@cruba/crubal 0.0.0-stage → 0.2.0

package/dist/src/store.d.ts

@@ -0,0 +1,164 @@
+import { type ClassLine, type Dictionary } from "./defs.ts";
+import type { Json, JsonObject, Record, Source } from "./model.ts";
+export declare function sha256(text: string): string;
+/** A write's hash: SHA-256 of its canonical form; a redacted write's hash is what it carries (8.5.2). */
+export declare function writeHash(w: Json): string;
+/**
+ * An entry's hash (8.5): SHA-256 of its canonical form without `sig`, each write replaced by `sha256:` and
+ * its own hash, so a redacted write leaves the entry's hash where it was. A redacted entry's hash is what it
+ * carries.
+ */
+export declare function entryHash(entry: JsonObject): string;
+/** Published keys by owner domain: `{ "test.example": { "alg": "Ed25519", "public": "<base64url>" } }`. */
+/** A published signing key (11.7): with `from` and `until` when it was rotated, so it still verifies what it signed. */
+export type Key = {
+    alg: string;
+    public: string;
+    from?: string;
+    until?: string;
+};
+export type Keys = {
+    [owner: string]: Key | Key[];
+};
+/** The owner's key in force at a moment: the one whose span holds `at`, else an undated one, else the latest. */
+export declare function keyFor(keys: Keys, owner: string, at?: string): Key | undefined;
+/** Does `sig` (base64url) verify over the entry's hash bytes with the owner's Ed25519 key? */
+export declare function verifySig(entry: JsonObject, owner: string, keys: Keys): boolean;
+/** Check a chain's links, and, when the owner's key is known, every entry's signature (8.5). */
+export declare function verifyChain(entries: JsonObject[], keys?: Keys): {
+    valid: boolean;
+    "breaks-at"?: string;
+    reason?: string;
+};
+export type MapLine = {
+    from: string;
+    to: string;
+    values: [string, string][];
+    line: number;
+    valueLines: number[];
+};
+export type Contract = {
+    name: string;
+    kind: string;
+    origin: string;
+    prefix?: string;
+    reads: MapLine[];
+    writes: MapLine[];
+    /** A store contract's one map (7.3): `reads` and `writes` are derived from it. */
+    stores: MapLine[];
+    /** An offer's terms (7.8): reshare, expires, revocable, and what else the package names. */
+    terms: {
+        [term: string]: string;
+    };
+    ignore: string[];
+    keepRaw: string[];
+    absorb: boolean;
+    lands: string;
+    line: number;
+    /** needs: an unnamed class (7.2) */
+    needs: ClassLine[];
+    gives: string[];
+    who?: string;
+    when?: string;
+    from?: string;
+    to?: string;
+    mode?: string;
+    undo?: string;
+    /** The field of their payload that is their own ID for the thing (9.2a). */
+    ref?: string;
+    /** For a send contract that carries projection streams (12.6.2): the views. */
+    stream: string[];
+    /** Every part as written, with its line, for the publish checks. */
+    parts: {
+        [k: string]: string;
+    };
+    partLines: {
+        [k: string]: number;
+    };
+};
+/** Read `contract:` blocks. */
+export declare function readContracts(source: string): Contract[];
+/** Split a field path into names: `aspects."Run Time"` → ["aspects", "Run Time"]. */
+export declare function fieldPath(path: string): string[];
+export type IntakeOutcome = {
+    from: string;
+    to?: string;
+    outcome: string;
+    value?: Json;
+    cites?: JsonObject;
+};
+export type IntakeRecord = {
+    intake: string;
+    contract: string;
+    for: string;
+    received?: string;
+    raw: {
+        type: string;
+        sha256: string;
+        body: string;
+    };
+    outcomes: IntakeOutcome[];
+};
+/** Keep a payload's exact bytes (3.8): as text when they are valid UTF-8, otherwise as base64. */
+export declare function rawOf(bytes: Uint8Array, type: string): {
+    type: string;
+    sha256: string;
+    body?: string;
+    base64?: string;
+};
+/** Replay an intake record from its kept bytes under the current contract (9.6); earlier outcomes stay. */
+export declare function replay(intake: IntakeRecord & {
+    replays?: JsonObject[];
+}, c: Contract, dict: Dictionary): IntakeRecord & {
+    replays: JsonObject[];
+};
+/** Review by key across every intake record (9.5), and candidate facets proposed by recurrence. */
+export declare function reviewByKey(intakes: {
+    for: string;
+    outcomes: IntakeOutcome[];
+}[], recur?: number): {
+    "by-key": JsonObject[];
+    proposals: JsonObject[];
+};
+/** Receive a raw payload through a contract: every field gets exactly one outcome. The bytes are kept. */
+export declare function receive(c: Contract, body: string, forRecord: string, dict: Dictionary, intakeId?: string): IntakeRecord;
+/** Who a source is, for the trust order (11.3): a person, a contract, a party's domain, and its origin. */
+export type Who = {
+    source: Source;
+    person?: boolean;
+    contract?: string;
+};
+/**
+ * Land an intake record's outcomes on a record. Absorbed and conflicting values go through the trust
+ * order: the winner is current, the loser is kept as an alternative. Equal values are agreement.
+ */
+export declare function land(r: Record, intake: {
+    outcomes: IntakeOutcome[];
+    contract?: string; /** a person's write through a form (11.3): ranks as `person` */
+    person?: boolean;
+}, source: Source, trust?: string[], facetTrust?: Map<string, string[]>, 
+/** The facets declared `transitions: yes` (4.2): a later value of equal or higher trust replaces, never conflicts. */
+transitions?: Set<string>): Record;
+export type PartMatch = {
+    parts: JsonObject[];
+    review: JsonObject[];
+};
+/** Bind incoming parts to existing ones: by the slot's match child, else review, else a new row. */
+export declare function matchParts(r: Record, incoming: {
+    slot: string;
+    [k: string]: Json;
+}[], dict: Dictionary): PartMatch;
+export type Observation = JsonObject & {
+    obs: string;
+    on: string;
+    address: string;
+    supports: string;
+};
+/** Validate a value from observations: independent witnesses for and against, vetoes, and the state. */
+export declare function validate(r: Record, address: string, observations: Observation[], confirmAt?: number, splitAt?: number): JsonObject;
+/**
+ * Version splits proposed (9.7.3): for each value an address's observations contradict, a cluster of at
+ * least `splitAt` instances agreeing with each other is a review item `split:<record>`; nothing splits
+ * on its own.
+ */
+export declare function proposeSplit(records: Record[], observations: Observation[], splitAt?: number): JsonObject[];