Markdown for LLMs
nb-20 — Sources, time, and outside data
The source Markdown for this article. Copy it into your assistant or download it as a text file.
# nb-20 — Sources, time, and outside data
*Northbridge course, intermediate (needs
[nb-01: First permit: facts, a rule and a question](/tutorials/northbridge/nb-01-first-permit/),
[nb-07: A document is not yet a proven fact](/tutorials/northbridge/nb-07-document-vs-fact/),
[nb-08: Which edition applies and when the term expires](/tutorials/northbridge/nb-08-edition-and-terms/)).
All law is fictional; every act, resident, file, rate, and snapshot is
synthetic and unofficial. No real deployment or legal-validity claims.
Tool `law 0.1.0`, language version `0.2`, semantics `law.core/0.2`,
std `0.2.0` (from `law --version`, quoted below).*
## 1. Situation
Mira, the Northbridge permits clerk, faces an audit of the overnight
parking files. The auditor asks four questions that turn out to be one
question asked four ways — *where did this answer come from?* A 2025
notice cites a text the 2026 amendment replaced. A Russian translation
exists but is not in force yet. A residency file reached the office
after the decision it should have supported. And the day rate the
office posts each morning arrives from a rate program, not from the
statute. Northbridge is synthetic; the audit is a pretext. The real
subject is provenance: pinned bytes behind every quotation, a
formalized amendment behind every edition change, three independent
time axes behind every answer, and a pinned snapshot behind every
number the office did not compute itself.
Every answer in this article carries its provenance. A
**publication** is the pinned file: media type, retrieval address,
and the hash of the bytes. A **fragment** is one citable passage
with its own hash. An **edition** is the dated text in force over
an interval, and a **revision** edge links two editions — with
**operations**, it carries the amendment itself as data. An
**entrenchment** shields one passage over a time window, and a
**reference** names a passage to be resolved at evaluation on one
axis.
Three independent time axes sit behind every answer:
**legal_time** selects the applicable law, **decision_time**
stamps when the office decides, and **knowledge_time** bounds
what the office may use. A **snapshot** is outside data pinned by
capability, binding, program hash, and content hash. Truth
statuses work as in
[nb-01: First permit: facts, a rule and a question](/tutorials/northbridge/nb-01-first-permit/):
`TRUE_ONLY` means established, `NEITHER` means established
neither way.
## 2. Prerequisites
[nb-01: First permit: facts, a rule and a question](/tutorials/northbridge/nb-01-first-permit/):
facts, strict rules, the four truth statuses, and `law test` as
the way to check a claim.
[nb-07: A document is not yet a proven fact](/tutorials/northbridge/nb-07-document-vs-fact/):
documents versus the facts they support — the evidence pipeline
this article drives with a late file.
[nb-08: Which edition applies and when the term expires](/tutorials/northbridge/nb-08-edition-and-terms/):
editions, anchored rules, the three time axes, deadline policies,
and terms — this article adds byte pinning, the amendment as
operations, entrenchment, references, regulated-event time, and
pinned snapshots on top of that machinery.
New here: `publication`, `fragment`, `align`, `revision` with `op`
blocks, `entrenchment`, `reference`, `scope`, `governs`,
`temporal_resolution_policy`, `event` with a `Date` time,
`external snapshot function`, and the stock operations
`law engine lower | consolidate | diff-editions | edition-state`.
Refusal codes met below: `LDC-E1307` (wrong resolution axis),
`LDC-E1315` (empty test selection), `LDC-E5401`/`LDC-E5403`
(consolidation mismatch / overlapping operations), `LDC-E5301`
(entrenched passage changed), `SOURCE_RESOLUTION_AMBIGUOUS`,
`SOURCE_RESOLUTION_FAILED`, `TEMPORAL_RESOLUTION_POLICY_MISSING`,
`EXTERNAL_UNAVAILABLE`, `EXTERNAL_SNAPSHOT_HASH_MISMATCH`,
`MISSING_POLICY`.
## 3. Minimal example
All excerpts are from `packs/examples/language-demo/sourcetime/package.law`
unless noted (identifiers as written; labels and unrelated
declarations cut). Standalones are complete files from
`packs/examples/language-demo/sourcetime/evidence/snippets/`.
Excerpt 1 — the work and its three editions (adopted dates, force
windows, and pinning promises cut to the bone; full blocks in the file).
```law
source OVERNIGHT_RULES {
kind municipal_act;
jurisdiction NORTHBRIDGE;
number "2026-1";
}
edition ORD_2025 of OVERNIGHT_RULES {
language en;
in_force [@2025-01-01, @2026-01-01);
materialization_status PINNED_OFFICIAL_BYTES;
}
edition ORD_2026_EN of OVERNIGHT_RULES {
language en;
in_force [@2026-01-01, infinity);
materialization_status PINNED_OFFICIAL_BYTES;
}
```
One idea: the English 2026 text replaces the 2025 text on
1 January 2026. (`PINNED_OFFICIAL_BYTES` promises every fragment
carries a hash and the bytes exist; the Russian edition, adopted
later and in force from 2027, is cut here.)
Look at the `in_force` windows: the 2025 interval ends exactly
where the 2026 interval begins, so one and only one English
edition applies on any date. Section 7 shows what breaks when
two editions overlap instead.
Excerpt 2 — one pinned file and one pinned passage (retrieval
metadata cut).
```law
publication ORD_2026_EN_TEXT of ORD_2026_EN {
content_hash "sha256:71f0914b2a0d9effd268b192b69174499143339eb5e5a3baa12d24cd527b069d";
local_path "sources/northbridge-overnight-2026-en.txt";
}
fragment PARKING_2026_ART2_EN in ORD_2026_EN {
kind article;
locator "article/2";
text en unofficial """A residential parking permit is issued to an applicant who resides in Northbridge and holds a vehicle registered at the residence address.""";
content_hash "sha256:735cd63214dfa9020bdd3c943ded78777eff1c8a1989e0d0bc4ab825abb91c41";
}
```
One idea: two hashes, two directions — the file must produce the
publication hash, and the quotation must hash to the fragment hash
*and* occur verbatim in the file.
The publication block checks the whole file through
`content_hash` and `local_path`. The fragment block checks the
quotation twice: its bytes must hash to the fragment hash, and
the same sentence must occur word for word in the file. Either
check can fail independently.
Excerpt 3 — the amendment as data: three operations, two dates
(relation and edge dates cut).
```law
revision Statute2025To2026 {
previous ORD_2025;
next ORD_2026_EN;
op replace {
locator "article/2";
language en;
text """A residential parking permit is issued to an applicant who resides in Northbridge and holds a vehicle registered at the residence address.""";
effective @2026-01-01;
}
op repeal {
locator "article/1";
effective @2026-01-01;
}
op insert {
locator "article/2a";
language en;
text """The office publishes the day rate before noon.""";
effective @2026-06-01;
}
}
```
One idea: operations carry the *result* text, not the instruction;
they apply by `effective` date, author order breaking ties.
Count the operations and their dates: `replace` and `repeal`
take effect on 1 January, the `insert` only on 1 June. The
replace arm carries the full new sentence — applying the
amendment means reconciling these result texts with the next
edition, which is what `consolidate` checks in section 4.
Excerpt 4 — the shield and the live link (windows and blocks cut
to their essence).
```law
entrenchment Art2Shield {
source OVERNIGHT_RULES;
locator "article/2";
window [@2027-01-01, @2028-01-01);
}
reference CurrentRateTable {
source OVERNIGHT_RULES;
locator "article/2a";
resolve_at legal_time;
}
```
One idea: article 2 is untouchable through 2027, while article 2a
is read fresh at every evaluation on the legal axis.
The shield names its passage and its window: `article/2`
through the whole of 2027. The reference names its passage and
its axis: `article/2a` resolved at `legal_time`. One freezes a
text against future amendments; the other re-reads a text at
every evaluation.
Excerpt 5 — anchored rules: the fragment decides *what the rule
says*, the window decides *when it speaks* (the `when`
conjunctions cut; each rule reads residence, the 2026 one also a
registered vehicle).
```law
@source(PARKING_2025_ART2)
rule OldResidencyNotice strict {
effective [@2025-01-01, @2026-01-01);
for a: Applicant;
then residency_notice(a);
}
@source(PARKING_2026_ART2_EN)
rule NewEligibilityNotice defeasible {
effective [@2026-01-01, infinity);
for a: Applicant;
then eligibility_notice(a);
}
```
One idea: the same facts conclude `residency_notice` in 2025 and
`eligibility_notice` in 2026 — different predicates, different
editions, no overlap.
Each rule carries two time pins: a `@source` anchor saying which
fragment it formalizes, and an `effective` window saying when it
speaks. The windows abut exactly like the editions in the first
block, so the two rules never fire together.
Excerpt 6 — scope is not `when` (binders cut; the full rule is in
the file).
```law
rule ScopedEligibility strict {
scope vehicle_registered(a);
when resident(a);
then scoped_notice(a);
}
```
One idea: `scope` merges semantically with `when` but is kept
separate for indexing and explanations — applicability reasoning
reads it without re-running the body.
Read the rule as a conjunction with two addresses: `scope
vehicle_registered(a)` states when the rule is even considered,
`when resident(a)` states what it then requires. The suite
checks both halves — the rule fires when the scope holds, and a
failed scope yields silence, not denial.
Excerpt 7 — governed versus plain support (binders cut).
```law
rule HearingWindowed strict {
governs event_time [@2026-01-01, infinity);
when hearing_filed(x, d);
then hearing_covered(x);
}
rule HearingPlain strict {
when hearing_filed(x, d);
then hearing_plain(x);
}
```
One idea: a bare `Date` fact is timeless on the `event_time`
axis — under `governs` it gives no support, without it the same
fact supports.
The two rules share the premise and the fact; their heads differ
only so the suite can tell the two conclusions apart. The `governs
event_time [...]` pin is the difference under test: the governed
rule stays silent while the plain rule concludes. That pin is what
the suite pair isolates.
Excerpt 8 — a day-stamped event resolved through the day policy
(states and transitions cut; the procedure moves `Draft` to
`Filed` on `FilingSubmitted`).
```law
temporal_resolution_policy NB_DAY_RESOLUTION {
utc_offset "+06:00";
day_boundary "00:00:00";
timezone "Asia/Almaty";
}
event FilingSubmitted {
filing: Filing;
}
```
One idea: a `Date` recorded as an event's `time` is not an
instant and never converts implicitly — the named policy maps
the day to `[start-of-day, start-of-next-day)` in `+06:00`.
The policy's three lines do the mapping: the UTC offset, the
day boundary, and the time zone together turn a calendar day
into an instant interval. Without this policy the same filing
refuses loudly instead of guessing, as section 8 records.
Excerpt 9 — the late file, from `tests/sourcetime.lawtest`
lines 70–71 (support, verification) and `package.law` lines 253–256,
262–263 (policy) and 265–269 (rule): the policy's five `input`
declarations (lines 257–261) cut, everything kept verbatim.
```law
support LateFile supports residency_proof(entity_ref("urn:demo:northbridge:ann"));
verification VLate { evidence LateFile; document_hash "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; verifier "urn:demo:northbridge:verifier"; outcome verified; recorded @2026-02-02T09:00:00Z; }
evidence policy OfficeFilePolicy {
profile "law.core.evidence-policy/0.1";
accepts accepted;
protects residency_proof;
rule Accept;
}
rule ProofAdmits strict {
for a: Applicant;
when residency_proof(a);
then resident_admitted(a);
}
```
One idea: protection plus verification admits the proof — but
only inside office knowledge, which is what the next section
varies.
Follow the chain across the four declarations: the `support`
edge links the file to the residency statement, the
`verification` record checks its hash and outcome, the evidence
policy protects that predicate, and the rule admits what the
pipeline lets through. Section 4 runs this chain twice — once
before the office knows the file, once after.
Excerpt 10 — term, deadline, calendar (policy fields and duty
body cut).
```law
term AppealWindow(a: Applicant, filed_on: Date) {
from application_filed(a, filed_on);
due appeal_decided(a);
default 30 calendar_day;
case FastTrack when urgent_appeal(a): 10 calendar_day;
}
calendar NorthbridgeCalendar {
timezone "Asia/Almaty";
resource "resources/northbridge-calendar-2026.json";
content_hash "sha256:344b43d6a1060fe139378ab2de8d30a85abab0d1584891c93cd8f38713ccd6ee";
}
```
One idea: the term names the deadline shape, the calendar names
the counted days, the policy names how to count — three
declarations, three jobs.
The term block reads like a small table: `from` the filing,
`due` the decision, `default` thirty calendar days, and one
`case` — urgent appeals get ten. The calendar pins which days
count through a resource file and its hash. Section 6 changes
only the urgency flag and watches the due date move.
Excerpt 11 — the outside number: capability, binding, call
(snapshot `id`, `programHash`, and `contentHash` cut, whitespace
compacted; values byte-identical; the file is
`tests/snapshots/day-rates.json`).
```law
external snapshot function day_rate(pair: Text) -> Decimal {
capability "demo.northbridge.day-rate/1";
snapshot_from context.day_rates;
}
rule PostDayRate strict {
when rate_proof(x) and rate_key(x, p);
then rate_posted(x, day_rate(p));
}
```
```json
{"symbol": "urn:law:demo:northbridge:sourcetime#day_rate",
"args": [{"kind": "value", "type": {"name": "urn:law:std#Text"},
"value": "USD-KZT-2026-03-02"}],
"result": {"kind": "value", "type": {"name": "urn:law:std#Decimal"},
"value": "512.5"}}
```
One idea: the rule never computes the rate — it calls a pinned
function whose answer lives in the snapshot file, keyed by the
case and hashed twice (content hash inside, manifest hash
outside).
The declaration names the capability and the binding
(`snapshot_from context.day_rates`) but no computation. The rule
calls `day_rate(p)` like any function; the JSON row supplies the
pinned answer `512.5` for the key `USD-KZT-2026-03-02`. Section
4 shows all three fates of such a call: posted when pinned,
unavailable when absent, refused when tampered.
## 4. Command and result
Record the build first:
```sh
law --version
```
```text
law 0.1.0
семантика: law.core/0.2
std для языка 0.2: 0.2.0
```
The Russian lines name the semantics (`law.core/0.2`) and the
standard library for language 0.2 (`0.2.0`). Every status below
holds for exactly this build.
Run the suite:
```sh
law test packs/examples/language-demo/sourcetime
```
```text
law test demo.northbridge.sourcetime: мир demo.northbridge.sourcetime
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / 2025 edition: the old reading holds in its window
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / 2026 edition: the new reading holds
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / before entry into force the 2026 rule is silent
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / late file: unknown while the office has no knowledge
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / late file: admitted once the office knows it
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / decision day alone moves no law, 1 March
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / decision day alone moves no law, 6 March
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / scoped rule fires when the scope holds
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / a failed scope is silence, not denial
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / timeless support under governs is no support
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / the same fact without governs is support
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / day-stamped filing moves the case
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / appeal window: thirty days by default
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / appeal window: ten days on the fast track
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / working days: the reply is on time
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / working days: silence after the window is a breach
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / without a policy working days are not counted
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / a rate without a snapshot is unavailable
ok [demo.northbridge.sourcetime] tests/snapshots-ok.lawtest / the pinned day rate is posted
ok [demo.northbridge.sourcetime] tests/snapshots-tampered.lawtest / a tampered snapshot is refused loudly
итого: 20 проверено, 20 прошли, 0 не прошли, 0 не исполнены; код 0
```
All 20 tests pass. The summary is in Russian: 20 checked, 20
passed, 0 failed, 0 skipped, exit code 0. Read the test names as
a map of the article: three edition tests, two late-file tests,
two decision-day tests, two scope tests, two `governs` tests,
one day-stamped filing, two appeal-window terms, three
working-day tests, and three snapshot tests. A passing test
means the answer matched its expectation — it does not mean the
overnight files survived the audit.
The edition operations run off the lowered program. Lower it
once to a scratch file (outside the package — generated bytes do
not belong in it), then ask the three questions:
```sh
law engine lower packs/examples/language-demo/sourcetime > /tmp/st-ir.json
law engine consolidate /tmp/st-ir.json 'urn:law:demo:northbridge:sourcetime#Statute2025To2026'
law engine diff-editions /tmp/st-ir.json 'urn:law:demo:northbridge:sourcetime#ORD_2025' 'urn:law:demo:northbridge:sourcetime#ORD_2026_EN'
law engine edition-state /tmp/st-ir.json --legal-time 2026-06-01
```
```text
article/2 (en)
article/2a (en)
```
```text
~ article/2 (en)
+ article/2a (en)
- article/1 (en)
```
```text
[{"diagnostics":[],"id":"urn:law:demo:northbridge:sourcetime#ORD_2025","state":{"mismatched":null,"since":"2025-01-01","state":"closed","status":"in_force"}},{"diagnostics":[],"id":"urn:law:demo:northbridge:sourcetime#ORD_2026_EN","state":{"mismatched":null,"since":"2026-01-01","state":"applicable","status":"in_force"}},{"diagnostics":[],"id":"urn:law:demo:northbridge:sourcetime#ORD_2026_RU","state":{"mismatched":null,"since":null,"state":"not_yet","status":null}}]
```
The first answer lists the consolidated 2026 projection:
articles 2 and 2a in English. Consolidation confirms that
`apply(previous, operations)` is exactly the `next` projection —
the repealed article 1 is gone, as it should be.
The second answer spells the amendment as a diff: `~` marks the
replaced article 2, `+` the added article 2a, `-` the removed
article 1. The third answer is the edition state at 1 June 2026:
the 2025 edition is `closed`, the English 2026 is `applicable`,
and the Russian 2026 is `not_yet`. Exactly one edition applies
on that legal date — which is also why the live reference
resolves instead of refusing.
The protection half is one flag away:
```sh
law engine consolidate /tmp/st-ir.json 'urn:law:demo:northbridge:sourcetime#Statute2025To2026' --protected article/2
```
```text
article/2 (en)
article/2a (en)
LDC-E5301: редакция urn:law:demo:northbridge:sourcetime#ORD_2026_EN: изменён защищённый фрагмент article/2 (en) при неизменяемом положении article/2 — поправка неправомерна независимо от соблюдения процедуры изменения
```
(exit 1). The consolidation is listed first, then refused: the
amendment touches the shielded passage, and no procedure cures
that. In Russian, the diagnostic says that the 2026 edition
changed the protected article 2 fragment under an unchangeable
provision — the amendment is unlawful regardless of whether the
change procedure was followed.
Reproducibility is byte equality, not a feeling:
```sh
law test --json packs/examples/language-demo/sourcetime > /tmp/rep1.json
law test --json packs/examples/language-demo/sourcetime > /tmp/rep2.json
cmp /tmp/rep1.json /tmp/rep2.json && echo REPRODUCIBLE
```
```text
REPRODUCIBLE
```
Two structured runs of the whole suite produce byte-identical
JSON: the same bytes in, the same bytes out. `cmp` stays silent
on identical files, so the echoed word is the verdict.
## 5. Why this construct
Each declaration earns its place by an observation no other
declaration produces.
The publication hash catches a changed byte in the file; the
fragment hash catches a retyped word in the quotation; `E5202`
catches a quotation that drifted out of its file. Three checks,
three different failures.
The revision operations catch a mis-described amendment at
`lower` time (`E5401`), and overlapping operations are rejected
before any ordering question arises (`E5403`). The amendment is
data, so a wrong amendment fails before any rule runs.
The reference resolves on the legal axis, or the whole
evaluation refuses — silence is never an answer to "which text?".
Entrenchment makes one class of future amendments unstatable
(`E5301`), with segment-bounded scope: `article/2` shields its
children, not `article/20`.
The three axes vary independently: legal time flips the
applicable law, knowledge time admits or cuts the late file, and
decision time stamps without switching the law. The suite moves
each axis while holding the others — the two decision-day tests
change the stamp and move no law.
The day policy turns a calendar day into an instant interval;
without it the same filing is a loud
`TEMPORAL_RESOLUTION_POLICY_MISSING`, never a guess. The
snapshot turns an outside number into pinned data: present and
hashed it posts, absent it is `EXTERNAL_UNAVAILABLE`, altered it
is `EXTERNAL_SNAPSHOT_HASH_MISMATCH` — and the same bytes twice
give the same bytes back.
What this does NOT prove: the Russian translation is aligned,
not equivalent — `align` records a reviewed correspondence and
creates no logical link between the two formalizations. The
consolidation check compares fragment projections, not legal
meaning. The snapshot's `programHash` pins the producing
program's semantic hash; it says nothing about whether that
program computed correctly.
## 6. Changed condition
File the same application as urgent. Everything else — filing
date, legal time, knowledge — stays put:
```text
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / appeal window: thirty days by default
ok [demo.northbridge.sourcetime] tests/sourcetime.lawtest / appeal window: ten days on the fast track
```
The change is one added fact: the urgency flag. The default test
expects `appeal_decided(ann, @2026-03-03)` (`TRUE_ONLY`); the
urgent test expects `appeal_decided(ann, @2026-02-11)`
(`TRUE_ONLY`). The `FastTrack` case moves the due date twenty
days earlier, because the term's `case` arm overrides the
thirty-day default with ten days. One added fact, one earlier
deadline, no other answer touched.
## 7. Typical mistake
The mistake is giving the Russian translation the same force
window as the English text — two editions, one period, no
resolver between them. The observed consequence is that the
suite fails on every 2026 case, all with one diagnostic:
```text
исполнение отказало: SOURCE_RESOLUTION_AMBIGUOUS reference urn:law:demo:northbridge:sourcetime#CurrentRateTable: на legal_time 2026-03-01 применимы несколько editions источника urn:law:demo:northbridge:sourcetime#OVERNIGHT_RULES: urn:law:demo:northbridge:sourcetime#ORD_2026_EN, urn:law:demo:northbridge:sourcetime#ORD_2026_RU (§30.2; выбор требует policy §82)
```
In Russian, the diagnostic says that execution is refused:
several editions of the source apply at that legal time, and
choosing between them requires a policy ([§82](https://github.com/arxohq/law/blob/master/spec/SPEC.ru/12-part-xii-events-actions-temporal-model.ru.md#82-temporal-axes)). The fix is the
one this package uses: disjoint force windows — the Russian text
enters into force in 2027, so exactly one edition is applicable
on any 2026 legal date. A named resolver policy would be the
other fix; none is declarable in the `0.2` surface, and the
engine refuses to guess instead.
## 8. Limits
Verified profile: `law 0.1.0`, `law.core/0.2` (semantics
`law.core/0.2.4`, std `0.2.0`). Every refusal below is a fact
about this profile and tool, never a claim about the language
in general.
The only resolution axis is `legal_time`. Any other axis is
refused statically (`LDC-E1307`, snippet
`evidence/snippets/dynamic-axis.law.txt`, exit 1).
Two same-period editions of one source are unresolvable:
`SOURCE_RESOLUTION_AMBIGUOUS`, exit 1 per test. No resolver
policy is declarable in `0.2`; the engine names the missing
policy instead of choosing.
A reference with no applicable edition fails the whole run:
`SOURCE_RESOLUTION_FAILED`. This was observed by moving the
English 2026 edition out of force: 2 passed, 18 failed, exit 1;
restored: 20 passed, exit 0. Only the 2025 cases survived —
resolution is per legal date.
A `Date` never converts to an `Instant` implicitly. Direct
comparison is refused statically; an event's `Date` time
resolves only through a declared day policy, and without one the
run fails loudly (`TEMPORAL_RESOLUTION_POLICY_MISSING`, snippet
pair `day-filing-nopolicy.lawtest` /
`day-without-policy.law.txt`, exit 1). The suite test names its
policy explicitly (`temporal_resolution_policy
NB_DAY_RESOLUTION;`); with the single declared policy that axis
agrees with automatic selection.
Snapshot values are read strictly: a non-canonical `Decimal`
form (`512.50` for `512.5`) leaves the call unfound
(`EXTERNAL_UNAVAILABLE`). Write canonical forms.
`recorded`/`observed` on a bare assertion do not cut it against
`knowledge_time` (verified: still `TRUE_ONLY`). The knowledge
cutoff observed here works through the evidence pipeline
(document `recorded_at` plus verification against case
knowledge), not through assertion fields.
An empty selection is not green silence: `law engine test
evidence/snippets/empty-selection.lawtest --program package.law`
refuses `LDC-E1315`, exit 1 (paths relative to the package
directory).
<details>
<summary>Why probe files use the `.law.txt` suffix</summary>
The package scanner reads every `.law` file, including files
under `evidence/`. Probe files that must not join the package
world therefore use the `.law.txt` suffix. Likewise,
`.lawtest` probes in `evidence/snippets/` are never listed in
any manifest part and never run with the suite.
</details>
## 9. Exercise
The council adds quiet hours as article 2b, in force with the
June 2026 wave: insert the locator `article/2b` with the English
text `Quiet hours are 23:00 to 07:00.` into the 2026 edition
(fragment plus operation, same `effective` as the 2a insert),
and add the sentence to
`sources/northbridge-overnight-2026-en.txt`.
Predict, then verify: the exact `consolidate` listing, the exact
`diff-editions` output against `ORD_2025`, and the new fragment
hash. Check your work against the
[full solution with the patched bytes and hashes](/tutorials/northbridge/solutions/nb-20-solutions/).
## 10. Sources
1. **Northbridge use** (this article): byte-pinned overnight
parking texts, the 2025→2026 amendment as three operations,
the 2027 shield on article 2, the live article-2a reference,
three independent time axes, the late residency file, the
appeal term with a working-day reply duty, and the pinned day
rate — verified by the 20 sourcetime tests above.
2. **Domain template:** pin every quoted byte and every file;
write each amendment as result-carrying operations checked by
consolidation; shield passages by locator segments and a
window; resolve references on exactly one axis and keep force
windows disjoint per period; drive applicability from
`legal_time`, admittance from `knowledge_time`, and stamp with
`decision_time`; count every deadline under a named policy
over a pinned calendar; never compute outside numbers —
snapshot them with capability, binding, program, and content
hashes.
3. **Confirmed example elsewhere:** the day-rate snapshot follows
the pinned-snapshot shape of the `kz.corpus.gesv_rules`
package — `external snapshot function` with `capability` and
`snapshot_from`, suites split by snapshot part (provided /
missing / tampered), content hash inside the file and in the
manifest — verifiable at
`corpus/laws/kz/regulators/gesv-rules/` (manifest
`external_snapshots`, `tests/snapshots/gesv-snapshot.json`).
The edition/term/axis half mirrors
`demo.northbridge.sources`
([nb-08: Which edition applies and when the term expires](/tutorials/northbridge/nb-08-edition-and-terms/));
the evidence pipeline mirrors `demo.northbridge.register`.
4. **Confirmed external formalization (corpus):** package identity
and pinning (Civil Code of Kazakhstan) — package
`kz.corpus.civilcode`,
`corpus/laws/kz/codes/civil-code/00-package.law:42-78`. The
package holds a source/edition/publication chain with per-norm
anchors: three identity levels told apart (`source GK_RK`
kind code, dated `edition`, `publication` with portal URI,
`retrieved_at`, content hash and local bytes), honest
`PINNED_UNOFFICIAL_COPY` status, and per-norm `@source`
anchors across sibling files. Evidence:
`docs/research/constructs/22-sources/corpus-forms.en.md` [§1](/tutorials/northbridge/nb-01-first-permit/#1-situation)
(rated exemplary). Limit of verification: presence of the
named construct at the cited lines only, confirmed by direct
file read; no claim about deployment, runtime behaviour, or
legal correctness.