nb-20 — Sources, time, and outside data

← Course mapChapter 20 / 25 · Advanced II

Northbridge course, intermediate (needs nb-01: First permit: facts, a rule and a question, nb-07: A document is not yet a proven fact, nb-08: Which edition applies and when the term expires). 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: TRUE_ONLY means established, NEITHER means established neither way.

2. Prerequisites

nb-01: First permit: facts, a rule and a question: 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: 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: 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).

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).

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).

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).

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).

@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).

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).

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).

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.

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).

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).

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));
}

{"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:

law --version

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:

law test packs/examples/language-demo/sourcetime

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:

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

article/2 (en)
article/2a (en)

~ article/2 (en)
+ article/2a (en)
- article/1 (en)

[{"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:

law engine consolidate /tmp/st-ir.json 'urn:law:demo:northbridge:sourcetime#Statute2025To2026' --protected article/2

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:

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

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:

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:

исполнение отказало: 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). 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.

10. Sources

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.
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.
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); the evidence pipeline mirrors demo.northbridge.register.
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 (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.

Documentation for Arxo. Writings — blog.arxo.io.

Anonymous visit counts on stats.arxo.io, no cookies.