@affiant/core 0.1.0-alpha.0

package/dist/model/affidavit.d.ts

@@ -0,0 +1,354 @@
+/**
+ * The Affidavit: the sworn evidence record for one proposed write, its fields, the
+ * three confidence numbers, and the mapping to and from the wire shape.
+ *
+ * **Rules served: AF-1** (`fields[]` carries only the proposed fields; unknown
+ * provenance is present and tagged `Empty`, a field the operation does not propose
+ * is absent), **AF-2** (three confidence numbers, `aggregateConfidence` the
+ * *minimum* over proposed fields with `Empty` counting as `0`), **AF-3**
+ * (`entityId` non-null ⇔ update; an update carries a `previousValue` key on every
+ * proposed field, `null` where the field had no stored value), **SR-2** (money is a
+ * decimal string plus an ISO 4217 code — the shape only; the validator is pull
+ * request C3).
+ *
+ * Why AF-2 is a minimum and not a mean: a mean that first discards every `Empty`
+ * field lets a mostly-empty Affidavit report high confidence, which is the exact
+ * hole once provenance authorises writes. The shipped .NET projection computes a
+ * mean over non-`Empty` fields; the parity manifest names it.
+ *
+ * Nothing here reads a clock or a database. `createdAt` is passed in and
+ * `previousValue` comes from the host's projection port.
+ *
+ * @packageDocumentation
+ */
+import type { Affidavit as WireAffidavit, EvidenceCardRequest as WireEvidenceCardRequest, FieldPresentation, JsonValue } from "@affiant/contract";
+import type { Operation } from "../ports.js";
+import { type ProvenanceChain } from "./provenance.js";
+/**
+ * Any value that survives a round trip through JSON, re-exported from
+ * `@affiant/contract` so the gate and the wire agree on one definition of what a
+ * field value may be. `null` is a value; `undefined` is not.
+ */
+export type { JsonValue };
+/**
+ * Whether `value` is a {@link JsonValue}: no `undefined`, no function, no symbol, no
+ * `NaN` or infinity, no cycle.
+ *
+ * Checked deeply, because a field value is carried onto a record a person is asked
+ * to swear to and later hashed into a canonical form (SR-1); a value that
+ * serialises to something different from what the reviewer saw is the failure mode
+ * this closes.
+ */
+export declare function isJsonValue(value: unknown): value is JsonValue;
+/**
+ * Money is one definition, and it lives in `./money.ts` — the SR-2 module, which
+ * owns the {@link Money} shape, the decimal-string and ISO 4217 validators, and the
+ * scale check a host declares. Re-exported here because an Affidavit is where a
+ * caller meets a monetary field, and because the export path `@affiant/core` offers
+ * should not depend on which pull request wrote which half.
+ *
+ * Note that `isMoney` **validates**: it is `false` for `{ amount: "1e3" }` and for
+ * `{ currency: "usd" }`, not only for a missing property. A shape-only guard on a
+ * public surface would answer "yes, money" for values SR-2 refuses, which is the
+ * wrong answer to give a host that is about to swear to one.
+ */
+export { isMoney } from "./money.js";
+export type { Money } from "./money.js";
+/** How a reviewer surface should render a field. Same set as the wire's. */
+export type AffidavitFieldKind = "text" | "number" | "date" | "enum";
+/** Every {@link AffidavitFieldKind}. */
+export declare const AFFIDAVIT_FIELD_KINDS: readonly ["text", "number", "date", "enum"];
+/**
+ * One sworn field: the proposed value, the value it replaces, and the whole
+ * provenance chain behind it.
+ *
+ * `previousValue` is `null` on a create and on an update field that had no stored
+ * value; the two are distinguished by the Affidavit's `operationType`, not by the
+ * field (AF-3).
+ */
+export interface AffidavitField {
+    /** The field's name on the target entity. The key amendments use. */
+    readonly name: string;
+    /** Rendering hint for a reviewer surface. */
+    readonly kind: AffidavitFieldKind;
+    /** The proposed value. */
+    readonly value: JsonValue;
+    /** The value being replaced, or `null` (AF-3). */
+    readonly previousValue: JsonValue | null;
+    /** Where the value came from, and everything it displaced. */
+    readonly provenance: ProvenanceChain;
+    /** Whether the target entity requires the field. */
+    readonly isMandatory: boolean;
+}
+/**
+ * The sworn evidence record for one proposed write.
+ *
+ * `operationType` is the protocol's own two-valued vocabulary rather than the
+ * host's operation name, because AF-3 is a rule about the *shape* — an update names
+ * the entity it updates and swears to what it replaces — and "create-only" has to
+ * be a predicate a policy can test without knowing the host's verbs. The host's own
+ * verb travels beside the record, never on it, and the v0.1 wire has no slot for
+ * it at all — a card carries the shape, and the host keeps its own vocabulary.
+ */
+export interface Affidavit {
+    /**
+     * The protocol version this record conforms to (SR-4).
+     *
+     * **On the record, not only on the wire.** `schemas/0.1.0/affidavit.schema.json`
+     * requires `protocolVersion` on an Affidavit, and SR-1 takes the canonical form
+     * over the Affidavit *as the schema defines it* — so a runtime model that carried
+     * it only on the way out would hash a document the protocol does not have. It
+     * did, until this version: `toWire` stamped the version and the canonical form
+     * over the model omitted it, so the bytes a Docket row's `canonicalHash` was
+     * taken over were not the bytes of the record the same row put on a card. Every
+     * canonical byte vector in the conformance suite carries the property; the model
+     * now carries it too, and the two paths produce identical bytes for one record.
+     *
+     * Set from `PROTOCOL_VERSION` when a record is built, kept as it arrived when one
+     * is read off the wire (a newer minor is accepted and is not rewritten to this
+     * version — re-emitting a record under a tag it did not arrive under would be
+     * forging its provenance), and carried unchanged through an amendment.
+     */
+    readonly protocolVersion: string;
+    /** `create` when nothing exists yet; `update` when an entity is being changed. */
+    readonly operationType: "create" | "update";
+    /** The kind of domain entity being written, named by the host. */
+    readonly entityType: string;
+    /** The entity being written; `null` on a create, non-null on an update (AF-3). */
+    readonly entityId: string | null;
+    /** The sworn fields, in the order the operation proposed them. */
+    readonly fields: readonly AffidavitField[];
+    /** Minimum confidence over every proposed field, `Empty` counting as `0` (AF-2). */
+    readonly aggregateConfidence: number;
+    /**
+     * Minimum confidence over the non-`Empty` proposed fields, or `null` when there
+     * are none (AF-2). `null` rather than `0`: "there is nothing populated to be
+     * confident about" is a different statement from "the populated fields are
+     * worthless", and a card showing `0` would say the second.
+     */
+    readonly populatedConfidence: number | null;
+    /** How many proposed fields are tagged `Empty` (AF-2). */
+    readonly emptyFieldCount: number;
+    /** The conversation turn the proposal was made on, or `null`. */
+    readonly conversationTurn: number | null;
+    /** When the Affidavit was built, as an ISO 8601 instant. */
+    readonly createdAt: string;
+}
+/** The three numbers AF-2 requires a card to show. */
+export interface ConfidenceNumbers {
+    /** Minimum over every proposed field, `Empty` counting as `0`. */
+    readonly aggregateConfidence: number;
+    /** Minimum over the non-`Empty` proposed fields; `null` when there are none. */
+    readonly populatedConfidence: number | null;
+    /** How many proposed fields are tagged `Empty`. */
+    readonly emptyFieldCount: number;
+}
+/**
+ * The three confidence numbers over `fields` (AF-2).
+ *
+ * - `aggregateConfidence` is the **minimum** over every proposed field, with an
+ *   `Empty` field counting as `0` whatever its tag says — so it is `0` exactly when
+ *   some proposed field has unknown provenance.
+ * - `populatedConfidence` is the minimum over the non-`Empty` fields, and **`null`**
+ *   when there are none. `null` rather than `0`: "there is nothing populated to be
+ *   confident about" is a different statement from "the populated fields are
+ *   worthless", and a card that showed `0` would say the second.
+ * - `emptyFieldCount` counts the `Empty` fields.
+ *
+ * An Affidavit with no fields at all reports `0`, `null`, `0`. It has nothing to
+ * swear to, and the substance gate refuses it before it is ever filed (GT-3).
+ *
+ * Neither the protocol nor this package defines a threshold on any of the three.
+ */
+export declare function computeConfidence(fields: readonly AffidavitField[]): ConfidenceNumbers;
+/**
+ * One field as a caller offers it to {@link buildAffidavit}.
+ *
+ * `provenance` is optional and its absence is the whole of AF-1's first half: a
+ * proposed field whose provenance nobody knows is **present** on the Affidavit with
+ * an `Empty` tag at confidence `0`, never quietly omitted.
+ *
+ * `previousValue` is optional in the type and **required at runtime on an update**
+ * (AF-3): the key must be there, holding `null` where the field had no stored
+ * value. Optional-in-the-type is what lets a create omit it; the runtime check is
+ * what stops an update from forgetting it.
+ */
+export interface AffidavitFieldInput {
+    /** The field's name. Must be one the operation proposes. */
+    readonly name: string;
+    /** Rendering hint for a reviewer surface. */
+    readonly kind: AffidavitFieldKind;
+    /** The proposed value. */
+    readonly value: JsonValue;
+    /** The stored value being replaced; `null` where there was none. */
+    readonly previousValue?: JsonValue | null;
+    /** Where the value came from. Absent means unknown, which becomes an `Empty` tag. */
+    readonly provenance?: ProvenanceChain;
+    /** Whether the target entity requires the field. */
+    readonly isMandatory: boolean;
+}
+/** What {@link buildAffidavit} needs that the operation and the fields do not carry. */
+export interface AffidavitMeta {
+    /** When the Affidavit is built, as an ISO 8601 instant. Passed in; nothing here reads a clock. */
+    readonly createdAt: string;
+    /** The conversation turn the proposal was made on. Defaults to `null`. */
+    readonly conversationTurn?: number | null;
+    /**
+     * The protocol version the record conforms to (SR-4). Defaults to
+     * `PROTOCOL_VERSION`, which is what a host building a fresh proposal wants.
+     *
+     * It is here for one caller: {@link fromWire}, which must keep the version a
+     * record arrived under rather than restamp it with this package's own.
+     */
+    readonly protocolVersion?: string;
+}
+/**
+ * Build an Affidavit for `op` from `fields`, enforcing AF-1 and AF-3 and computing
+ * the three numbers (AF-2).
+ *
+ * **AF-1.** `op.fields` is the authority on what is proposed, and the field list
+ * must cover it exactly. A field the operation does not propose is a `RangeError`
+ * rather than a silently `Empty`-tagged row (that is the "absent, never
+ * `Empty`-tagged" half of the rule, made unfakeable); a proposed field with no
+ * entry is also a `RangeError`, because the way to say "proposed, provenance
+ * unknown" is to pass the field with no `provenance` and get an `Empty` tag.
+ *
+ * **AF-3.** `op.kind` and `op.entityId` must agree — an update names its entity, a
+ * create names none — and on an update every field must carry the `previousValue`
+ * key, holding `null` where the entity had no stored value. On a create every
+ * `previousValue` is `null`.
+ *
+ * @throws RangeError on any AF-1 or AF-3 violation, naming the field.
+ */
+export declare function buildAffidavit(op: Operation, fields: readonly AffidavitFieldInput[], meta: AffidavitMeta): Affidavit;
+/** The Affidavit's own properties minus the three numbers — what a caller supplies. */
+type AffidavitCore = Omit<Affidavit, "aggregateConfidence" | "populatedConfidence" | "emptyFieldCount" | "fields">;
+/**
+ * Assemble an Affidavit from its parts with the three numbers computed over
+ * `fields` (AF-2, and AF-4 when the fields have been amended).
+ *
+ * Exported because the amendment path needs exactly this: same identity, same
+ * order, recomputed numbers.
+ */
+export declare function withConfidence(core: AffidavitCore, fields: readonly AffidavitField[]): Affidavit;
+/**
+ * The presentation the card envelope carries beside a sworn record, which the
+ * Affidavit itself does not own.
+ *
+ * All four are the host's presentation of the proposal rather than its sworn
+ * substance: the sentences a reviewer should read, whether a person must confirm
+ * (which is the policy chain's verdict, not a property of the evidence), the
+ * per-field rendering hints a surface builds its inputs from, and the host's own
+ * verb for the operation.
+ *
+ * They live on the envelope and not on the record because the canonical form a
+ * host's execution grant binds to is defined over the Affidavit and its accepted
+ * amendments and nothing else (SR-1). A closed value set, a regular expression an
+ * input is masked with, and a sentence a reviewer should read are none of those
+ * things: swearing to them would put a rendering decision inside a hash a grant is
+ * checked against, so that restyling an input invalidates a grant minted over
+ * evidence that did not change. It would also invite the misreading that the gate
+ * enforces them — it does not. A value outside `allowedValues`, or not matching
+ * `pattern`, is still recorded; a host that wants such a value refused enforces
+ * that in its own policy.
+ */
+export interface WireCarry {
+    /** Sentences a reviewer should see beside the record. Empty when there are none. */
+    readonly warnings: readonly string[];
+    /** Whether a person must confirm this write before it commits. */
+    readonly requiresConfirmation: boolean;
+    /**
+     * How a reviewer surface should render each field's input: one entry per field
+     * the host has a hint for, naming a field the Affidavit carries. Empty when the
+     * host declared none.
+     */
+    readonly presentation: readonly FieldPresentation[];
+    /**
+     * The host's own verb for the operation, or `null` when it named none.
+     *
+     * `Affidavit.operationType` is the protocol's two-valued shape, so that a rule
+     * about shape stays a predicate a policy can test without knowing any host's
+     * vocabulary. The host's word for the same act travels **beside** it, here, where
+     * a reviewer surface can show it and no hash is taken over it.
+     */
+    readonly hostOperation: string | null;
+}
+/**
+ * Lift the {@link WireCarry} off a card envelope, so a round trip can put it back.
+ *
+ * The two optional slots come back as empty arrays rather than `undefined`: a
+ * caller reading them wants something to iterate, and `toWire`'s companion,
+ * {@link presentationToWire}, turns an empty one back into an omitted property.
+ */
+export declare function wireCarryOf(card: WireEvidenceCardRequest): WireCarry;
+/**
+ * The card envelope's three optional presentation slots as the wire spells them:
+ * **absent** when there is nothing to say, never `null`.
+ *
+ * Nothing swears to any of them, so a producer with nothing to say says nothing —
+ * the distinction the schemas draw between a value that is sometimes missing
+ * (spelled `null`) and a property that is meaningful only sometimes (spelled by its
+ * absence).
+ */
+export declare function presentationToWire(carry: WireCarry): {
+    presentation?: readonly FieldPresentation[];
+    warnings?: readonly string[];
+    hostOperation?: string;
+};
+/** What {@link fromWire} must be told, because a wire Affidavit does not carry it. */
+export interface FromWireStamp {
+    /**
+     * The instant to stamp on the Affidavit. A tag carries its own `at` on the wire
+     * from v0.1, so this is the record's `createdAt` and the fallback for a tag that
+     * somehow arrived without one.
+     */
+    readonly at: string;
+    /** The conversation turn the proposal was made on. Defaults to the wire's own, else `null`. */
+    readonly conversationTurn?: number | null;
+}
+/**
+ * Read a wire Affidavit into the core model.
+ *
+ * **A payload from another protocol version is refused, never guessed at.** The
+ * `0.0.1-seed` shape the shipped .NET framework still sends is a different
+ * document — the host's verb where the shape belongs, one confidence number rather
+ * than three, the warnings and the confirmation flag on the record, the
+ * presentation on each field — and reading it as though it were this one would
+ * produce a record that swore to things nobody said. SR-4 puts the version on the
+ * envelope precisely so a consumer can tell: a differing **major** is refused, and
+ * so is an older minor whose shape this version does not describe. A newer minor is
+ * accepted, because a minor only adds.
+ *
+ * Two mappings are worth stating. **The operation shape is derived, not trusted:**
+ * `entityId === null` is a create and anything else is an update (AF-3), so a
+ * record whose `operationType` disagrees with its own `entityId` still lands on the
+ * right side of the rule. **A grade is carried, never raised:** a binding read off
+ * the wire is recorded as it arrived, and whether a tag may be relied on is PV-4's
+ * call, not the reader's.
+ *
+ * @throws RangeError if the payload names another protocol version, if a field
+ *         value is not a JSON value, or if the wire shape violates AF-1 or AF-3.
+ */
+export declare function fromWire(wire: WireAffidavit, stamp: FromWireStamp): Affidavit;
+/**
+ * Write a core Affidavit back out in the wire shape.
+ *
+ * Everything on the wire record is the record: the operation's **shape** rather
+ * than the host's verb (AF-3), the three confidence numbers (AF-2), the version
+ * the envelope conforms to (SR-4), and each field's value, previous value and
+ * whole provenance chain. The presentation a surface needs goes on the card
+ * envelope instead — see {@link WireCarry}.
+ *
+ * `aggregateConfidence` is **the computed value** (AF-2). An implementation that
+ * wrote back whatever number it was handed would let a mean computed elsewhere
+ * travel under a name the rule defines as a minimum.
+ *
+ * `protocolVersion` is **the record's own** (SR-4), no longer stamped here. It used
+ * to be invented on the way out, which made the wire document and the runtime model
+ * two different records — the wire one carrying a property the model did not have —
+ * and SR-1's canonical form is over the record as the schema defines it, so the two
+ * hashed differently. The parameter is kept for a caller re-emitting a record under
+ * an explicit version, and defaults to the version the record carries.
+ */
+export declare function toWire(affidavit: Affidavit, protocolVersion?: string): WireAffidavit;
+//# sourceMappingURL=affidavit.d.ts.map

package/dist/model/affidavit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affidavit.d.ts","sourceRoot":"","sources":["../../src/model/affidavit.ts"],"names":[],"mappings":"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"}