@akagilnc/pi-workflow-roles 0.1.1751

package/dist/activation-ledger-session.js

@@ -0,0 +1,120 @@
+import { lstatSync, realpathSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { activationBookDirectory, ensureRealDirectoryTree, errnoCode, errorText, pathContainedIn, } from "./activation-ledger-topology.js";
+export function childSessionManager(parent, cwd, childDirectory) {
+    const parentSession = parent?.getSessionFile();
+    return parentSession === undefined
+        ? SessionManager.inMemory(cwd)
+        : SessionManager.create(cwd, join(parent.getSessionDir(), childDirectory), { parentSession });
+}
+/**
+ * Typed missing durable session principal. Callers discriminate with instanceof/code;
+ * never by parsing message prose. Original filesystem causes are retained.
+ */
+export class ActivationSessionFileMissingError extends Error {
+    code = "AK_ACTIVATION_SESSION_FILE_MISSING";
+    path;
+    constructor(path, options) {
+        super(`Workflow role activation durable session file does not exist: ${path}`, options?.cause === undefined ? undefined : { cause: options.cause });
+        this.name = "ActivationSessionFileMissingError";
+        this.path = path;
+    }
+}
+function materializeDeferredSessionFile(sessionManager, resolvedFile, ledgerHome) {
+    const header = sessionManager.getHeader?.();
+    if (header === null || header === undefined || header.type !== "session") {
+        throw new ActivationSessionFileMissingError(resolvedFile);
+    }
+    ensureRealDirectoryTree(ledgerHome, dirname(resolvedFile));
+    try {
+        writeFileSync(resolvedFile, `${JSON.stringify(header)}\n`, { flag: "wx" });
+    }
+    catch (error) {
+        if (errnoCode(error) !== "EEXIST") {
+            throw new Error(`Workflow role activation failed to materialize durable session file (${resolvedFile}): ${errorText(error)}`, { cause: error });
+        }
+        // Lost a create race — validate the winner below.
+    }
+    // Rebind full SessionManager so subsequent Pi appends use O_APPEND (flushed=true)
+    // instead of exclusive wx create against the file we just wrote.
+    if (typeof sessionManager.setSessionFile === "function") {
+        sessionManager.setSessionFile(resolvedFile);
+    }
+}
+/**
+ * Admit only a durable Pi session file principal under the resolved machine ledger
+ * book (ADR 0048). Requires an existing regular file at admission: resolve real paths
+ * and prove containment under the real book. Reject relative paths, outside-book paths,
+ * directories, symlink escapes, and nonexistent paths that cannot be materialized from
+ * the live SessionManager header. Original filesystem causes are retained.
+ *
+ * Upstream Pi defers exclusive create until the first assistant message. When the path
+ * is the live SessionManager principal under the book and only the header is in memory,
+ * admission materializes that header onto the same path before the fact is written so
+ * the role fact never points at a session that may be created later.
+ */
+export function durableSessionPointer(sessionManager, options) {
+    const file = sessionManager.getSessionFile?.();
+    if (typeof file !== "string" || file.length === 0) {
+        throw new Error("Workflow role activation requires a durable Pi session file principal (getSessionFile); directory-only or --no-session invocations are rejected");
+    }
+    if (!isAbsolute(file)) {
+        throw new Error(`Workflow role activation requires an absolute durable session file path under the machine ledger book; got relative path: ${file}`);
+    }
+    const resolvedFile = resolve(file);
+    const bookRoot = resolve(activationBookDirectory(options.ledgerHome, options.bookKey));
+    if (!pathContainedIn(bookRoot, resolvedFile)) {
+        throw new Error(`Workflow role activation requires the durable session file principal under the machine ledger book (${bookRoot}); got: ${resolvedFile}`);
+    }
+    try {
+        lstatSync(resolvedFile);
+    }
+    catch (error) {
+        if (errnoCode(error) !== "ENOENT") {
+            throw new Error(`Workflow role activation failed to stat durable session file (${resolvedFile}): ${errorText(error)}`, { cause: error });
+        }
+        try {
+            materializeDeferredSessionFile(sessionManager, resolvedFile, options.ledgerHome);
+        }
+        catch (materializeError) {
+            // Missing principal: rethrow typed missing-file identity with the original ENOENT cause.
+            // Other materialize failures keep their own typed/native identity.
+            if (materializeError instanceof ActivationSessionFileMissingError) {
+                throw new ActivationSessionFileMissingError(resolvedFile, { cause: error });
+            }
+            throw materializeError;
+        }
+    }
+    let realBook;
+    try {
+        realBook = realpathSync(bookRoot);
+    }
+    catch (error) {
+        throw new Error(`Workflow role activation machine ledger book is not resolvable (${bookRoot}): ${errorText(error)}`, { cause: error });
+    }
+    let realFile;
+    try {
+        realFile = realpathSync(resolvedFile);
+    }
+    catch (error) {
+        throw new ActivationSessionFileMissingError(resolvedFile, { cause: error });
+    }
+    if (!pathContainedIn(realBook, realFile)) {
+        throw new Error(`Workflow role activation requires the durable session file principal under the machine ledger book (${realBook}); got: ${realFile}`);
+    }
+    let info;
+    try {
+        info = statSync(realFile);
+    }
+    catch (error) {
+        throw new Error(`Workflow role activation failed to stat durable session file (${realFile}): ${errorText(error)}`, { cause: error });
+    }
+    if (info.isDirectory()) {
+        throw new Error(`Workflow role activation durable session principal must be a file, not a directory: ${realFile}`);
+    }
+    if (!info.isFile()) {
+        throw new Error(`Workflow role activation durable session principal is not a regular file: ${realFile}`);
+    }
+    return { kind: "session-file", path: realFile };
+}

package/dist/activation-ledger-topology.js

@@ -0,0 +1,239 @@
+import {
+  lstatSync,
+  mkdirSync,
+  realpathSync,
+  statSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+class ActivationLedgerError extends Error {
+  code = "AK_ACTIVATION_LEDGER";
+  constructor(message, options) {
+    super(
+      message,
+      options?.cause === void 0 ? void 0 : { cause: options.cause }
+    );
+    this.name = "ActivationLedgerError";
+  }
+}
+function resolveActivationLedgerHome(home = homedir) {
+  const processHome = home();
+  if (typeof processHome !== "string" || processHome.length === 0 || !isAbsolute(processHome)) {
+    throw new ActivationLedgerError(
+      `activation ledger process home must be absolute, got ${JSON.stringify(processHome)}`
+    );
+  }
+  return resolve(processHome, ".ak-roles");
+}
+function activationBookDirectory(ledgerHome, bookKey) {
+  return join(ledgerHome, "books", bookKey);
+}
+function activationWaitingLedgerPath(ledgerHome, bookKey) {
+  return join(activationBookDirectory(ledgerHome, bookKey), "waiting.jsonl");
+}
+function pathContainedIn(root, candidate) {
+  const rel = relative(root, candidate);
+  return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+function physicalPathIdentity(path) {
+  const absolute = resolve(path);
+  const missing = [];
+  let cursor = absolute;
+  while (true) {
+    try {
+      const real = realpathSync(cursor);
+      return missing.length === 0 ? real : join(real, ...missing);
+    } catch (error) {
+      if (errnoCode(error) !== "ENOENT") {
+        return absolute;
+      }
+      const parent = dirname(cursor);
+      if (parent === cursor) return absolute;
+      missing.unshift(basename(cursor));
+      cursor = parent;
+    }
+  }
+}
+function physicallyContainedIn(root, candidate) {
+  return pathContainedIn(physicalPathIdentity(root), physicalPathIdentity(candidate));
+}
+function errnoCode(error) {
+  return error !== null && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+function errorText(error) {
+  if (!(error instanceof Error)) return String(error);
+  return error.message;
+}
+function assertPhysicalLedgerRoot(absoluteRoot) {
+  let st;
+  try {
+    st = lstatSync(absoluteRoot);
+  } catch (error) {
+    if (errnoCode(error) !== "ENOENT") {
+      throw new ActivationLedgerError(
+        `activation ledger failed to stat home (${absoluteRoot}): ${errorText(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  if (st === void 0) {
+    try {
+      mkdirSync(absoluteRoot, { recursive: true });
+    } catch (error) {
+      if (errnoCode(error) !== "EEXIST") {
+        throw new ActivationLedgerError(
+          `activation ledger failed to create home (${absoluteRoot}): ${errorText(error)}`,
+          { cause: error }
+        );
+      }
+    }
+    try {
+      st = lstatSync(absoluteRoot);
+    } catch (error) {
+      throw new ActivationLedgerError(
+        `activation ledger failed to stat home (${absoluteRoot}): ${errorText(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  if (st.isSymbolicLink()) {
+    throw new ActivationLedgerError(
+      `activation ledger home is a symbolic link: ${absoluteRoot}`
+    );
+  }
+  if (!st.isDirectory()) {
+    throw new ActivationLedgerError(`activation ledger home is not a directory: ${absoluteRoot}`);
+  }
+}
+function ensureRealDirectoryTree(root, targetDir) {
+  if (!isAbsolute(root)) {
+    throw new ActivationLedgerError(`activation ledger home must be absolute: ${root}`);
+  }
+  const absoluteRoot = resolve(root);
+  const absoluteTarget = resolve(targetDir);
+  if (absoluteTarget !== absoluteRoot && !pathContainedIn(absoluteRoot, absoluteTarget)) {
+    throw new ActivationLedgerError(
+      `activation ledger path escapes ledger home (${absoluteRoot}): ${absoluteTarget}`
+    );
+  }
+  assertPhysicalLedgerRoot(absoluteRoot);
+  let realRoot;
+  try {
+    realRoot = realpathSync(absoluteRoot);
+  } catch (error) {
+    throw new ActivationLedgerError(
+      `activation ledger home is not resolvable (${absoluteRoot}): ${errorText(error)}`,
+      { cause: error }
+    );
+  }
+  if (!statSync(realRoot).isDirectory()) {
+    throw new ActivationLedgerError(`activation ledger home is not a directory: ${realRoot}`);
+  }
+  const rel = absoluteTarget === absoluteRoot ? "" : relative(absoluteRoot, absoluteTarget);
+  if (rel === "") return realRoot;
+  if (isAbsolute(rel) || rel === ".." || rel.startsWith(`..${sep}`)) {
+    throw new ActivationLedgerError(
+      `activation ledger path escapes ledger home (${absoluteRoot}): ${absoluteTarget}`
+    );
+  }
+  let lexicalCursor = absoluteRoot;
+  for (const part of rel.split(sep)) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      throw new ActivationLedgerError(`activation ledger path contains '..': ${absoluteTarget}`);
+    }
+    lexicalCursor = join(lexicalCursor, part);
+    let st;
+    try {
+      st = lstatSync(lexicalCursor);
+    } catch (error) {
+      if (errnoCode(error) !== "ENOENT") {
+        throw new ActivationLedgerError(
+          `activation ledger failed to stat path component (${lexicalCursor}): ${errorText(error)}`,
+          { cause: error }
+        );
+      }
+      try {
+        mkdirSync(lexicalCursor);
+      } catch (mkdirError) {
+        if (errnoCode(mkdirError) !== "EEXIST") {
+          throw new ActivationLedgerError(
+            `activation ledger failed to create directory (${lexicalCursor}): ${errorText(mkdirError)}`,
+            { cause: mkdirError }
+          );
+        }
+      }
+      try {
+        st = lstatSync(lexicalCursor);
+      } catch (statError) {
+        throw new ActivationLedgerError(
+          `activation ledger failed to stat path component (${lexicalCursor}): ${errorText(statError)}`,
+          { cause: statError }
+        );
+      }
+    }
+    if (st.isSymbolicLink()) {
+      throw new ActivationLedgerError(
+        `activation ledger path component is a symbolic link: ${lexicalCursor}`
+      );
+    }
+    if (!st.isDirectory()) {
+      throw new ActivationLedgerError(`activation ledger path component is not a directory: ${lexicalCursor}`);
+    }
+    let realCursor;
+    try {
+      realCursor = realpathSync(lexicalCursor);
+    } catch (error) {
+      throw new ActivationLedgerError(
+        `activation ledger path component is not resolvable (${lexicalCursor}): ${errorText(error)}`,
+        { cause: error }
+      );
+    }
+    if (realCursor !== realRoot && !pathContainedIn(realRoot, realCursor)) {
+      throw new ActivationLedgerError(
+        `activation ledger path component escapes ledger home (${lexicalCursor} -> ${realCursor})`
+      );
+    }
+  }
+  try {
+    return realpathSync(absoluteTarget);
+  } catch (error) {
+    throw new ActivationLedgerError(
+      `activation ledger directory is not resolvable (${absoluteTarget}): ${errorText(error)}`,
+      { cause: error }
+    );
+  }
+}
+function assertLedgerFileInsideHome(ledgerPath, ledgerHome) {
+  if (!isAbsolute(ledgerHome)) {
+    throw new ActivationLedgerError(`activation ledger home must be absolute: ${ledgerHome}`);
+  }
+  const resolvedLedger = resolve(ledgerPath);
+  try {
+    if (!lstatSync(resolvedLedger).isSymbolicLink()) return;
+    throw new ActivationLedgerError(
+      `activation ledger file is a symbolic link: ${resolvedLedger}`
+    );
+  } catch (error) {
+    if (errnoCode(error) !== "ENOENT") {
+      if (error instanceof ActivationLedgerError) throw error;
+      throw new ActivationLedgerError(
+        `activation ledger failed to stat ledger file (${resolvedLedger}): ${errorText(error)}`,
+        { cause: error }
+      );
+    }
+  }
+}
+export {
+  ActivationLedgerError,
+  activationBookDirectory,
+  activationWaitingLedgerPath,
+  assertLedgerFileInsideHome,
+  ensureRealDirectoryTree,
+  errnoCode,
+  errorText,
+  pathContainedIn,
+  physicalPathIdentity,
+  physicallyContainedIn,
+  resolveActivationLedgerHome
+};

package/dist/activation-reconciliation.js

@@ -0,0 +1,61 @@
+const DISPATCH_STUB_EVENT = "dispatch-stub";
+function buildDispatchStubFact(input) {
+  return {
+    event: DISPATCH_STUB_EVENT,
+    observedAt: input.observedAt,
+    bookKey: input.bookKey,
+    dispatch: input.dispatch.kind === "process" ? { kind: "process", pid: input.dispatch.pid } : { kind: "opaque", ref: input.dispatch.ref },
+    correlation: { kind: "caller", id: input.correlation.id }
+  };
+}
+function callerCorrelationId(correlation) {
+  return correlation.kind === "caller" ? correlation.id : void 0;
+}
+function dispatchMatchesActivation(dispatch, activation) {
+  const activationId = callerCorrelationId(activation.correlation);
+  return activationId !== void 0 && activationId === dispatch.correlation.id && activation.bookKey === dispatch.bookKey;
+}
+function reconcileInvocation(subject) {
+  const { dispatch, activation, process } = subject;
+  if (activation !== void 0) {
+    if (dispatch !== void 0 && dispatchMatchesActivation(dispatch, activation)) {
+      return {
+        kind: "matched",
+        correlationId: dispatch.correlation.id,
+        bookKey: dispatch.bookKey
+      };
+    }
+    return {
+      kind: "activation-without-dispatch",
+      correlationId: callerCorrelationId(activation.correlation),
+      bookKey: activation.bookKey
+    };
+  }
+  if (dispatch !== void 0) {
+    if (process === void 0) {
+      throw new TypeError(
+        "reconcileInvocation requires process liveness when activation is absent"
+      );
+    }
+    if (process.state === "alive") {
+      return {
+        kind: "pending",
+        correlationId: dispatch.correlation.id,
+        bookKey: dispatch.bookKey
+      };
+    }
+    return {
+      kind: "ghost",
+      correlationId: dispatch.correlation.id,
+      bookKey: dispatch.bookKey
+    };
+  }
+  throw new TypeError(
+    "reconcileInvocation requires a dispatch stub and/or an accepted-activation fact"
+  );
+}
+export {
+  DISPATCH_STUB_EVENT,
+  buildDispatchStubFact,
+  reconcileInvocation
+};

package/dist/audit-escalation.js

@@ -0,0 +1,108 @@
+export const AUDIT_ESCALATION_KIND = "audit_escalation";
+// Live Navigator settlement may consume only the projection produced by this
+// owner. Its private WeakSet cannot be authored by role output; persisted/
+// replayed records are re-authenticated by the retained audit evidence binder.
+const AUDIT_ESCALATION_LIVE_REGISTRY = new WeakSet();
+/**
+ * Build the escalation delivery face.
+ * Role-delivered fields ride under the escalation discriminator (ADR 0055).
+ * `kind` always wins so the discriminator cannot be laundered.
+ * `conflicts` and `auditDecisionGate`, when present, always come from the
+ * audit (why we escalated and its gate). Raw ancillary values are not repaired.
+ * A role `decisionGate`, when present, stays at its own key via spread and is
+ * never overwritten (not folded, not dropped, not swapped into the audit home).
+ */
+export function buildAuditEscalationResult(decision, deliveredOutput) {
+    const auditOwned = {
+        kind: AUDIT_ESCALATION_KIND,
+    };
+    if (Object.hasOwn(decision, "conflicts")) {
+        auditOwned.conflicts = decision.conflicts;
+    }
+    if (Object.hasOwn(decision, "decisionGate")) {
+        auditOwned.auditDecisionGate = decision.decisionGate;
+    }
+    const deliveredFields = deliveredOutput !== undefined &&
+        deliveredOutput !== null &&
+        typeof deliveredOutput === "object" &&
+        !Array.isArray(deliveredOutput)
+        ? { ...deliveredOutput }
+        : {};
+    // Role output cannot fill an absent audit-owned field.
+    delete deliveredFields.conflicts;
+    delete deliveredFields.auditDecisionGate;
+    const result = {
+        ...deliveredFields,
+        ...auditOwned,
+    };
+    AUDIT_ESCALATION_LIVE_REGISTRY.add(result);
+    return result;
+}
+/** True only for the audit-owned live projection, never for role-shaped data. */
+export function isAuditEscalationProjection(value) {
+    if (!isAuditEscalationResult(value))
+        return false;
+    return AUDIT_ESCALATION_LIVE_REGISTRY.has(value);
+}
+function humanDecisionText(result) {
+    const lines = ["Human decision required: compliance audit escalation."];
+    if (Array.isArray(result.conflicts)) {
+        lines.push("Conflicts:", ...result.conflicts.map((conflict) => `- ${conflict}`));
+    }
+    const gate = result.auditDecisionGate;
+    if (gate !== null && typeof gate === "object" && !Array.isArray(gate)) {
+        const record = gate;
+        if (typeof record.question === "string")
+            lines.push(`Question: ${record.question}`);
+        if (Array.isArray(record.options)) {
+            lines.push("Options:", ...record.options.map((option) => `- ${option}`));
+        }
+    }
+    return lines.join("\n");
+}
+export function projectAuditEscalation(decision, deliveredOutput) {
+    const details = buildAuditEscalationResult(decision, deliveredOutput);
+    return {
+        content: [{ type: "text", text: humanDecisionText(details) }],
+        details,
+        terminate: true,
+        ...(decision.usage === undefined ? {} : { usage: decision.usage }),
+    };
+}
+export function projectAuditIncomplete(decision) {
+    return {
+        content: [{ type: "text", text: "Compliance audit incomplete; no role receipt was formed." }],
+        details: decision,
+        terminate: true,
+        ...(decision.usage === undefined ? {} : { usage: decision.usage }),
+    };
+}
+/**
+ * Discriminator-only recognition (ADR 0040). Shape of conflicts/options/gate
+ * is not a reject gate — element types and cardinality are delivery content.
+ */
+export function isAuditEscalationResult(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    return value.kind === AUDIT_ESCALATION_KIND;
+}
+/**
+ * Dispose a parsed audit decision without repeating status handling in roles.
+ * Role output already delivered is preserved on the escalate face (ADR 0055).
+ */
+export async function disposeComplianceDecision(decision, handlers, deliveredOutput) {
+    switch (decision.status) {
+        case "pass":
+            return await handlers.pass(decision.usage);
+        case "revise":
+            return await handlers.revise(decision.violations);
+        case "escalate":
+            return await handlers.escalate(projectAuditEscalation(decision, deliveredOutput));
+        case "audit-incomplete":
+            if (handlers.auditIncomplete === undefined) {
+                throw new Error("Compliance audit-incomplete handler is unavailable");
+            }
+            return await handlers.auditIncomplete(projectAuditIncomplete(decision));
+    }
+}

package/dist/auditor-dossier-tool.js

@@ -0,0 +1,35 @@
+import { dirname, join, resolve } from "node:path";
+import { Type } from "typebox";
+export const AUDITOR_DOSSIER_TOOL_NAME = "ak_get_run_dossier";
+/** Resolve the exact run binding already carried by the parent record session. */
+export function auditorRunDirectory(context) {
+    const sessionFile = context.sessionManager?.getSessionFile?.();
+    return sessionFile === undefined ? undefined : resolve(dirname(dirname(sessionFile)));
+}
+/** The one shared, run-bound dossier locator exposed to every auditor seat. */
+export function createAuditorDossierTool(runDirectory) {
+    return {
+        name: AUDITOR_DOSSIER_TOOL_NAME,
+        description: "Locate this auditor's bound run dossier and its evidence entry points.",
+        parameters: Type.Object({}, { additionalProperties: false }),
+        async execute(_id, _params) {
+            if (runDirectory === undefined) {
+                return {
+                    content: [{ type: "text", text: "This auditor has no run-bound dossier record." }],
+                    details: undefined,
+                };
+            }
+            const details = {
+                runDirectory,
+                admittedRequest: join(runDirectory, "admitted-request.json"),
+                parentSessionCandidate: join(runDirectory, "session", "session.jsonl"),
+                attachments: join(runDirectory, "attachments"),
+                artifacts: join(runDirectory, "artifacts"),
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(details) }],
+                details,
+            };
+        },
+    };
+}

package/dist/canonical-json.js

@@ -0,0 +1,78 @@
+export const CANONICAL_JSON_VALIDATION_ERROR_CODE = "canonical-json-invalid";
+export class CanonicalJsonValidationError extends Error {
+    path;
+    reason;
+    code = CANONICAL_JSON_VALIDATION_ERROR_CODE;
+    constructor(path, reason) {
+        super(`Canonical JSON validation failed at ${path}: ${reason}`);
+        this.path = path;
+        this.reason = reason;
+        this.name = "CanonicalJsonValidationError";
+    }
+}
+function childPath(path, segment) {
+    return `${path}/${String(segment).replaceAll("~", "~0").replaceAll("/", "~1")}`;
+}
+function ownStringKeys(value, path) {
+    const keys = Reflect.ownKeys(value);
+    if (keys.some((key) => typeof key === "symbol")) {
+        throw new CanonicalJsonValidationError(childPath(path, "<symbol>"), "symbol-keyed member is not a JSON member");
+    }
+    return keys;
+}
+/** Deterministic serialization of the closed JSON value domain. */
+export function canonicalJson(value) {
+    const ancestors = new WeakSet();
+    const serialize = (item, path) => {
+        if (item === null)
+            return "null";
+        switch (typeof item) {
+            case "boolean":
+            case "string":
+                return JSON.stringify(item);
+            case "number":
+                if (!Number.isFinite(item))
+                    throw new CanonicalJsonValidationError(path, "number must be finite");
+                return JSON.stringify(item);
+            case "undefined":
+            case "function":
+            case "symbol":
+            case "bigint":
+                throw new CanonicalJsonValidationError(path, `${typeof item} is not a JSON value`);
+            case "object": {
+                if (ancestors.has(item))
+                    throw new CanonicalJsonValidationError(path, "cycle is not a JSON value");
+                ancestors.add(item);
+                try {
+                    if (Array.isArray(item)) {
+                        if (Object.getPrototypeOf(item) !== Array.prototype)
+                            throw new CanonicalJsonValidationError(path, "array must not be a custom object");
+                        const keys = ownStringKeys(item, path);
+                        const extraKey = keys.find((key) => key !== "length" && (!/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= item.length));
+                        if (extraKey !== undefined)
+                            throw new CanonicalJsonValidationError(childPath(path, extraKey), "non-index array member is not a JSON member");
+                        const values = [];
+                        for (let index = 0; index < item.length; index += 1) {
+                            if (!Object.hasOwn(item, index))
+                                throw new CanonicalJsonValidationError(childPath(path, index), "sparse array slot is not a JSON value");
+                            values.push(serialize(item[index], childPath(path, index)));
+                        }
+                        return `[${values.join(",")}]`;
+                    }
+                    const prototype = Object.getPrototypeOf(item);
+                    if (prototype !== Object.prototype && prototype !== null)
+                        throw new CanonicalJsonValidationError(path, "object must be a plain record");
+                    return `{${ownStringKeys(item, path).sort().map((key) => `${JSON.stringify(key)}:${serialize(item[key], childPath(path, key))}`).join(",")}}`;
+                }
+                finally {
+                    ancestors.delete(item);
+                }
+            }
+        }
+        throw new Error("Unreachable canonical JSON value type");
+    };
+    return serialize(value, "$");
+}
+export function canonicalJsonBytes(value) {
+    return new TextEncoder().encode(canonicalJson(value));
+}