@arxo/law

Ask a pinned canon a closed question. Get the answer, its proof and three hashes anyone can replay. A canon is a law, a standard or a rulebook compiled to a package; the engine runs locally in WebAssembly, offline after install, with byte-identical answers on every machine.

Quickstart · How it works · Questions · Facts · Answer · Run it anywhere · Packages · Canons · API

Quickstart

npm i @arxo/[email protected] @arxo/[email protected]

A 14-day period starts with an event on Saturday 7 March 2026. When does it end? (§§ 187, 188, 193 of the German Civil Code)

import { open } from '@arxo/law';

const bgb = await open('[email protected]', { offline: true });
const end = await bgb.collect('frist_ende', ['frist', '?end'], {
  legalTime: '2026-09-17', timezone: 'Europe/Berlin',
  decisionTime: '2026-09-17T09:00:00Z', knowledgeTime: '2026-09-17T09:00:00Z',
  deadlinePolicy: 'urn:de:corpus:clir:bgb-fristen#BGB_FRISTEN_TAG',
  answers: [{ predicate: 'frist_ereignis', args: ['frist', '2026-03-07'] },
    { predicate: 'frist_dauer_tage', args: ['frist', '14 calendar_day'] },
  ],
});

Output — produced by this exact call and checked on every build. Fourteen days from 7 March land on Saturday 21 March, so § 193 moves the end to the next working day:

end.evaluationStatus    // 'COMPUTED'
end.value[0].value      // '2026-03-23'  (Mon, 23 Mar 2026)
end.proof.nodes.length  // 4: two facts → rule TagesfristEnde → the question
end.hashes.result       // 'sha256:b2faa3a5…'  (with program and semantic)
end.document            // 4423 canonical bytes — replay them anywhere

Want a ready TypeScript project with this question and a test? npm create arxo@latest my-app.

What comes back

Every answer carries the proof graph the engine built, the norms it relied on with their pinned text, and the canonical evaluation document. The package itself is transport, case assembly and field projection: there is no second evaluator, and a refusal is a value, not an exception.

How it works

The same mechanics run any canon — a statute, a technical standard, a rulebook or a table of constants. A model can formalize a text; the engine executes it and proves every answer.

Five questions

One ask underneath; pick the shape of the question.

Two more read the result rather than ask a new question: whyNot(p, args, case) returns the blocker graph of a NEITHER, and unfold(p, { depth }) prints the rules that produce p and their premises, anchored to the pinned text, with no case at all.

Facts

Facts are { predicate, args, state }. Values are bare; the package's declarations type them:

Three states, not two: 'yes' (the default for a listed fact), 'no' (an explicit negative assertion) and 'unknown'. A fact you do not list is unknown; nothing is defaulted.

An unknown relation, a wrong arity, a wrong type or an unknown enum variant throws FactError with the path and the nearest names before the engine runs — which makes the package a safe check layer behind an LLM agent: the model proposes facts, Arxo evaluates and proves.

The answer

"Not in the model" and "the law is silent" are different answers: pkg.passport() repeats the package's formalization measure (EXECUTABLE, SOURCE_ONLY, …) and pkg.inModel(predicate) says whether a name exists at all. pkg.explain(answer) returns the host's text over the same proof.

Exceptions are only for the facade's own failures: FactError, PackageNotFoundError, IntegrityError, TransportError, RpcError.

Run it anywhere

The same methods and the same answer shape on every route.

import { open } from '@arxo/law';
const fristen = await open('[email protected]', { offline: true });

import { open } from '@arxo/law/browser';   // or the `browser` export condition
import ir from '@arxo/canon-bgb-fristen/package.lawir.json';

const fristen = await open('[email protected]', {
  wasm: fetch('/law_wasm_core.wasm'),
  canons: { '[email protected]': { ir, calendar } },
});

const picc = await open('[email protected]', { remote: true });

import { route } from '@arxo/law/router';
const r = await route('Wann endet eine 14-Tage-Frist ab 6. März 2026?', { legalTime: '2026-09-17', answers });

import { openCasePackage } from '@arxo/law/case-package';

const pkg = await openCasePackage('/path/to/case-package');
const accident = pkg.case('Collision');
accident.questions();                      // saved queries and question cards
const answer = await accident.ask('positions');

await accident.proposeFacts('facts.json', { by: 'urn:example:operator', at: '2026-09-17T12:00:00+05:00' });
await accident.acceptFact('p-0001', { by: 'urn:example:operator', at: '2026-09-17T12:00:00+05:00' });

const law = await open('[email protected]', {
  serve: { endpoint: 'http://127.0.0.1:8480', token: process.env.LAW_SERVE_TOKEN },
});
const answer = await law.ask('Prosrochka', { kind: 'positions', queryId: 'positions' });
answer.documentBytes;   // the exact embedded evaluation document

import { openContainer } from '@arxo/law/arxo';

const box = await openContainer('https://example.org/ogpo-batch.arxo', { wasm: fetch('/law_wasm.wasm') });
await box.inspect();          // descriptor, containerHash, signature — a few KB of the file
await box.replay('001');      // re-evaluates a saved answer: replay.same, replay.document

Packages

Canons

Each @arxo/canon-* package adds its relation names to the CanonRegistry type, so a misspelled predicate is an editor error. Answer, Fact, CaseInput and the status unions come from @arxo/law-types.

API

open(spec, options?)

spec is 'name@version'. Returns a package with the methods above.

Case input

Errors

Examples

recipes/ holds four 20-line examples, each run in CI: a term end (BGB), a computed value (Kazakh motor insurance), a condition (UNIDROIT) and the check layer behind an LLM agent.

Performance

Wasm cold start 77 ms, one truth question 40 ms, law_wasm_core.wasm 4.7 MB (node bench/measure.mjs, 2026-09-21, darwin 24.6, developer laptop).

Links

arxo.io · Changelog · @arxo/law-engine — the engine without the facade · @arxo/law-types — types · Apache-2.0