# 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).
Why probe files use the `.law.txt` suffix 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.
## 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.