@raybase/record-mount 0.0.2 → 0.3.3

package/dist/testing.js

@@ -0,0 +1,764 @@
+/**
+ * A contract-conformant, in-memory record door — the dev-time half.
+ *
+ * It exists so that this package's own suite drives the real client
+ * against something that answers the wire contract's shapes, and so that a
+ * consuming app's tests can exercise its mount without a deployed Worker,
+ * a service binding, or a network. It is exported for exactly that.
+ *
+ * **What it is honest about.** It implements the contract's *shapes* — the
+ * result envelope, the closed taxonomy, the Row projection, `version()`,
+ * keyset paging, append idempotency by content hash, the ordering rule
+ * that `forbidden` outranks `not_found`. It is generic: no family, no id
+ * prefix and no lifecycle vocabulary is baked in, and every one of those
+ * is a hook with a documented generic default.
+ *
+ * **What it is not.** It is not the door. Bytes that this double accepts
+ * are not thereby proven acceptable to a deployed door — its frontmatter
+ * reader is this package's own, written to this package's own dialect, so
+ * a suite green against it is a builder-authored oracle for wire
+ * acceptance and nothing more. The real-door cross-check is a consumer-side
+ * act against the running door itself, and this double does not stand in
+ * for it. Its materialize path layout is its own invention (`family/id`),
+ * because the real one belongs to the consumer's substrate.
+ *
+ * ## Seam fidelity: why the default is a Proxy
+ *
+ * The double used to hand back a plain object that simply OMITTED
+ * `append`/`transition` for a read door. That is not how the production seam
+ * behaves, and the difference cost a real defect: a Cloudflare RPC
+ * service-binding stub answers EVERY property access with a callable, so
+ * every property-presence check the client made read `true` against a
+ * deployed read door while reading `false` against this fixture. The suite
+ * was green on a shape that does not exist in production — a self-authored
+ * oracle in its purest form.
+ *
+ * So by default the double presents as an RPC-faithful stub: a Proxy whose
+ * every property is a function, where calling one the underlying door does
+ * not carry rejects with a `TypeError` imitating the runtime's method-missing
+ * shape. Pass `rpc: false` for the plain object, which is the honest fixture
+ * for an in-process mount that really does hold a plain implementation.
+ *
+ * The imitation is an imitation, but its SHAPE is load-bearing: the client
+ * translates a `TypeError` only when its message carries the observed
+ * method-missing form — `does not implement` naming the verb — so the double
+ * reproduces that form. Do not pin the full string in a test as if it were
+ * workerd's contract; the wording is workerd's to change, and when it changes
+ * the client deliberately stops translating rather than guessing.
+ */
+import { RECORD_COUNT_GROUPS, RECORD_EXACT_FILTERS, RECORD_SET_FILTERS, RECORD_DOOR_CONTRACT_VERSION } from "./contract.js";
+import { parseRecordFrontmatter, recordProseOf } from "./body.js";
+/** The contract's id scheme. The prefix charset matches the composer's
+ *  `RECORD_ID_PATTERN` exactly — a double stricter than the composer would
+ *  refuse ids this package itself builds, which is a fixture that lies. */
+const DEFAULT_ID_RE = /^[a-z0-9]+-\d{4}-\d{2}-\d{2}-[a-z0-9][a-z0-9-]*$/;
+const MAX_LIMIT = 1000;
+/** Build the door double. */
+export function createRecordDoorDouble(options = {}) {
+    const contract = options.contract ?? RECORD_DOOR_CONTRACT_VERSION;
+    const deployment = options.deployment ?? "double";
+    const writable = options.writable ?? true;
+    const rpc = options.rpc ?? true;
+    const declaredWrites = options.declaredWrites ?? writable;
+    const hasSerializer = options.serializer ?? true;
+    const idPattern = options.idPattern ?? DEFAULT_ID_RE;
+    /** Whether the consumer supplied a real prefix-to-family map. */
+    const familyDeclared = options.familyOfId !== undefined;
+    const familyOfId = options.familyOfId ??
+        ((id) => {
+            const cut = id.indexOf("-");
+            return cut > 0 ? id.slice(0, cut) : null;
+        });
+    const lifecycleField = options.lifecycleField ?? (() => "status");
+    const isLegalTransition = options.isLegalTransition ??
+        ((_family, from, to) => from.length > 0 && to.length > 0);
+    const canWrite = options.canWrite ?? (() => true);
+    const headline = options.headline ?? defaultHeadline;
+    const refsOf = options.refsOf ?? defaultRefs;
+    const pageEntries = options.materializePageEntries ?? 500;
+    const held = new Map();
+    const faults = new Map();
+    const bindingRefusal = () => {
+        if (options.invalidBinding === undefined)
+            return null;
+        const detail = { missing: options.invalidBinding.missing ?? [] };
+        if (options.invalidBinding.actor !== undefined)
+            detail.actor = options.invalidBinding.actor;
+        if (options.invalidBinding.served !== undefined)
+            detail.served = options.invalidBinding.served;
+        return refuse("invalid_binding", detail);
+    };
+    const fault = (verb) => {
+        const planted = faults.get(verb);
+        if (planted === undefined)
+            return null;
+        faults.delete(verb);
+        return { ok: false, error: planted };
+    };
+    const guard = (verb) => fault(verb) ?? bindingRefusal();
+    const envelopeOf = (rec) => {
+        const f = rec.fields;
+        const lifecycle = lifecycleField(rec.family);
+        const last = rec.events[rec.events.length - 1];
+        const env = {
+            id: rec.id,
+            type: rec.family,
+            by: str(f.by) ?? "",
+            refs: refsOf(f),
+            body_sha256: rec.sha,
+            head_seq: rec.events.length
+        };
+        if (str(f.created) !== undefined)
+            env.created = str(f.created);
+        if (str(f.ts) !== undefined)
+            env.ts = str(f.ts);
+        for (const key of ["case", "due", "kind", "severity", "decided"]) {
+            const v = str(f[key]);
+            if (v !== undefined)
+                env[key] = v;
+        }
+        const decidedBy = str(f["decided-by"]);
+        if (decidedBy !== undefined)
+            env["decided-by"] = decidedBy;
+        // The lifecycle value is the last transition's target, falling back to
+        // what the body was filed with. `disposition` is carried as filed
+        // unless it IS the family's lifecycle field.
+        const filed = lifecycle === null ? undefined : str(f[lifecycle]);
+        const current = lastTransition(rec.events)?.to ?? filed;
+        if (lifecycle === "disposition") {
+            if (current !== undefined)
+                env.disposition = current;
+        }
+        else {
+            if (current !== undefined)
+                env.status = current;
+            const disposition = str(f.disposition) ?? str(last?.fields?.disposition);
+            if (disposition !== undefined)
+                env.disposition = disposition;
+        }
+        return env;
+    };
+    const rowOf = (rec) => {
+        const envelope = envelopeOf(rec);
+        const body = replay(rec, lifecycleField(rec.family));
+        const last = rec.events[rec.events.length - 1];
+        return {
+            ...envelope,
+            headline: headline({ envelope, body }),
+            head_ts: last === undefined ? null : last.ts
+        };
+    };
+    const allRows = () => [...held.values()].map(rowOf);
+    const door = {
+        failNext(verb, error) {
+            faults.set(String(verb), {
+                code: error.code,
+                detail: error.detail ?? {},
+                message: error.message ?? `${error.code}: planted by the record door double`
+            });
+        },
+        ids() {
+            return [...held.keys()];
+        },
+        async version() {
+            const planted = fault("version");
+            if (planted !== null)
+                return planted;
+            // An older door has no `writes` field at all — the absence IS the
+            // simulation, so it is omitted rather than sent as undefined.
+            return declaredWrites === "omit"
+                ? { ok: true, deployment, contract }
+                : { ok: true, deployment, contract, writes: declaredWrites };
+        },
+        async get(id) {
+            const stop = guard("get");
+            if (stop !== null)
+                return stop;
+            if (!idPattern.test(id) || familyOfId(id) === null) {
+                return refuse("invalid_id", { id });
+            }
+            const rec = held.get(id);
+            if (rec === undefined)
+                return refuse("not_found", { id });
+            return {
+                ok: true,
+                envelope: envelopeOf(rec),
+                body: replay(rec, lifecycleField(rec.family)),
+                events: rec.events.map((e) => ({ ...e }))
+            };
+        },
+        async query(q) {
+            const stop = guard("query");
+            if (stop !== null)
+                return stop;
+            let bounds;
+            try {
+                bounds = validate(q, false);
+            }
+            catch (ex) {
+                return asRefusal(ex);
+            }
+            let rows = allRows().filter((row) => matches(row, q));
+            rows = sortRows(rows, bounds.order);
+            if (q.cursor !== undefined) {
+                const after = decodeCursor(q.cursor, queryHash(q));
+                if (after === null)
+                    return refuse("invalid_cursor", {});
+                rows = afterKey(rows, after, bounds.order);
+            }
+            const page = rows.slice(0, bounds.limit);
+            const envelopes = page.map(stripRow);
+            if (rows.length > bounds.limit) {
+                const last = page[page.length - 1];
+                return {
+                    ok: true,
+                    envelopes,
+                    cursor: encodeCursor(sortKey(last), last.id, queryHash(q))
+                };
+            }
+            return { ok: true, envelopes };
+        },
+        async list(q) {
+            const stop = guard("list");
+            if (stop !== null)
+                return stop;
+            let bounds;
+            try {
+                bounds = validate(q, true);
+            }
+            catch (ex) {
+                return asRefusal(ex);
+            }
+            let rows = sortRows(allRows().filter((row) => matches(row, q)), bounds.order);
+            if (q.cursor !== undefined) {
+                const after = decodeCursor(q.cursor, queryHash(q));
+                if (after === null)
+                    return refuse("invalid_cursor", {});
+                rows = afterKey(rows, after, bounds.order);
+            }
+            const page = rows.slice(0, bounds.limit);
+            if (rows.length > bounds.limit) {
+                const last = page[page.length - 1];
+                return { ok: true, rows: page, cursor: encodeCursor(sortKey(last), last.id, queryHash(q)) };
+            }
+            return { ok: true, rows: page };
+        },
+        async count(args) {
+            const stop = guard("count");
+            if (stop !== null)
+                return stop;
+            if (!RECORD_COUNT_GROUPS.includes(args.groupBy)) {
+                return refuse("invalid_query", {
+                    errors: [`groupBy '${String(args.groupBy)}' is not one of ${RECORD_COUNT_GROUPS.join("|")}`]
+                });
+            }
+            const rows = allRows().filter((row) => args.family === undefined || row.type === args.family);
+            const tally = new Map();
+            for (const row of rows) {
+                const value = row[args.groupBy] ?? null;
+                tally.set(value, (tally.get(value) ?? 0) + 1);
+            }
+            const groups = [...tally.entries()]
+                .map(([value, count]) => ({ value, count }))
+                .sort((a, b) => cmp(a.value ?? "", b.value ?? ""));
+            return { ok: true, groups, total: groups.reduce((n, g) => n + g.count, 0) };
+        },
+        async reverseRefs(id, opts) {
+            const stop = guard("reverseRefs");
+            if (stop !== null)
+                return stop;
+            let bounds;
+            try {
+                bounds = validate({ limit: opts?.limit, order: opts?.order }, false);
+            }
+            catch (ex) {
+                return asRefusal(ex);
+            }
+            const rows = sortRows(allRows().filter((row) => row.refs.includes(id)), bounds.order).slice(0, bounds.limit);
+            return { ok: true, rows };
+        },
+        async materialize(prefix, cursor) {
+            const stop = guard("materialize");
+            if (stop !== null)
+                return stop;
+            // A stored record's family is what it was filed as; only an unknown
+            // id falls back to the prefix derivation.
+            const parsed = parsePrefix(prefix, (id) => held.get(id)?.family ?? familyOfId(id), idPattern);
+            if (parsed === null)
+                return refuse("invalid_prefix", { prefix });
+            const all = [...held.values()]
+                .filter((rec) => (parsed.family === null || rec.family === parsed.family) &&
+                (parsed.onlyId === null || rec.id === parsed.onlyId))
+                .sort((a, b) => cmp(`${a.family}/${a.id}`, `${b.family}/${b.id}`));
+            let index = 0;
+            if (cursor !== undefined) {
+                const at = decodeIndexCursor(cursor, hash(prefix));
+                if (at === null)
+                    return refuse("invalid_cursor", {});
+                index = at;
+            }
+            const slice = all.slice(index, index + pageEntries);
+            const entries = slice.map((rec) => ({
+                path: `${rec.family}/${rec.id}`,
+                bytes: new TextEncoder().encode(replay(rec, lifecycleField(rec.family)))
+            }));
+            const next = index + slice.length;
+            return next < all.length
+                ? { ok: true, entries, cursor: encodeIndexCursor(next, hash(prefix)) }
+                : { ok: true, entries };
+        },
+        ...(writable
+            ? {
+                async append(body) {
+                    const stop = guard("append");
+                    if (stop !== null)
+                        return stop;
+                    const text = typeof body === "string" ? body : new TextDecoder().decode(body);
+                    let fields;
+                    try {
+                        fields = parseRecordFrontmatter(text);
+                    }
+                    catch (ex) {
+                        return refuse("invalid_record", { errors: [ex.message] });
+                    }
+                    const id = str(fields.id);
+                    if (id === undefined) {
+                        return refuse("invalid_record", { errors: ["missing required field 'id'"] });
+                    }
+                    const named = familyOfId(id);
+                    if (!idPattern.test(id) || named === null) {
+                        return refuse("invalid_id", { id });
+                    }
+                    const errors = [];
+                    // With a declared prefix-to-family map the door's own rule
+                    // applies: the body's `type` must be the family its id names.
+                    // Without one, the body's `type` IS the family — see the
+                    // familyOfId option's note on why equality is not the default.
+                    const family = familyDeclared ? named : (str(fields.type) ?? named);
+                    if (familyDeclared && str(fields.type) !== named) {
+                        errors.push(`type '${String(fields.type)}' != family '${named}'`);
+                    }
+                    if (str(fields.created) === undefined && str(fields.ts) === undefined) {
+                        errors.push("missing created/ts");
+                    }
+                    if (str(fields.by) === undefined)
+                        errors.push("missing required field 'by'");
+                    if (errors.length > 0) {
+                        return refuse("invalid_record", { id, errors });
+                    }
+                    // forbidden outranks conflict and not_found: authorization is
+                    // judged before the record is looked for.
+                    if (!canWrite({ verb: "append", family, id })) {
+                        return refuse("forbidden", { actor: "(double)", verb: "append", family, id });
+                    }
+                    const sha = await sha256(text);
+                    const existing = held.get(id);
+                    if (existing !== undefined) {
+                        if (existing.sha === sha)
+                            return { ok: true, id, created: false };
+                        return refuse("conflict", { id, existing_sha256: existing.sha, offered_sha256: sha });
+                    }
+                    held.set(id, { id, family, body: text, sha, fields, events: [] });
+                    return { ok: true, id, created: true };
+                },
+                async transition(id, expected, next, event) {
+                    const stop = guard("transition");
+                    if (stop !== null)
+                        return stop;
+                    if (!hasSerializer) {
+                        return refuse("no_serializer", { id, verb: "transition" });
+                    }
+                    if (!idPattern.test(id) || familyOfId(id) === null) {
+                        return refuse("invalid_id", { id });
+                    }
+                    const family = familyOfId(id);
+                    const lifecycle = lifecycleField(family);
+                    if (lifecycle === null) {
+                        return refuse("illegal_transition", { id, family, expected, next });
+                    }
+                    // `expected === next` IS the note form. The wire contract's
+                    // published section does not say so; the reference
+                    // implementation does, and a note additionally requires
+                    // non-empty `fields` — it records something or it is noise.
+                    const isNote = expected === next;
+                    if (!isNote && !isLegalTransition(family, expected, next)) {
+                        return refuse("illegal_transition", { id, family, expected, next });
+                    }
+                    const missing = [];
+                    if (str(event?.by) === undefined)
+                        missing.push("by");
+                    if (isNote && (event?.fields === undefined || Object.keys(event.fields).length === 0)) {
+                        missing.push("fields");
+                    }
+                    if (missing.length > 0) {
+                        return refuse("invalid_event", { id, missing });
+                    }
+                    if (!canWrite({ verb: "transition", family, id })) {
+                        return refuse("forbidden", { actor: "(double)", verb: "transition", family, id });
+                    }
+                    const rec = held.get(id);
+                    if (rec === undefined)
+                        return refuse("not_found", { id });
+                    const current = lastTransition(rec.events)?.to ?? str(rec.fields[lifecycle]) ?? "";
+                    if (!isNote && current !== expected) {
+                        return refuse("stale", { id, expected, current });
+                    }
+                    const seq = rec.events.length + 1;
+                    const ev = {
+                        record: id,
+                        seq,
+                        kind: isNote ? "note" : "transition",
+                        ...(isNote ? {} : { from: expected, to: next }),
+                        by: event.by,
+                        ts: event.ts ?? new Date().toISOString(),
+                        ...(event.fields ? { fields: event.fields } : {})
+                    };
+                    rec.events.push(ev);
+                    return { ok: true, seq };
+                }
+            }
+            : {})
+    };
+    return rpc ? asRpcStub(door) : door;
+}
+/**
+ * The door, wearing a Cloudflare RPC service-binding stub's manners.
+ *
+ * The one property that matters: **every property access answers with a
+ * callable**, whether or not the door carries that verb. Calling one it does
+ * not carry rejects with a `TypeError`, which is the runtime's own wall and
+ * the only signal the seam gives — there is nothing to inspect beforehand.
+ *
+ * `then` is the deliberate exception, answered as `undefined`: a stub that
+ * claimed a `then` would be treated as a thenable by every `await` that ever
+ * touched it, and real RPC stubs are careful about exactly that.
+ *
+ * And the manners go one level down: a callable READ OFF the stub is itself
+ * proxy-mannered, so `stub.append.call` is not `Function.prototype.call` but
+ * a further RPC method named "call" — invoking it rejects method-missing,
+ * exactly as workerd does. That interception is what lets this double catch
+ * an extracted-and-re-invoked verb (`const v = stub.append; v.call(stub, …)`),
+ * the invocation shape that broke every real-binding write while the plainer
+ * double waved it through (fnd-2026-08-31-mount-write-call-invocation).
+ */
+function asRpcStub(door) {
+    return new Proxy(door, {
+        get(target, key, receiver) {
+            if (typeof key === "symbol")
+                return Reflect.get(target, key, receiver);
+            if (key === "then")
+                return undefined;
+            const held = Reflect.get(target, key, receiver);
+            const method = held === undefined ? methodMissing(String(key)) : held;
+            return typeof method === "function" ? asRpcMethod(method) : method;
+        },
+        // Presence is uninformative here too, which is the whole point: a client
+        // that reached for `in` instead of `typeof` would learn exactly as little.
+        has(target, key) {
+            return typeof key === "symbol" ? Reflect.has(target, key) : true;
+        }
+    });
+}
+/**
+ * A callable handed out by the RPC-faithful stub. Invoking it runs the
+ * door's method; reading any property off it — `call`, `apply`, `bind`,
+ * anything — answers another method-missing callable, because the real
+ * proxy answers property access with further RPC addressing, never with
+ * `Function.prototype`'s helpers.
+ */
+function asRpcMethod(fn) {
+    return new Proxy(fn, {
+        get(target, key, receiver) {
+            if (typeof key === "symbol")
+                return Reflect.get(target, key, receiver);
+            if (key === "then")
+                return undefined;
+            return methodMissing(String(key));
+        }
+    });
+}
+/**
+ * A verb the bound entrypoint does not carry.
+ *
+ * The message IMITATES workerd's method-missing shape (observed on the real
+ * seam, 2026-08-31) because the client's translation now keys on that shape:
+ * `does not implement` plus the quoted method name. A test may rely on the
+ * shape the client keys on; pinning the full sentence is still pinning a
+ * fixture's prose to a runtime's wording nobody here controls.
+ */
+function methodMissing(name) {
+    return async () => {
+        throw new TypeError(`The RPC receiver does not implement the method "${name}".`);
+    };
+}
+/** An `env`-shaped object carrying the double under a binding name — what
+ *  `openRecordDoor({ env, binding })` reads. */
+export function recordDoorEnv(binding, door) {
+    return { [binding]: door };
+}
+// --- the double's internals ------------------------------------------------
+/**
+ * A typed refusal, in one uniform message shape:
+ * `` `${code}: ${JSON.stringify(detail)}` ``.
+ *
+ * That is the record-door error type's own default, and the double uses it
+ * for every code deliberately. A real door authors bespoke prose at some
+ * sites and takes the default at others, so no fixture can match its
+ * messages text-for-text — and one that invented door-ish prose would be
+ * non-conformant in the least visible way. A single documented shape is the
+ * honest fixture.
+ *
+ * The one place message equality is load-bearing is `not_found`, and there
+ * the double and the door genuinely agree: every `not_found` a record door
+ * raises takes this default. That matters because the mount's read-policy
+ * denial must be byte-identical to real absence. This double previously
+ * wrote `not_found: <id>` — the *mount's* bespoke shape rather than the
+ * door's — so the suite proved indistinguishability against a fixture built
+ * to agree with the implementation, which is a builder-authored oracle
+ * passing itself on a security claim.
+ */
+function refuse(code, detail) {
+    return { ok: false, error: { code, detail, message: `${code}: ${JSON.stringify(detail)}` } };
+}
+class QueryRefusal extends Error {
+    errors;
+    constructor(errors) {
+        super(errors.join("; "));
+        this.errors = errors;
+    }
+}
+function asRefusal(ex) {
+    if (ex instanceof QueryRefusal) {
+        return refuse("invalid_query", { errors: ex.errors });
+    }
+    throw ex;
+}
+function validate(q, sets) {
+    const errors = [];
+    const known = new Set([...RECORD_EXACT_FILTERS, "ts", "due", "order", "limit", "cursor"]);
+    for (const key of Object.keys(q)) {
+        if (q[key] === undefined)
+            continue;
+        if (!known.has(key))
+            errors.push(`unknown filter field '${key}'`);
+    }
+    for (const key of RECORD_EXACT_FILTERS) {
+        const value = q[key];
+        if (value === undefined)
+            continue;
+        const isSet = RECORD_SET_FILTERS.includes(key);
+        if (Array.isArray(value)) {
+            if (!sets || !isSet) {
+                errors.push(`filter '${key}' is exact-match — a list is only legal on ${RECORD_SET_FILTERS.join("/")} at list`);
+                continue;
+            }
+            if (value.length === 0) {
+                errors.push(`empty set on filter '${key}' — an OR over nothing matches nothing; omit the filter`);
+            }
+            if (value.some((one) => typeof one !== "string" || one === "")) {
+                errors.push(`set filter '${key}' takes nonempty strings`);
+            }
+        }
+        for (const one of Array.isArray(value) ? value : [value]) {
+            if (typeof one === "string" && one.includes(",")) {
+                errors.push(`comma in exact-match filter '${key}': '${one}' — filters are exact-match, never lists`);
+            }
+        }
+    }
+    if (q.order !== undefined && q.order !== "asc" && q.order !== "desc") {
+        errors.push(`order must be asc|desc, got '${String(q.order)}'`);
+    }
+    const limit = q.limit ?? 100;
+    if (!Number.isInteger(limit) || limit < 1 || limit > MAX_LIMIT) {
+        errors.push(`limit out of bounds: ${String(q.limit)} (1..${MAX_LIMIT})`);
+    }
+    for (const key of ["ts", "due"]) {
+        const range = q[key];
+        if (range === undefined)
+            continue;
+        if (typeof range !== "object" ||
+            range === null ||
+            Array.isArray(range) ||
+            Object.keys(range).some((k) => k !== "gte" && k !== "lte") ||
+            (range.gte === undefined && range.lte === undefined)) {
+            errors.push(`malformed range on '${key}' — {gte?, lte?} with at least one bound`);
+        }
+    }
+    if (errors.length > 0)
+        throw new QueryRefusal(errors);
+    return { limit, order: q.order ?? "asc" };
+}
+function matches(row, q) {
+    for (const key of RECORD_EXACT_FILTERS) {
+        const want = q[key];
+        if (want === undefined)
+            continue;
+        const have = key === "family" ? row.type : row[key];
+        const wanted = Array.isArray(want) ? want : [want];
+        if (!wanted.includes(have))
+            return false;
+    }
+    const key = sortKey(row);
+    if (q.ts?.gte !== undefined && key < q.ts.gte)
+        return false;
+    if (q.ts?.lte !== undefined && key > q.ts.lte)
+        return false;
+    if (q.due?.gte !== undefined && (row.due ?? "") < q.due.gte)
+        return false;
+    if (q.due?.lte !== undefined && (row.due ?? "") > q.due.lte)
+        return false;
+    return true;
+}
+function sortKey(row) {
+    return row.ts ?? (row.created !== undefined ? `${row.created}T00:00:00Z` : "");
+}
+function sortRows(rows, order) {
+    const out = [...rows].sort((a, b) => cmp(sortKey(a), sortKey(b)) || cmp(a.id, b.id));
+    return order === "asc" ? out : out.reverse();
+}
+function afterKey(rows, after, order) {
+    return rows.filter((row) => {
+        const c = cmp(sortKey(row), after[0]) || cmp(row.id, after[1]);
+        return order === "asc" ? c > 0 : c < 0;
+    });
+}
+function stripRow(row) {
+    const { headline: _h, head_ts: _t, ...envelope } = row;
+    return envelope;
+}
+function cmp(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function lastTransition(events) {
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        if (events[i].kind === "transition")
+            return events[i];
+    }
+    return undefined;
+}
+/** The lifecycle line, rewritten to the last transition's target — the
+ *  double's whole replay. The real substrate projects more (a decision's
+ *  signature fields, per-family edges); nothing generic can. */
+function replay(rec, lifecycle) {
+    const last = lastTransition(rec.events);
+    if (last === undefined || lifecycle === null || last.to === undefined)
+        return rec.body;
+    const end = rec.body.indexOf("\n---", 4);
+    if (end === -1)
+        return rec.body;
+    const lines = rec.body.slice(4, end).split("\n");
+    const at = lines.findIndex((line) => line.startsWith(`${lifecycle}:`));
+    if (at >= 0)
+        lines[at] = `${lifecycle}: ${last.to}`;
+    else
+        lines.push(`${lifecycle}: ${last.to}`);
+    return `---\n${lines.join("\n")}${rec.body.slice(end)}`;
+}
+function defaultHeadline({ envelope, body }) {
+    for (const line of recordProseOf(body).split("\n")) {
+        const text = line.trim();
+        if (text.startsWith("# "))
+            return clip(text.slice(2).trim());
+        if (text.length > 0)
+            return clip(text);
+    }
+    const cut = envelope.id.match(/^[a-z0-9]+-\d{4}-\d{2}-\d{2}-(.+)$/);
+    return clip(cut === null ? envelope.id : cut[1]);
+}
+function clip(text) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length <= 160 ? flat : `${flat.slice(0, 160).replace(/\s\S*$/, "")}…`;
+}
+function defaultRefs(fields) {
+    const out = [];
+    const refs = fields.refs;
+    if (Array.isArray(refs))
+        out.push(...refs.filter((r) => typeof r === "string"));
+    const single = str(fields.ref);
+    if (single !== undefined)
+        out.push(single);
+    return [...new Set(out)];
+}
+function str(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function parsePrefix(prefix, familyOfId, idPattern) {
+    if (prefix === "")
+        return { family: null, onlyId: null };
+    const [head, ...tail] = prefix.split("/");
+    if (head.length === 0 || tail.length > 1)
+        return null;
+    if (tail.length === 0)
+        return { family: head, onlyId: null };
+    const onlyId = tail[0];
+    if (!idPattern.test(onlyId) || familyOfId(onlyId) !== head)
+        return null;
+    return { family: head, onlyId };
+}
+async function sha256(text) {
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+    return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+/** Cursors are opaque and only their binding matters, so the double binds
+ *  them with a cheap non-cryptographic hash rather than pretending to a
+ *  digest it does not need. */
+function hash(text) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < text.length; i += 1) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return h.toString(16).padStart(8, "0");
+}
+function queryHash(q) {
+    const filters = {};
+    for (const key of RECORD_EXACT_FILTERS) {
+        const value = q[key];
+        if (value === undefined)
+            continue;
+        filters[key] = Array.isArray(value) ? [...value].sort() : value;
+    }
+    for (const key of ["ts", "due"]) {
+        const range = q[key];
+        if (range !== undefined)
+            filters[key] = { gte: range.gte ?? null, lte: range.lte ?? null };
+    }
+    filters.order = q.order ?? "asc";
+    return hash(JSON.stringify(filters));
+}
+function b64url(text) {
+    return btoa(text).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function unb64url(text) {
+    const padded = text.replace(/-/g, "+").replace(/_/g, "/");
+    return atob(padded + "=".repeat((4 - (padded.length % 4)) % 4));
+}
+function encodeCursor(key, id, bound) {
+    return b64url(JSON.stringify({ k: [key, id], h: bound }));
+}
+function decodeCursor(cursor, bound) {
+    try {
+        const parsed = JSON.parse(unb64url(cursor));
+        if (!Array.isArray(parsed.k) || parsed.k.length !== 2 || parsed.h !== bound)
+            return null;
+        return [String(parsed.k[0]), String(parsed.k[1])];
+    }
+    catch {
+        return null;
+    }
+}
+function encodeIndexCursor(index, bound) {
+    return b64url(JSON.stringify({ i: index, h: bound }));
+}
+function decodeIndexCursor(cursor, bound) {
+    try {
+        const parsed = JSON.parse(unb64url(cursor));
+        if (typeof parsed.i !== "number" || parsed.h !== bound)
+            return null;
+        return parsed.i;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=testing.js.map