@mnemom/mnemom 0.17.34-next.1 → 0.17.34-next.2

package/dist/vendor/shared/durable-contract/envelope.js

@@ -0,0 +1,317 @@
+// GENERATED from shared/durable-contract/src/envelope.ts by cli/scripts/sync-durable-contract.mjs; do not edit.
+/**
+ * Contract ciphertext envelope v1 and the charter commitment schema (C18-R01..R03; BACKBONE
+ * amendment 36; r3 U05). API only: no other repo decrypts.
+ *
+ *   contract_ciphertext = "v1." + b64url(iv, 12 bytes) + "." + b64url(ciphertext || 16-byte tag)
+ *   AES-256-GCM, per-session 32-byte DEK, random IV per write
+ *   AAD = UTF-8 "durable-contract:v1:<session_id>:<charter_version>"
+ *   plaintext = canonicalJson({statement, requirements, allowed_paths, forbidden_paths}), plus
+ *               goal_id, work_card and shape when the seal carries them (amendment 55)
+ *   wrapped_data_key = encryptBlob(dekWrapInput(DEK)) under the SESSION_COOKIE_KEY keyring (api)
+ *   statement_hash = sha256(canonicalJson(statement)); requirements_hash = sha256(canonicalJson(requirements))
+ */
+import { base64urlDecode, base64urlEncode, canonicalJson, sha256Hex, utf8, HEX64_RE, } from "./canonical.js";
+import { CONTRACT_STATEMENT_MAX_CHARS } from "./constants.js";
+import { canonicalEventTs, GENESIS_PREV_HASH } from "./events.js";
+export const ENVELOPE_VERSION = "v1";
+export const CIPHER_KEY_REFS = ["mnemom"];
+export const DEK_BYTES = 32;
+export const IV_BYTES = 12;
+export const TAG_BYTES = 16;
+/** The Contract's optional keys (amendment 55); absent unless the gateway seal carried them. */
+export const CONTRACT_OPTIONAL_KEYS = ["goal_id", "work_card", "shape"];
+export function contractAad(sessionId, charterVersion) {
+    return `durable-contract:v1:${sessionId}:${charterVersion}`;
+}
+/** Validate a submitted contract; null when malformed or over the statement limit. */
+export function parseContract(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const r = raw;
+    const keys = ["statement", "requirements", "allowed_paths", "forbidden_paths"];
+    const known = [...keys, ...CONTRACT_OPTIONAL_KEYS];
+    if (Object.keys(r).some((k) => !known.includes(k)))
+        return null;
+    if (typeof r.statement !== "string" ||
+        r.statement.length === 0 ||
+        r.statement.length > CONTRACT_STATEMENT_MAX_CHARS)
+        return null;
+    for (const k of keys.slice(1)) {
+        const v = r[k] ?? [];
+        if (!Array.isArray(v) || v.some((s) => typeof s !== "string"))
+            return null;
+    }
+    if ("goal_id" in r && (typeof r.goal_id !== "string" || r.goal_id.length === 0))
+        return null;
+    if ("work_card" in r && r.work_card !== true)
+        return null;
+    if ("shape" in r && r.shape !== "duty")
+        return null;
+    const out = {
+        statement: r.statement,
+        requirements: (r.requirements ?? []),
+        allowed_paths: (r.allowed_paths ?? []),
+        forbidden_paths: (r.forbidden_paths ?? []),
+    };
+    return { ...out, ...optionalContractFields(r) };
+}
+function optionalContractFields(c) {
+    const out = {};
+    if (c.goal_id !== undefined)
+        out.goal_id = c.goal_id;
+    if (c.work_card !== undefined)
+        out.work_card = c.work_card;
+    if (c.shape !== undefined)
+        out.shape = c.shape;
+    return out;
+}
+export function contractPlaintext(c) {
+    return canonicalJson({
+        statement: c.statement,
+        requirements: c.requirements,
+        allowed_paths: c.allowed_paths,
+        forbidden_paths: c.forbidden_paths,
+        ...optionalContractFields(c),
+    });
+}
+export async function statementHash(statement) {
+    return sha256Hex(canonicalJson(statement));
+}
+export async function requirementsHash(requirements) {
+    return sha256Hex(canonicalJson(requirements));
+}
+/** What encryptBlob wraps: base64url of the raw DEK (so wrapped_data_key never decodes to 32 raw bytes). */
+export function dekWrapInput(dek) {
+    if (dek.length !== DEK_BYTES)
+        throw new RangeError("DEK must be 32 bytes");
+    return base64urlEncode(dek);
+}
+export function dekFromWrapInput(text) {
+    const b = base64urlDecode(text);
+    return b !== null && b.length === DEK_BYTES ? b : null;
+}
+export function newDek(random = (n) => crypto.getRandomValues(new Uint8Array(n))) {
+    return random(DEK_BYTES);
+}
+async function importDek(dek) {
+    if (dek.length !== DEK_BYTES)
+        throw new RangeError("DEK must be 32 bytes");
+    return crypto.subtle.importKey("raw", dek, { name: "AES-GCM" }, false, [
+        "encrypt",
+        "decrypt",
+    ]);
+}
+/** Seal a contract. `random` is injectable for golden vectors only; production uses getRandomValues. */
+export async function sealContract(dek, sessionId, charterVersion, contract, random = (n) => crypto.getRandomValues(new Uint8Array(n))) {
+    const iv = random(IV_BYTES);
+    const key = await importDek(dek);
+    const ct = await crypto.subtle.encrypt({
+        name: "AES-GCM",
+        iv: iv,
+        additionalData: utf8(contractAad(sessionId, charterVersion)),
+        tagLength: TAG_BYTES * 8,
+    }, key, utf8(contractPlaintext(contract)));
+    return `${ENVELOPE_VERSION}.${base64urlEncode(iv)}.${base64urlEncode(new Uint8Array(ct))}`;
+}
+export function parseEnvelope(text) {
+    const parts = text.split(".");
+    if (parts.length !== 3 || parts[0] !== ENVELOPE_VERSION)
+        return null;
+    const iv = base64urlDecode(parts[1]);
+    const ct = base64urlDecode(parts[2]);
+    if (iv === null || iv.length !== IV_BYTES || ct === null || ct.length < TAG_BYTES)
+        return null;
+    return { iv, ct };
+}
+/** Open an envelope; null on a malformed envelope, wrong key, wrong session or wrong version (AAD). */
+export async function openContract(dek, sessionId, charterVersion, envelope) {
+    const env = parseEnvelope(envelope);
+    if (env === null)
+        return null;
+    try {
+        const key = await importDek(dek);
+        const pt = await crypto.subtle.decrypt({
+            name: "AES-GCM",
+            iv: env.iv,
+            additionalData: utf8(contractAad(sessionId, charterVersion)),
+            tagLength: TAG_BYTES * 8,
+        }, key, env.ct);
+        return parseContract(JSON.parse(new TextDecoder().decode(pt)));
+    }
+    catch {
+        return null;
+    }
+}
+// ---- charter commitment schema (closed) -------------------------------------------------------
+export const COMMITMENT_KEYS = [
+    "statement_hash",
+    "requirements_hash",
+    "budget_usd",
+    "per_wake_cap_usd",
+    "max_wakes_per_day",
+    "max_turns",
+    "active_time_limit_s",
+    "pins",
+    "tool_classes",
+    "launch_spec",
+    // amendment 55 (C07-R02): what the gateway sealed beyond the ceilings, so a reload keeps it
+    "mode",
+    "stall_turns",
+    "contract_hash",
+];
+/** The gateway's sealed-contract modes (MNE-8199); committed as `mode` by amendment 55. */
+export const CONTRACT_MODE_VALUES = ["nudge", "enforce"];
+export const TOOL_CLASS_VALUES = ["input_dependent", "safe", "idempotent"];
+/**
+ * Charter pins (BACKBONE A3, rulings U13, C07-R23): card_content_hash is the agent's live /state
+ * content_hash read at lock; policy_engine_major is the API's policy-engine major at lock. Both
+ * required, never empty, inside the charter preimage.
+ */
+export const PIN_KEYS = ["card_content_hash", "policy_engine_major"];
+/** Validate a charter commitment object (keys a subset of COMMITMENT_KEYS; no text values). */
+export function isValidCommitment(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return false;
+    const r = raw;
+    for (const [k, v] of Object.entries(r)) {
+        switch (k) {
+            case "statement_hash":
+            case "requirements_hash":
+            case "contract_hash":
+                if (typeof v !== "string" || !HEX64_RE.test(v))
+                    return false;
+                break;
+            case "budget_usd":
+            case "per_wake_cap_usd":
+                if (typeof v !== "number" || !Number.isFinite(v) || v < 0)
+                    return false;
+                break;
+            case "max_wakes_per_day":
+            case "max_turns":
+            case "active_time_limit_s":
+            case "stall_turns":
+                if (!Number.isSafeInteger(v) || v < 0)
+                    return false;
+                break;
+            case "pins": {
+                if (v === null || typeof v !== "object" || Array.isArray(v))
+                    return false;
+                const p = v;
+                if (Object.keys(p).some((x) => !PIN_KEYS.includes(x)))
+                    return false;
+                if (typeof p.card_content_hash !== "string" ||
+                    !HEX64_RE.test(p.card_content_hash) ||
+                    !Number.isSafeInteger(p.policy_engine_major) ||
+                    p.policy_engine_major < 0)
+                    return false;
+                break;
+            }
+            case "tool_classes": {
+                if (v === null || typeof v !== "object" || Array.isArray(v))
+                    return false;
+                for (const [tool, cls] of Object.entries(v)) {
+                    if (!/^[A-Za-z0-9_:.-]{1,128}$/.test(tool) ||
+                        !TOOL_CLASS_VALUES.includes(cls))
+                        return false;
+                }
+                break;
+            }
+            case "mode":
+                if (!CONTRACT_MODE_VALUES.includes(v))
+                    return false;
+                break;
+            case "launch_spec":
+                if (typeof v !== "object" || v === null || Array.isArray(v))
+                    return false;
+                break;
+            default:
+                return false;
+        }
+    }
+    return true;
+}
+/** M1 accepts only input_dependent tool classes (safe/idempotent -> 422 durable_unsupported {feature:'tool_classes'}). */
+export function toolClassesSupportedM1(toolClasses) {
+    return (toolClasses === undefined || Object.values(toolClasses).every((c) => c === "input_dependent"));
+}
+// ---- charter hash chain (C07-R04, R23; r3 U05) ------------------------------------------------
+/**
+ * The charter row preimage. hash = sha256(canonicalJson(charterPreimage(row))); v(1).prev_hash =
+ * GENESIS_PREV_HASH (64 zeros) and v(n).prev_hash = v(n-1).hash. The preimage is exactly these
+ * fields (canonicalJson sorts keys):
+ *   v           CHARTER_PREIMAGE_VERSION (1)
+ *   session_id  the session uuid, lowercase text
+ *   version     the charter version, integer >= 1
+ *   prev_hash   64 lowercase hex
+ *   charter     the commitment object (isValidCommitment; pins included)
+ *   created_at  canonicalEventTs(created_at): UTC, "T", 6 fraction digits, "Z" (a Postgres
+ *               timestamptz text such as "2026-10-16 12:00:00.123+00" canonicalises the same).
+ *               Amendment 55: v1's created_at IS the original seal's sealed_at (T0, the gateway's
+ *               first sealed request), never the lock time: build it with charterV1CreatedAt. Every
+ *               reader that reports a session's sealed_at reads v1's created_at. v(n>1)'s created_at
+ *               is the amend time and never changes sealed_at.
+ * Every other agent_session_charters column is outside it (CHARTER_HASH_EXCLUDED_COLUMNS), so a KEK
+ * re-wrap (wrapped_data_key changes) and the contract purge (contract_ciphertext nulled,
+ * contract_purge_after stamped) leave every hash and agent_sessions.charter_hash unchanged.
+ */
+export const CHARTER_PREIMAGE_VERSION = 1;
+export const CHARTER_PREIMAGE_FIELDS = [
+    "v",
+    "session_id",
+    "version",
+    "prev_hash",
+    "charter",
+    "created_at",
+];
+export const CHARTER_HASH_EXCLUDED_COLUMNS = [
+    "hash",
+    "contract_ciphertext",
+    "wrapped_data_key",
+    "cipher_key_ref",
+    "contract_purge_after",
+    "signature",
+];
+/**
+ * Build the preimage from a charter row. Extra row columns (the excluded ones) are ignored. Throws on
+ * a bad version, a malformed prev_hash, a version-1 row that does not chain from genesis, or an
+ * invalid commitment.
+ */
+export function charterPreimage(row) {
+    if (!Number.isSafeInteger(row.version) || row.version < 1)
+        throw new RangeError("charter version must be an integer >= 1");
+    if (!HEX64_RE.test(row.prev_hash))
+        throw new RangeError("prev_hash must be 64 lowercase hex");
+    if (row.version === 1 && row.prev_hash !== GENESIS_PREV_HASH)
+        throw new RangeError("charter v1 must chain from GENESIS_PREV_HASH");
+    if (!isValidCommitment(row.charter))
+        throw new RangeError("charter is not a valid commitment");
+    return {
+        v: CHARTER_PREIMAGE_VERSION,
+        session_id: row.session_id,
+        version: row.version,
+        prev_hash: row.prev_hash,
+        charter: row.charter,
+        created_at: canonicalEventTs(row.created_at),
+    };
+}
+/**
+ * Charter v1's created_at from the gateway seal's sealed_at (amendment 55). The seal may carry any
+ * ISO-8601 instant (UTC, or an offset such as "-07:00", at millisecond precision); the result is the same instant in
+ * canonicalEventTs form. Throws on text that is not an instant.
+ */
+export function charterV1CreatedAt(sealedAt) {
+    try {
+        return canonicalEventTs(sealedAt); // UTC already: keeps every fraction digit
+    }
+    catch {
+        // an offset form: the same instant, in UTC
+    }
+    const ms = Date.parse(sealedAt);
+    if (!Number.isFinite(ms))
+        throw new RangeError(`not a seal instant: ${sealedAt}`);
+    return canonicalEventTs(new Date(ms).toISOString());
+}
+export async function charterHash(row) {
+    return sha256Hex(canonicalJson(charterPreimage(row)));
+}

package/dist/vendor/shared/durable-contract/events.d.ts

@@ -0,0 +1,147 @@
+/**
+ * The journal: the closed event vocabulary (design §3.7, BACKBONE "Event kinds list", C10-R1..R25),
+ * writer classes, refs schemas, the server-generated detail, idempotency keys and the hash
+ * preimage (C10-R0 (a)-(m)).
+ *
+ * C10-R0 decisions frozen here:
+ *  (a) preimage fields: EVENT_PREIMAGE_FIELDS; hash = sha256(canonicalJson(preimage)).
+ *  (b) genesis prev_hash: GENESIS_PREV_HASH (64 zeros), never null.
+ *  (c) ts: stamped by the API process at append (Date, millisecond precision), stored timestamptz,
+ *      hashed as canonicalEventTs(ts): UTC, exactly 6 fraction digits, "Z" (survives PostgREST's
+ *      "+00:00" and psql's "+00" read-back forms).
+ *  (d) principal_ref: a stored column, HMAC-SHA256(hmac_salt, principal_uid) hex, null when the
+ *      writer has no principal (gateway, sweep, trigger).
+ *  (e) writer classes: EVENT_WRITER; executor list exactly [executor.spawned], plus session.waiting
+ *      from the Doors amendment (ruling 34.06) and executor.turn_continued (lead ruling 2026-10-28).
+ *  (f) executor.enrolled is journaled into no session in M1 (the agent_executors row is the record).
+ *  (h) an epoch-bump event is stamped with the NEW epoch.
+ *  (i)(j) codes.ts: durable_append_conflict, durable_lease_fenced, durable_idempotency_conflict.
+ *  (k) refs_schema is enforced inside durable_append_event (so a direct service_role RPC is refused).
+ *  (l) the gateway's internal route is GATEWAY_EVENTS_ROUTE on the API.
+ *  (m) DSR: phase user_erasure, treatment pseudonymize (nulls principal_uid, detail, refs).
+ */
+export declare const EVENT_GROUPS: readonly ["lifecycle", "charter", "lease", "input", "human", "effects", "governance", "context"];
+export type EventGroup = (typeof EVENT_GROUPS)[number];
+/** The §3.7 table, all 88 kinds, by group. */
+export declare const DESIGN_EVENT_KINDS: {
+    readonly [G in EventGroup]: readonly string[];
+};
+/** The 8 kinds L01 leaves out of the M1 seed: unknown kinds on every write path in M1. */
+export declare const M1_EXCLUDED_KINDS: readonly ["intent.issued", "intent.committed", "intent.unknown", "intent.resolved", "intent.readmission_flagged", "context.note", "context.compacted", "inbox.acked"];
+/**
+ * Every M1 kind (80) with its group, in §3.7 order, then the Doors amendment's three (rulings
+ * 34.02, 34.06), appended so no existing index moves. Mirrors durable_event_kinds (parity test).
+ */
+export declare const DURABLE_EVENT_KINDS: readonly ["session.registered", "session.locked", "session.unlocked", "session.resumed", "session.detached", "session.parked", "session.suspended", "session.paused", "session.unpaused", "session.moved", "session.completed", "session.failed", "session.killed", "session.expired", "session.adopted", "seat.hello", "charter.sealed", "charter.amended", "charter.goal_sealed", "charter.card_drift", "profile.amended", "executor.upgraded", "attestation.passed", "attestation.failed", "lease.acquired", "lease.reclaimed", "lease.released", "lease.expired", "lease.fenced", "lease.zombie_call", "lease.stale_admit", "executor.enrolled", "executor.revoked", "executor.spawned", "executor.exited", "executor.contract_violation", "inbox.admitted", "inbox.rejected", "inbox.coalesced", "inbox.held_unsealed", "inbox.queued_for_home", "inbox.reverted", "inbox.delivered", "inbox.unmatched", "inbox.dead", "timer.set", "timer.fired", "timer.cancelled", "trigger.added", "trigger.removed", "trigger.fired", "trigger.suppressed", "trigger.over_cap", "wake.undelivered", "question.asked", "question.answered", "approval.requested", "approval.resolved", "approval.consumed", "approval.expired", "approval.superseded", "approval.single_person_override", "never.held", "chain.posture", "guard.refused", "guard.unavailable", "budget.reached", "grant.renewed", "grant.revoked", "verdict.violation", "identity.mismatch", "containment.pause", "containment.kill", "containment.auto_pause", "governance.degraded_admit", "governance.outage_mode_set", "policy.host_unattended_changed", "workspace.checkpointed", "rearm.recorded", "tip.signed", "session.ready", "session.waiting", "session.wait_cleared", "executor.turn_continued"];
+export type DurableEventKind = (typeof DURABLE_EVENT_KINDS)[number];
+export declare function isDurableEventKind(v: unknown): v is DurableEventKind;
+/**
+ * The kinds amendments add, with their group: the Doors amendment (rulings 34.02, 34.06), and
+ * executor.turn_continued (lead ruling 2026-10-28: the seat sent its one automatic "continue" to a
+ * turn a lock interrupted). They are not in the design's §3.7 table, so DESIGN_EVENT_KINDS stays the
+ * design's table and these are listed here.
+ */
+export declare const AMENDMENT_EVENT_GROUPS: Readonly<{
+    readonly "session.ready": "lifecycle";
+    readonly "session.waiting": "lifecycle";
+    readonly "session.wait_cleared": "lifecycle";
+    readonly "executor.turn_continued": "lease";
+}>;
+export declare function eventGroupOf(kind: DurableEventKind): EventGroup;
+export declare const EVENT_WRITERS: readonly ["executor", "gateway", "api"];
+export type EventWriter = (typeof EVENT_WRITERS)[number];
+/**
+ * M1: exactly [executor.spawned] (L01); the Doors amendment adds session.waiting (ruling 34.06), and
+ * the seat's one automatic continue adds executor.turn_continued (lead ruling 2026-10-28).
+ */
+export declare const EXECUTOR_WRITABLE_KINDS: readonly ["executor.spawned", "session.waiting", "executor.turn_continued"];
+/** Gateway: no session state in M1, so no containment.*, charter.* or lifecycle kind. */
+export declare const GATEWAY_WRITABLE_KINDS: readonly ["lease.zombie_call", "identity.mismatch", "guard.unavailable"];
+/** The one writer class allowed to append a kind; everything not executor- or gateway-writable is API-writable. */
+export declare function writerOf(kind: DurableEventKind): EventWriter;
+/** Kinds with no M1 emitter: seeded for parity, never written by M1 code (C10-R4 static scan). */
+export declare const NO_M1_EMITTER_KINDS: readonly ["session.resumed", "session.moved", "charter.goal_sealed", "profile.amended", "executor.upgraded", "lease.stale_admit", "executor.enrolled", "executor.contract_violation", "inbox.admitted", "inbox.rejected", "inbox.coalesced", "inbox.held_unsealed", "inbox.queued_for_home", "inbox.reverted", "inbox.delivered", "inbox.unmatched", "inbox.dead", "timer.set", "timer.fired", "timer.cancelled", "trigger.added", "trigger.removed", "trigger.fired", "trigger.suppressed", "trigger.over_cap", "wake.undelivered", "question.asked", "question.answered", "approval.superseded", "approval.single_person_override", "never.held", "verdict.violation", "containment.auto_pause", "governance.degraded_admit", "governance.outage_mode_set", "policy.host_unattended_changed", "workspace.checkpointed", "rearm.recorded", "tip.signed"];
+export interface RefsProperty {
+    readonly type: "string" | "integer" | "boolean";
+    readonly enum?: readonly string[];
+    readonly pattern?: string;
+    readonly maxLength?: number;
+    readonly minimum?: number;
+    /** A boolean that may only take this value when present (ruling 34.14 (1): lease.acquired pool). */
+    readonly const?: boolean;
+}
+export interface RefsSchema {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly string[];
+    readonly properties: Readonly<Record<string, RefsProperty>>;
+    /**
+     * if refs[if.field] === if.equals then `require` fields are required (C10-R5, R25) and `forbid`
+     * fields must be absent (ruling 34.14 (5)).
+     */
+    readonly if_then?: readonly {
+        readonly field: string;
+        readonly equals: string;
+        readonly require?: readonly string[];
+        readonly forbid?: readonly string[];
+        readonly enums?: Readonly<Record<string, readonly string[]>>;
+    }[];
+}
+/** durable_approvals.kind values, as the approval.* refs enums carry them. */
+export declare const APPROVAL_KINDS: readonly ["question", "ask", "tool_confirmation", "intent_rerun", "card_drift", "owner_mutation", "grant_renewal", "limit_raise"];
+/** session.ready refs.cause: how a session entered ready (ruling 34.02 (3)). */
+export declare const READY_CAUSES: readonly ["dispatched", "lease_expired", "wait_cleared"];
+/** refs_schema for every M1 kind; kinds without a specific schema take EMPTY (refs must be {}). */
+export declare function refsSchemaOf(kind: DurableEventKind): RefsSchema;
+/** One refs property against its schema (pure; exported for its direct test). An integer with no minimum accepts any safe integer. */
+export declare function refsPropertyOk(p: RefsProperty, v: unknown): boolean;
+/** Reference validator for refs against refsSchemaOf(kind) (the RPC enforces the same rules). */
+export declare function validateRefs(kind: DurableEventKind, refs: unknown): boolean;
+/** Server-generated detail (C10-R6, C18-R07): "<kind>" then " key=value" for each refs key, sorted. Content-free by construction. */
+export declare function eventDetail(kind: DurableEventKind, refs: Readonly<Record<string, string | number | boolean | null>>): string;
+/** The closed shape every stored detail matches (the C18 structural checker's regex). */
+export declare const EVENT_DETAIL_RE: RegExp;
+export declare const idempotencyKeys: {
+    readonly spawn: (sessionId: string, epoch: number, spawnId: string) => string;
+    readonly zombie: (requestId: string) => string;
+    readonly identityMismatch: (sessionId: string, epoch: number) => string;
+    readonly cardDrift: (sessionId: string, observedHash: string) => string;
+    /** API transitions: one event per (session, kind, new epoch); a retried transition replays the row. */
+    readonly transition: (sessionId: string, kind: DurableEventKind, epoch: number) => string;
+};
+export declare const GENESIS_PREV_HASH: string;
+export declare const GATEWAY_EVENTS_ROUTE = "/internal/durable/events";
+/**
+ * The journal kinds that mark a terminal transition, one per TERMINAL_STATES value in the same
+ * order (wave-0 fix ruling 1.06). contract_purge_after is stamped from the ts of this event
+ * (C18-R13).
+ */
+export declare const TERMINAL_EVENT_KINDS: readonly ["session.completed", "session.failed", "session.killed", "session.expired"];
+export declare const EVENT_DSR: {
+    readonly phase: "user_erasure";
+    readonly treatment: "pseudonymize";
+};
+/** Hashed fields, in no particular order (canonicalJson sorts). Raw detail, refs and principal_uid are never hashed. */
+export declare const EVENT_PREIMAGE_FIELDS: readonly ["v", "session_id", "seq", "ts", "kind", "epoch", "idempotency_key", "principal_ref", "detail_sha256", "refs_sha256", "prev_hash"];
+export interface EventPreimageInput {
+    session_id: string;
+    seq: number;
+    ts: string;
+    kind: DurableEventKind;
+    epoch: number;
+    idempotency_key: string;
+    principal_ref?: string | null;
+    detail_sha256: string;
+    refs_sha256: string;
+    prev_hash: string;
+}
+/** The canonical ts text: UTC, 6 fraction digits, "Z". Throws on a non-UTC or malformed value. */
+export declare function canonicalEventTs(ts: string): string;
+/** The API's stamper: millisecond Date, canonical form. */
+export declare function stampEventTs(epochMs: number): string;
+/** The preimage object; absent principal_ref hashes like explicit null (C10-R8). */
+export declare function eventPreimage(input: EventPreimageInput): Record<string, unknown>;
+export declare function eventHash(input: EventPreimageInput): Promise<string>;
+export declare function refsSha256(refs: unknown): Promise<string>;
+/** principal_ref = HMAC-SHA256(hmac_salt, principal_uid), lowercase hex (C10-R15). */
+export declare function principalRef(hmacSalt: Uint8Array, principalUid: string): Promise<string>;