@hasna/mementos 0.14.74 → 0.14.78

package/dist/project-registration.js

@@ -0,0 +1,1496 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/project-registration/schema.ts
+function sqliteMementosProjectRegistrationSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_project_registration_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL,
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      resource_kind TEXT NOT NULL CHECK(resource_kind = 'project'),
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'inverse')),
+      target_selector TEXT NOT NULL,
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      normalized_call_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome IN (
+        'accepted', 'duplicate_of_accepted', 'terminal_nonacceptance'
+      )),
+      reason TEXT,
+      target_id TEXT,
+      result_revision TEXT,
+      result_digest TEXT,
+      duplicate_of_receipt_id TEXT,
+      accepted_receipt_id TEXT,
+      created_by_operation INTEGER NOT NULL CHECK(created_by_operation IN (0, 1)),
+      created_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_project_registration_receipts_lookup
+      ON mementos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction, idempotency_key, target_selector
+      );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_mementos_project_registration_receipts_accepted_step
+      ON mementos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction
+      )
+      WHERE outcome = 'accepted';
+
+    CREATE TABLE IF NOT EXISTS mementos_project_registration_bindings (
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      resource_kind TEXT NOT NULL CHECK(resource_kind = 'project'),
+      target_selector TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction = 'forward'),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      normalized_call_digest TEXT NOT NULL,
+      state TEXT NOT NULL CHECK(state IN (
+        'pending', 'accepted', 'terminal_nonacceptance', 'removed'
+      )),
+      target_id TEXT,
+      accepted_receipt_id TEXT,
+      result_revision TEXT,
+      result_digest TEXT,
+      removed_receipt_id TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY(authority_id, tenant_id, corpus_id, resource_kind, target_selector),
+      UNIQUE(accepted_receipt_id)
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_mementos_project_registration_binding_target
+      ON mementos_project_registration_bindings(
+        authority_id, tenant_id, corpus_id, resource_kind, target_id
+      )
+      WHERE target_id IS NOT NULL;
+
+    CREATE TRIGGER IF NOT EXISTS mementos_project_registration_receipts_immutable_update
+    BEFORE UPDATE ON mementos_project_registration_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos project registration receipts are immutable');
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS mementos_project_registration_receipts_immutable_delete
+    BEFORE DELETE ON mementos_project_registration_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos project registration receipts are immutable');
+    END;
+  `;
+}
+function postgresMementosProjectRegistrationSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_project_registration_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL,
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      resource_kind TEXT NOT NULL CHECK(resource_kind = 'project'),
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'inverse')),
+      target_selector TEXT NOT NULL,
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      normalized_call_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome IN (
+        'accepted', 'duplicate_of_accepted', 'terminal_nonacceptance'
+      )),
+      reason TEXT,
+      target_id TEXT,
+      result_revision TEXT,
+      result_digest TEXT,
+      duplicate_of_receipt_id TEXT,
+      accepted_receipt_id TEXT,
+      created_by_operation BOOLEAN NOT NULL,
+      created_at TIMESTAMPTZ NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_project_registration_receipts_lookup
+      ON mementos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction, idempotency_key, target_selector
+      );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_mementos_project_registration_receipts_accepted_step
+      ON mementos_project_registration_receipts (
+        authority_id, tenant_id, corpus_id, operation_id, step_id,
+        resource_kind, direction
+      )
+      WHERE outcome = 'accepted';
+
+    CREATE TABLE IF NOT EXISTS mementos_project_registration_bindings (
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      resource_kind TEXT NOT NULL CHECK(resource_kind = 'project'),
+      target_selector TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction = 'forward'),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      precondition_digest TEXT NOT NULL,
+      normalized_call_digest TEXT NOT NULL,
+      state TEXT NOT NULL CHECK(state IN (
+        'pending', 'accepted', 'terminal_nonacceptance', 'removed'
+      )),
+      target_id TEXT,
+      accepted_receipt_id TEXT UNIQUE,
+      result_revision TEXT,
+      result_digest TEXT,
+      removed_receipt_id TEXT,
+      created_at TIMESTAMPTZ NOT NULL,
+      updated_at TIMESTAMPTZ NOT NULL,
+      PRIMARY KEY(authority_id, tenant_id, corpus_id, resource_kind, target_selector)
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_mementos_project_registration_binding_target
+      ON mementos_project_registration_bindings(
+        authority_id, tenant_id, corpus_id, resource_kind, target_id
+      )
+      WHERE target_id IS NOT NULL;
+
+    CREATE OR REPLACE FUNCTION mementos_project_registration_receipts_immutable()
+      RETURNS trigger
+      LANGUAGE plpgsql
+      AS $$
+      BEGIN
+        RAISE EXCEPTION 'mementos project registration receipts are immutable';
+      END;
+      $$;
+    DROP TRIGGER IF EXISTS mementos_project_registration_receipts_immutable
+      ON mementos_project_registration_receipts;
+    CREATE TRIGGER mementos_project_registration_receipts_immutable
+      BEFORE UPDATE OR DELETE ON mementos_project_registration_receipts
+      FOR EACH ROW EXECUTE FUNCTION mementos_project_registration_receipts_immutable();
+  `;
+}
+function sqliteMementosProjectGuardedUpdateSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_project_update_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL CHECK(route = 'mementos.project-guarded-update.v1'),
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'rollback')),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome = 'accepted'),
+      target_id TEXT NOT NULL,
+      expected_revision TEXT NOT NULL,
+      result_revision TEXT NOT NULL,
+      result_digest TEXT NOT NULL,
+      accepted_receipt_id TEXT,
+      before_project_json TEXT NOT NULL,
+      after_project_json TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      UNIQUE(authority_id, tenant_id, corpus_id, direction, idempotency_key)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_project_update_receipts_target
+      ON mementos_project_update_receipts(
+        authority_id, tenant_id, corpus_id, target_id, created_at
+      );
+
+    CREATE TRIGGER IF NOT EXISTS mementos_project_update_receipts_immutable_update
+    BEFORE UPDATE ON mementos_project_update_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos project update receipts are immutable');
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS mementos_project_update_receipts_immutable_delete
+    BEFORE DELETE ON mementos_project_update_receipts
+    BEGIN
+      SELECT RAISE(ABORT, 'mementos project update receipts are immutable');
+    END;
+  `;
+}
+function postgresMementosProjectGuardedUpdateSchemaSql() {
+  return `
+    CREATE TABLE IF NOT EXISTS mementos_project_update_receipts (
+      receipt_id TEXT PRIMARY KEY,
+      authority TEXT NOT NULL CHECK(authority = 'mementos'),
+      route TEXT NOT NULL CHECK(route = 'mementos.project-guarded-update.v1'),
+      package_version TEXT NOT NULL,
+      authority_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL,
+      corpus_id TEXT NOT NULL,
+      operation_id TEXT NOT NULL,
+      step_id TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction IN ('forward', 'rollback')),
+      idempotency_key TEXT NOT NULL,
+      request_digest TEXT NOT NULL,
+      outcome TEXT NOT NULL CHECK(outcome = 'accepted'),
+      target_id TEXT NOT NULL,
+      expected_revision TEXT NOT NULL,
+      result_revision TEXT NOT NULL,
+      result_digest TEXT NOT NULL,
+      accepted_receipt_id TEXT,
+      before_project_json JSONB NOT NULL,
+      after_project_json JSONB NOT NULL,
+      created_at TIMESTAMPTZ NOT NULL,
+      UNIQUE(authority_id, tenant_id, corpus_id, direction, idempotency_key)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_mementos_project_update_receipts_target
+      ON mementos_project_update_receipts(
+        authority_id, tenant_id, corpus_id, target_id, created_at
+      );
+
+    CREATE OR REPLACE FUNCTION mementos_project_update_receipts_immutable()
+      RETURNS trigger
+      LANGUAGE plpgsql
+      AS $$
+      BEGIN
+        RAISE EXCEPTION 'mementos project update receipts are immutable';
+      END;
+      $$;
+    DROP TRIGGER IF EXISTS mementos_project_update_receipts_immutable
+      ON mementos_project_update_receipts;
+    CREATE TRIGGER mementos_project_update_receipts_immutable
+      BEFORE UPDATE OR DELETE ON mementos_project_update_receipts
+      FOR EACH ROW EXECUTE FUNCTION mementos_project_update_receipts_immutable();
+  `;
+}
+
+// src/project-registration/authority.ts
+import { createHash } from "crypto";
+import { resolve } from "path";
+
+// src/lib/package-version.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function getMementosPackageVersion() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  for (const candidate of [
+    join(here, "..", "..", "package.json"),
+    join(here, "..", "package.json")
+  ]) {
+    try {
+      const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+      if (typeof parsed.version === "string" && parsed.version.trim())
+        return parsed.version;
+    } catch {}
+  }
+  return "0.0.0";
+}
+
+// src/project-registration/project-references.ts
+var MEMENTOS_PROJECT_REFERENCE_SURFACES = [
+  { key: "memories", table: "memories", column: "project_id" },
+  { key: "sessions", table: "sessions", column: "project_id" },
+  { key: "entities", table: "entities", column: "project_id" },
+  { key: "agents", table: "agents", column: "active_project_id" },
+  { key: "tool_events", table: "tool_events", column: "project_id" },
+  { key: "tasks", table: "tasks", column: "project_id" },
+  {
+    key: "memory_consolidation_runs",
+    table: "memory_consolidation_runs",
+    column: "project_id"
+  },
+  {
+    key: "memory_reflection_runs",
+    table: "memory_reflection_runs",
+    column: "project_id"
+  },
+  { key: "memory_acl", table: "memory_acl", column: "project_id" },
+  { key: "search_history", table: "search_history", column: "project_id" },
+  {
+    key: "session_memory_jobs",
+    table: "session_memory_jobs",
+    column: "project_id"
+  },
+  { key: "synthesis_events", table: "synthesis_events", column: "project_id" },
+  { key: "synthesis_runs", table: "synthesis_runs", column: "project_id" },
+  { key: "webhook_hooks", table: "webhook_hooks", column: "project_id" }
+];
+function quotedIdentifier(value) {
+  if (!/^[a-z_][a-z0-9_]*$/.test(value)) {
+    throw new Error(`unsafe project-reference identifier: ${value}`);
+  }
+  return `"${value}"`;
+}
+function mementosProjectReferenceCounts(db, projectId) {
+  const projections = MEMENTOS_PROJECT_REFERENCE_SURFACES.map(({ key, table, column }) => `(SELECT COUNT(*) FROM ${quotedIdentifier(table)} ` + `WHERE ${quotedIdentifier(column)} = ?) AS ${quotedIdentifier(key)}`).join(`,
+`);
+  const row = db.get(`SELECT
+${projections}`, ...MEMENTOS_PROJECT_REFERENCE_SURFACES.map(() => projectId));
+  return Object.fromEntries(MEMENTOS_PROJECT_REFERENCE_SURFACES.map(({ key }) => [key, Number(row[key] ?? 0)]));
+}
+function hasMementosProjectReferences(counts) {
+  return MEMENTOS_PROJECT_REFERENCE_SURFACES.some(({ key }) => counts[key] > 0);
+}
+function deleteMementosProjectIfUnreferenced(db, projectId) {
+  const guards = MEMENTOS_PROJECT_REFERENCE_SURFACES.map(({ table, column }) => `NOT EXISTS (SELECT 1 FROM ${quotedIdentifier(table)} ` + `WHERE ${quotedIdentifier(column)} = ?)`).join(`
+      AND `);
+  const result = db.run(`DELETE FROM projects
+     WHERE id = ?
+       AND ${guards}`, projectId, ...MEMENTOS_PROJECT_REFERENCE_SURFACES.map(() => projectId));
+  return result.changes;
+}
+
+// src/project-registration/types.ts
+var MEMENTOS_PROJECT_REGISTRATION_ROUTE = "mementos.project-registration.v1";
+var MEMENTOS_PROJECT_REGISTRATION_CALLER_ROUTE = "projects.full-registration.v1";
+var MEMENTOS_PROJECT_REGISTRATION_SCHEMA_VERSION = 1;
+var MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE = "mementos.project-guarded-update.v1";
+
+class MementosProjectRegistrationError extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "MementosProjectRegistrationError";
+  }
+}
+
+// src/project-registration/authority.ts
+var WORKSPACE_ID_PATTERN = /^wks_[A-Za-z0-9][A-Za-z0-9_-]{11,}$/;
+var OPERATION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/;
+var STEP_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{2,127}$/;
+var SHA256_PATTERN = /^[0-9a-f]{64}$/;
+var IDEMPOTENCY_PATTERN = /^prk_[0-9a-f]{48}$/;
+var PROJECT_ID_PATTERN = /^mm_project_[0-9a-f]{40}$/;
+
+class WriteBoundaryError extends Error {
+  point;
+  cause;
+  constructor(point, cause) {
+    super(`Mementos project registration failed at ${point}`);
+    this.point = point;
+    this.cause = cause;
+  }
+}
+function canonicalMementosProjectRegistrationJson(value) {
+  return JSON.stringify(canonicalize(value));
+}
+function canonicalize(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize);
+  if (!value || typeof value !== "object")
+    return value;
+  const out = {};
+  for (const key of Object.keys(value).sort()) {
+    const item = value[key];
+    if (item !== undefined)
+      out[key] = canonicalize(item);
+  }
+  return out;
+}
+function digestMementosProjectRegistrationValue(value) {
+  return createHash("sha256").update(canonicalMementosProjectRegistrationJson(value)).digest("hex");
+}
+function digestOwnedPath(path) {
+  return createHash("sha256").update(path).digest("hex");
+}
+function deriveMementosProjectRegistrationIdempotencyKey(input) {
+  return `prk_${digestMementosProjectRegistrationValue({
+    route: MEMENTOS_PROJECT_REGISTRATION_CALLER_ROUTE,
+    operation_id: input.operation_id,
+    step_id: input.step_id,
+    direction: input.direction,
+    target_selector: input.target_selector,
+    request_digest: input.request_digest,
+    precondition_digest: input.precondition_digest
+  }).slice(0, 48)}`;
+}
+function responseBytes(value) {
+  return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+function assertBounds(bounds) {
+  if (!Number.isSafeInteger(bounds.response_byte_limit) || bounds.response_byte_limit <= 0) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_BOUNDS", "response_byte_limit must be a positive integer");
+  }
+  if (!Number.isSafeInteger(bounds.time_budget_ms) || bounds.time_budget_ms <= 0) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_BOUNDS", "time_budget_ms must be a positive integer");
+  }
+}
+function assertWithinBounds(value, bounds, startedAt) {
+  const bytes = responseBytes(value);
+  if (bytes > bounds.response_byte_limit) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_RESPONSE_TOO_LARGE", `registration response requires ${bytes} bytes but the bound is ${bounds.response_byte_limit}`, { response_bytes: bytes, response_byte_limit: bounds.response_byte_limit });
+  }
+  const elapsed = Date.now() - startedAt;
+  if (elapsed > bounds.time_budget_ms) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_TIME_BUDGET_EXCEEDED", `registration call took ${elapsed}ms but the bound is ${bounds.time_budget_ms}ms`, { elapsed_ms: elapsed, time_budget_ms: bounds.time_budget_ms });
+  }
+  return { response_bytes: bytes, elapsed_ms: elapsed };
+}
+function withResponseControl(receipt, bounds, startedAt) {
+  const result = {
+    receipt,
+    response_control: {
+      response_byte_limit: bounds.response_byte_limit,
+      time_budget_ms: bounds.time_budget_ms,
+      response_bytes: 0,
+      elapsed_ms: 0,
+      complete: true,
+      truncated: false
+    }
+  };
+  for (let attempt = 0;attempt < 8; attempt += 1) {
+    const measured2 = assertWithinBounds(result, bounds, startedAt);
+    const stable = result.response_control.response_bytes === measured2.response_bytes && result.response_control.elapsed_ms === measured2.elapsed_ms;
+    result.response_control.response_bytes = measured2.response_bytes;
+    result.response_control.elapsed_ms = measured2.elapsed_ms;
+    if (stable)
+      break;
+  }
+  const measured = assertWithinBounds(result, bounds, startedAt);
+  result.response_control.response_bytes = measured.response_bytes;
+  result.response_control.elapsed_ms = measured.elapsed_ms;
+  return result;
+}
+function requireString(value, field, options = {}) {
+  const min = options.min ?? 1;
+  const max = options.max ?? 512;
+  if (typeof value !== "string" || value.length < min || value.length > max || /[\u0000-\u001f]/.test(value) || options.pattern && !options.pattern.test(value)) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", `${field} is not a valid bounded registration identifier`);
+  }
+  return value;
+}
+function exactKeys(value, expected, field) {
+  const actual = Object.keys(value).sort();
+  const wanted = [...expected].sort();
+  if (actual.length !== wanted.length || actual.some((key, i) => key !== wanted[i])) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", `${field} must contain exactly: ${wanted.join(", ")}`);
+  }
+}
+function ownedPath(target) {
+  if (!target || typeof target.withOwnedPath !== "function") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "target must be a package-owned path handle");
+  }
+  const path = target.withOwnedPath((value) => value);
+  requireString(path, "target path", { max: 4096 });
+  if (path !== resolve(path)) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "target path must already be canonical and absolute");
+  }
+  return path;
+}
+function normalizedCallDigest(request) {
+  return digestMementosProjectRegistrationValue({
+    authority_route: request.authority_route,
+    package_version: request.package_version,
+    authority_id: request.authority_id,
+    tenant_id: request.tenant_id,
+    corpus_id: request.corpus_id,
+    operation_id: request.operation_id,
+    step_id: request.step_id,
+    resource_kind: request.resource_kind,
+    direction: request.direction,
+    target_selector: request.target_selector,
+    idempotency_key: request.idempotency_key,
+    request_digest: request.request_digest,
+    precondition_digest: request.precondition_digest,
+    project_id: request.project_id,
+    project_slug: request.project_slug,
+    project_name: request.project_name,
+    desired: request.desired,
+    accepted_receipt_id: request.accepted_receipt?.receipt_id ?? null
+  });
+}
+function publicReceipt(row) {
+  const { target_selector: _selector, normalized_call_digest: _digest, ...receipt } = row;
+  return receipt;
+}
+function timestampString(value) {
+  return value instanceof Date ? value.toISOString() : String(value);
+}
+function receiptFromRow(row) {
+  return {
+    ...row,
+    authority: "mementos",
+    resource_kind: "project",
+    created_by_operation: row["created_by_operation"] === true || Number(row["created_by_operation"]) === 1,
+    created_at: timestampString(row["created_at"])
+  };
+}
+function bindingFromRow(row) {
+  return {
+    ...row,
+    created_at: timestampString(row["created_at"]),
+    updated_at: timestampString(row["updated_at"])
+  };
+}
+function getStoredReceipt(db, receiptId) {
+  const row = db.get("SELECT * FROM mementos_project_registration_receipts WHERE receipt_id = ? LIMIT 1", receiptId);
+  return row ? receiptFromRow(row) : null;
+}
+function getAcceptedReceipt(db, request) {
+  const row = db.get(`
+    SELECT * FROM mementos_project_registration_receipts
+    WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+      AND operation_id = ? AND step_id = ? AND resource_kind = 'project'
+      AND direction = ? AND outcome = 'accepted'
+    ORDER BY created_at ASC, receipt_id ASC
+    LIMIT 1
+  `, request.authority_id, request.tenant_id, request.corpus_id, request.operation_id, request.step_id, request.direction);
+  return row ? receiptFromRow(row) : null;
+}
+function getReceiptForLookup(db, request) {
+  const row = db.get(`
+    SELECT * FROM mementos_project_registration_receipts
+    WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+      AND operation_id = ? AND step_id = ? AND resource_kind = 'project'
+      AND direction = ? AND idempotency_key = ? AND target_selector = ?
+    ORDER BY CASE outcome
+      WHEN 'terminal_nonacceptance' THEN 0
+      WHEN 'duplicate_of_accepted' THEN 1
+      ELSE 2
+    END, created_at DESC, receipt_id DESC
+    LIMIT 1
+  `, request.authority_id, request.tenant_id, request.corpus_id, request.operation_id, request.step_id, request.direction, request.idempotency_key, request.target_selector);
+  return row ? receiptFromRow(row) : null;
+}
+function getBinding(db, capability, targetSelector) {
+  const row = db.get(`
+    SELECT * FROM mementos_project_registration_bindings
+    WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+      AND resource_kind = 'project' AND target_selector = ?
+    LIMIT 1
+  `, capability.authority_id, capability.tenant_id, capability.corpus_id, targetSelector);
+  return row ? bindingFromRow(row) : null;
+}
+function getProjectByExactId(db, id) {
+  const row = db.get("SELECT * FROM projects WHERE id = ? LIMIT 1", id);
+  if (!row)
+    return null;
+  return {
+    id: String(row["id"]),
+    name: String(row["name"]),
+    path: String(row["path"]),
+    description: row["description"] === null ? null : String(row["description"]),
+    memory_prefix: row["memory_prefix"] === null ? null : String(row["memory_prefix"]),
+    created_at: timestampString(row["created_at"]),
+    updated_at: timestampString(row["updated_at"])
+  };
+}
+function getProjectByPath(db, path) {
+  const row = db.get("SELECT * FROM projects WHERE path = ? LIMIT 1", path);
+  return row ? getProjectByExactId(db, String(row["id"])) : null;
+}
+function projectRecord(db, project, references = mementosProjectReferenceCounts(db, project.id)) {
+  return {
+    target_id: project.id,
+    revision: project.updated_at,
+    digest: digestMementosProjectRegistrationValue({
+      id: project.id,
+      name: project.name,
+      path: project.path,
+      description: project.description,
+      memory_prefix: project.memory_prefix,
+      created_at: project.created_at,
+      updated_at: project.updated_at,
+      references
+    })
+  };
+}
+function targetId(capability, selector) {
+  return `mm_project_${digestMementosProjectRegistrationValue({
+    authority_id: capability.authority_id,
+    tenant_id: capability.tenant_id,
+    corpus_id: capability.corpus_id,
+    selector
+  }).slice(0, 40)}`;
+}
+function receiptId(input) {
+  return `mmpr_${digestMementosProjectRegistrationValue(input).slice(0, 40)}`;
+}
+function makeReceipt(request, capability, callDigest, now, values) {
+  const withoutId = {
+    authority: "mementos",
+    route: MEMENTOS_PROJECT_REGISTRATION_ROUTE,
+    package_version: capability.package_version,
+    authority_id: capability.authority_id,
+    tenant_id: capability.tenant_id,
+    corpus_id: capability.corpus_id,
+    operation_id: request.operation_id,
+    step_id: request.step_id,
+    resource_kind: "project",
+    direction: request.direction,
+    target_selector: values.target_selector ?? request.target_selector,
+    idempotency_key: request.idempotency_key,
+    request_digest: request.request_digest,
+    precondition_digest: request.precondition_digest,
+    normalized_call_digest: callDigest,
+    outcome: values.outcome,
+    reason: values.reason ?? null,
+    target_id: values.target_id ?? null,
+    result_revision: values.result_revision ?? null,
+    result_digest: values.result_digest ?? null,
+    duplicate_of_receipt_id: values.duplicate_of_receipt_id ?? null,
+    accepted_receipt_id: values.accepted_receipt_id ?? null,
+    created_by_operation: values.created_by_operation ?? false
+  };
+  return {
+    receipt_id: receiptId(withoutId),
+    ...withoutId,
+    created_at: now
+  };
+}
+function insertReceipt(db, receipt) {
+  db.run(`
+    INSERT INTO mementos_project_registration_receipts (
+      receipt_id, authority, route, package_version, authority_id, tenant_id,
+      corpus_id, operation_id, step_id, resource_kind, direction,
+      target_selector, idempotency_key, request_digest, precondition_digest,
+      normalized_call_digest, outcome, reason, target_id, result_revision,
+      result_digest, duplicate_of_receipt_id, accepted_receipt_id,
+      created_by_operation, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT DO NOTHING
+  `, receipt.receipt_id, receipt.authority, receipt.route, receipt.package_version, receipt.authority_id, receipt.tenant_id, receipt.corpus_id, receipt.operation_id, receipt.step_id, receipt.resource_kind, receipt.direction, receipt.target_selector, receipt.idempotency_key, receipt.request_digest, receipt.precondition_digest, receipt.normalized_call_digest, receipt.outcome, receipt.reason, receipt.target_id, receipt.result_revision, receipt.result_digest, receipt.duplicate_of_receipt_id, receipt.accepted_receipt_id, receipt.created_by_operation, receipt.created_at);
+  const stored = getStoredReceipt(db, receipt.receipt_id);
+  const withoutCreatedAt = (value) => {
+    const { created_at: _createdAt, ...logical } = value;
+    return logical;
+  };
+  if (!stored || canonicalMementosProjectRegistrationJson(withoutCreatedAt(stored)) !== canonicalMementosProjectRegistrationJson(withoutCreatedAt(receipt))) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "immutable receipt id resolved to different content");
+  }
+  return stored;
+}
+function insertBinding(db, request, callDigest, now) {
+  const result = db.run(`
+    INSERT INTO mementos_project_registration_bindings (
+      authority_id, tenant_id, corpus_id, resource_kind, target_selector,
+      operation_id, step_id, direction, idempotency_key, request_digest,
+      precondition_digest, normalized_call_digest, state, target_id,
+      accepted_receipt_id, result_revision, result_digest, removed_receipt_id,
+      created_at, updated_at
+    ) VALUES (?, ?, ?, 'project', ?, ?, ?, 'forward', ?, ?, ?, ?, 'pending',
+      NULL, NULL, NULL, NULL, NULL, ?, ?)
+    ON CONFLICT DO NOTHING
+  `, request.authority_id, request.tenant_id, request.corpus_id, request.target_selector, request.operation_id, request.step_id, request.idempotency_key, request.request_digest, request.precondition_digest, callDigest, now, now);
+  return result.changes === 1;
+}
+function lockBinding(db, capability, targetSelector) {
+  const result = db.run(`
+    UPDATE mementos_project_registration_bindings
+    SET updated_at = updated_at
+    WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+      AND resource_kind = 'project' AND target_selector = ?
+  `, capability.authority_id, capability.tenant_id, capability.corpus_id, targetSelector);
+  return result.changes === 1;
+}
+function setBindingAccepted(db, request, receipt, now) {
+  const result = db.run(`
+    UPDATE mementos_project_registration_bindings
+    SET state = 'accepted', target_id = ?, accepted_receipt_id = ?,
+      result_revision = ?, result_digest = ?, updated_at = ?
+    WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+      AND resource_kind = 'project' AND target_selector = ? AND state = 'pending'
+  `, receipt.target_id, receipt.receipt_id, receipt.result_revision, receipt.result_digest, now, request.authority_id, request.tenant_id, request.corpus_id, request.target_selector);
+  if (result.changes !== 1) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "registration binding was not pending at acceptance");
+  }
+}
+function setBindingRemoved(db, accepted, inverseReceiptId, now) {
+  const result = db.run(`
+    UPDATE mementos_project_registration_bindings
+    SET state = 'removed', removed_receipt_id = ?, updated_at = ?
+    WHERE authority_id = ? AND tenant_id = ? AND corpus_id = ?
+      AND resource_kind = 'project' AND target_selector = ?
+      AND state = 'accepted' AND accepted_receipt_id = ?
+  `, inverseReceiptId, now, accepted.authority_id, accepted.tenant_id, accepted.corpus_id, accepted.target_selector, accepted.receipt_id);
+  if (result.changes !== 1) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "registration binding was not accepted at inverse");
+  }
+}
+function capabilityMatches(request, capability) {
+  return request.authority_route === capability.route && request.package_version === capability.package_version && request.authority_id === capability.authority_id && request.tenant_id === capability.tenant_id && request.corpus_id === capability.corpus_id;
+}
+function assertCommonRequest(request, capability) {
+  assertBounds(request);
+  if (request.resource_kind !== "project") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "resource_kind must be project");
+  }
+  if (request.direction !== "forward" && request.direction !== "inverse") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "direction must be forward or inverse");
+  }
+  if (!capabilityMatches(request, capability)) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CAPABILITY_MISMATCH", "registration request does not match this authority capability identity");
+  }
+  requireString(request.operation_id, "operation_id", {
+    min: 8,
+    max: 128,
+    pattern: OPERATION_PATTERN
+  });
+  requireString(request.step_id, "step_id", { min: 3, max: 128, pattern: STEP_PATTERN });
+  requireString(request.target_selector, "target_selector", { max: 512 });
+  requireString(request.project_id, "project_id", {
+    min: 16,
+    max: 128,
+    pattern: WORKSPACE_ID_PATTERN
+  });
+  requireString(request.project_name, "project_name", { max: 256 });
+  requireString(request.project_slug, "project_slug", { max: 128 });
+  requireString(request.request_digest, "request_digest", {
+    min: 64,
+    max: 64,
+    pattern: SHA256_PATTERN
+  });
+  requireString(request.precondition_digest, "precondition_digest", {
+    min: 64,
+    max: 64,
+    pattern: SHA256_PATTERN
+  });
+  requireString(request.idempotency_key, "idempotency_key", {
+    min: 52,
+    max: 52,
+    pattern: IDEMPOTENCY_PATTERN
+  });
+  if (!request.desired || typeof request.desired !== "object" || Array.isArray(request.desired)) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "desired must be a JSON object");
+  }
+  if (digestMementosProjectRegistrationValue(request.desired) !== request.request_digest) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_DIGEST_MISMATCH", "request_digest does not match the canonical desired payload");
+  }
+  const expectedKey = deriveMementosProjectRegistrationIdempotencyKey(request);
+  if (request.idempotency_key !== expectedKey) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_IDEMPOTENCY_MISMATCH", "idempotency_key does not match the deterministic request", { expected: expectedKey });
+  }
+}
+function assertForwardRequest(request, capability) {
+  assertCommonRequest(request, capability);
+  if (request.direction !== "forward" || request.accepted_receipt !== undefined) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "conditional create requires a forward request without an accepted receipt");
+  }
+  exactKeys(request.desired, [
+    "name",
+    "source_project_id",
+    "source_project_slug",
+    "target_path_digest"
+  ], "forward desired");
+  if (request.target_selector !== request.project_id || request.desired["source_project_id"] !== request.project_id || request.desired["source_project_slug"] !== request.project_slug || request.desired["name"] !== request.project_name) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "forward project identity fields disagree");
+  }
+  const expectedPrecondition = digestMementosProjectRegistrationValue({
+    target_selector: request.target_selector,
+    expected: "absent"
+  });
+  if (request.precondition_digest !== expectedPrecondition) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_DIGEST_MISMATCH", "forward precondition must bind expected absence");
+  }
+  const path = ownedPath(request.target);
+  if (request.desired["target_path_digest"] !== digestOwnedPath(path)) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_DIGEST_MISMATCH", "target path does not match the package-owned digest");
+  }
+  return path;
+}
+function sameReceipt(left, right) {
+  return canonicalMementosProjectRegistrationJson(publicReceipt(left)) === canonicalMementosProjectRegistrationJson(right);
+}
+function assertInverseRequest(request, capability) {
+  assertCommonRequest(request, capability);
+  if (request.direction !== "inverse" || !request.accepted_receipt) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "conditional inverse requires the accepted forward receipt");
+  }
+  const accepted = request.accepted_receipt;
+  if (accepted.authority !== "mementos" || accepted.route !== capability.route || accepted.package_version !== capability.package_version || accepted.authority_id !== capability.authority_id || accepted.tenant_id !== capability.tenant_id || accepted.corpus_id !== capability.corpus_id || accepted.operation_id !== request.operation_id || accepted.step_id !== request.step_id || accepted.resource_kind !== "project" || accepted.direction !== "forward" || accepted.outcome !== "accepted" || !accepted.created_by_operation || !accepted.target_id || !accepted.result_revision || !accepted.result_digest || request.target_selector !== accepted.target_id) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "accepted receipt is not an exact attempt-created forward receipt");
+  }
+  exactKeys(request.desired, ["accepted_receipt_id", "target_id"], "inverse desired");
+  if (request.desired["accepted_receipt_id"] !== accepted.receipt_id || request.desired["target_id"] !== accepted.target_id) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_DIGEST_MISMATCH", "inverse desired payload does not bind the accepted receipt");
+  }
+  const expectedPrecondition = digestMementosProjectRegistrationValue({
+    expected_revision: accepted.result_revision,
+    expected_digest: accepted.result_digest
+  });
+  if (request.precondition_digest !== expectedPrecondition) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_DIGEST_MISMATCH", "inverse precondition does not bind the accepted object state");
+  }
+  return accepted;
+}
+function assertLookup(request, capability) {
+  assertBounds(request);
+  if (request.max_items !== 1) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_BOUNDS", "terminal receipt lookup requires max_items exactly 1");
+  }
+  if (request.authority !== "mementos" || request.resource_kind !== "project" || request.authority_route !== capability.route || request.package_version !== capability.package_version || request.authority_id !== capability.authority_id || request.tenant_id !== capability.tenant_id || request.corpus_id !== capability.corpus_id) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CAPABILITY_MISMATCH", "receipt lookup does not match this authority capability identity");
+  }
+  requireString(request.operation_id, "operation_id", { pattern: OPERATION_PATTERN });
+  requireString(request.step_id, "step_id", { pattern: STEP_PATTERN });
+  requireString(request.target_selector, "target_selector");
+  requireString(request.idempotency_key, "idempotency_key", {
+    min: 52,
+    max: 52,
+    pattern: IDEMPOTENCY_PATTERN
+  });
+  if (request.target_id !== undefined) {
+    requireString(request.target_id, "target_id", {
+      min: 51,
+      max: 51,
+      pattern: PROJECT_ID_PATTERN
+    });
+  }
+}
+
+class PackageOwnedMementosProjectRegistrationAuthority {
+  db;
+  authority = "mementos";
+  capabilityValue;
+  now;
+  faultInjector;
+  constructor(db, options = {}) {
+    this.db = db;
+    this.now = options.now ?? (() => new Date().toISOString());
+    this.faultInjector = options.faultInjector;
+    this.capabilityValue = {
+      authority: "mementos",
+      route: MEMENTOS_PROJECT_REGISTRATION_ROUTE,
+      package_version: options.packageVersion ?? getMementosPackageVersion(),
+      authority_id: options.authorityId ?? "mementos",
+      tenant_id: options.tenantId ?? "default",
+      corpus_id: options.corpusId ?? "default",
+      supported_resources: ["project"],
+      conditional_create: true,
+      immutable_receipts: true,
+      exact_terminal_lookup: true,
+      exact_readback: true,
+      conditional_inverse: true,
+      ambiguous_outcome_reconciliation: true,
+      guarded_update: true,
+      no_write_dry_run: true,
+      expected_revision_compare_and_swap: true,
+      caller_idempotency: true,
+      exact_inverse_rollback: true
+    };
+  }
+  fault(point, request) {
+    this.faultInjector?.(point, {
+      operation_id: request.operation_id,
+      step_id: request.step_id,
+      resource_kind: "project",
+      direction: request.direction
+    });
+  }
+  writeBoundary(point, request) {
+    try {
+      this.fault(point, request);
+    } catch (cause) {
+      throw new WriteBoundaryError(point, cause);
+    }
+  }
+  terminal(request, callDigest, reason, values = {}) {
+    return insertReceipt(this.db, makeReceipt(request, this.capabilityValue, callDigest, this.now(), {
+      outcome: "terminal_nonacceptance",
+      reason,
+      target_id: values.target_id,
+      accepted_receipt_id: values.accepted_receipt_id,
+      target_selector: values.target_selector
+    }));
+  }
+  duplicateForwardOrTerminal(request, callDigest, path, accepted) {
+    if (accepted.normalized_call_digest !== callDigest) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_IDEMPOTENCY_MISMATCH", "accepted operation/step identity is bound to a different request");
+    }
+    const project = accepted.target_id ? getProjectByExactId(this.db, accepted.target_id) : null;
+    if (!project || project.path !== path) {
+      return this.terminal(request, callDigest, "accepted_target_missing_or_replaced", {
+        target_id: accepted.target_id
+      });
+    }
+    const record = projectRecord(this.db, project);
+    if (record.revision !== accepted.result_revision || record.digest !== accepted.result_digest) {
+      return this.terminal(request, callDigest, "accepted_target_drifted", {
+        target_id: accepted.target_id
+      });
+    }
+    return insertReceipt(this.db, makeReceipt(request, this.capabilityValue, callDigest, this.now(), {
+      outcome: "duplicate_of_accepted",
+      target_id: accepted.target_id,
+      result_revision: accepted.result_revision,
+      result_digest: accepted.result_digest,
+      duplicate_of_receipt_id: accepted.receipt_id,
+      created_by_operation: false
+    }));
+  }
+  async capability() {
+    return {
+      ...this.capabilityValue,
+      supported_resources: ["project"]
+    };
+  }
+  async create(request) {
+    const startedAt = Date.now();
+    const path = assertForwardRequest(request, this.capabilityValue);
+    const callDigest = normalizedCallDigest(request);
+    let stored;
+    try {
+      stored = this.db.transaction(() => {
+        const exact = getReceiptForLookup(this.db, {
+          ...request,
+          authority: "mementos",
+          max_items: 1
+        });
+        if (exact?.outcome === "terminal_nonacceptance")
+          return exact;
+        const accepted = getAcceptedReceipt(this.db, request);
+        if (accepted) {
+          return this.duplicateForwardOrTerminal(request, callDigest, path, accepted);
+        }
+        const existing = getProjectByPath(this.db, path) ?? getProjectByExactId(this.db, targetId(this.capabilityValue, request.target_selector));
+        if (existing) {
+          return this.terminal(request, callDigest, "target_preexists", {
+            target_id: existing.id
+          });
+        }
+        const now = this.now();
+        const insertedBinding = insertBinding(this.db, request, callDigest, now);
+        if (!lockBinding(this.db, this.capabilityValue, request.target_selector)) {
+          throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "registration binding disappeared before it could be locked");
+        }
+        const ownedBinding = getBinding(this.db, this.capabilityValue, request.target_selector);
+        if (!ownedBinding || ownedBinding.normalized_call_digest !== callDigest) {
+          return this.terminal(request, callDigest, "target_selector_preexists", {
+            target_id: ownedBinding?.target_id
+          });
+        }
+        const acceptedAfterBinding = getAcceptedReceipt(this.db, request);
+        if (acceptedAfterBinding) {
+          return this.duplicateForwardOrTerminal(request, callDigest, path, acceptedAfterBinding);
+        }
+        if (!insertedBinding || ownedBinding.state !== "pending") {
+          return this.terminal(request, callDigest, "target_selector_preexists", {
+            target_id: ownedBinding.target_id
+          });
+        }
+        const id = targetId(this.capabilityValue, request.target_selector);
+        this.writeBoundary("before_object_write", request);
+        try {
+          this.db.run(`
+            INSERT INTO projects (
+              id, name, path, description, memory_prefix, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+          `, id, request.project_name, path, null, request.project_slug, now, now);
+        } catch (cause) {
+          throw new WriteBoundaryError("before_object_write", cause);
+        }
+        this.writeBoundary("after_object_write", request);
+        const project = getProjectByExactId(this.db, id);
+        if (!project || project.path !== path) {
+          throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "project write did not read back by its full id");
+        }
+        const record = projectRecord(this.db, project);
+        const acceptedReceipt = makeReceipt(request, this.capabilityValue, callDigest, now, {
+          outcome: "accepted",
+          target_id: record.target_id,
+          result_revision: record.revision,
+          result_digest: record.digest,
+          created_by_operation: true
+        });
+        this.writeBoundary("before_receipt_write", request);
+        let inserted;
+        try {
+          inserted = insertReceipt(this.db, acceptedReceipt);
+        } catch (cause) {
+          throw new WriteBoundaryError("before_receipt_write", cause);
+        }
+        this.writeBoundary("after_receipt_write", request);
+        setBindingAccepted(this.db, request, inserted, now);
+        return inserted;
+      });
+    } catch (error) {
+      if (!(error instanceof WriteBoundaryError))
+        throw error;
+      stored = this.db.transaction(() => this.terminal(request, callDigest, `write_failed:${error.point}`));
+    }
+    this.fault("after_commit", request);
+    const receipt = publicReceipt(stored);
+    assertWithinBounds(receipt, request, startedAt);
+    return receipt;
+  }
+  async readExact(request) {
+    const startedAt = Date.now();
+    assertBounds(request);
+    if (request.resource_kind !== "project") {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "resource_kind must be project");
+    }
+    requireString(request.target_id, "target_id", {
+      min: 51,
+      max: 51,
+      pattern: PROJECT_ID_PATTERN
+    });
+    const path = ownedPath(request.target);
+    const project = getProjectByExactId(this.db, request.target_id);
+    if (!project || project.path !== path) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_RECORD_NOT_FOUND", "exact full-id project readback did not resolve the owned path");
+    }
+    const record = projectRecord(this.db, project);
+    assertWithinBounds(record, request, startedAt);
+    return record;
+  }
+  async lookupReceipt(request) {
+    const startedAt = Date.now();
+    assertLookup(request, this.capabilityValue);
+    const receipt = getReceiptForLookup(this.db, request);
+    if (!receipt || request.target_id !== undefined && receipt.target_id !== request.target_id) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND", "exact immutable terminal receipt was not found");
+    }
+    return withResponseControl(publicReceipt(receipt), request, startedAt);
+  }
+  async compensate(request) {
+    const startedAt = Date.now();
+    const acceptedPublic = assertInverseRequest(request, this.capabilityValue);
+    const callDigest = normalizedCallDigest(request);
+    const storedAccepted = getStoredReceipt(this.db, acceptedPublic.receipt_id);
+    if (!storedAccepted || !sameReceipt(storedAccepted, acceptedPublic)) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_ACCEPTED_RECEIPT_NOT_FOUND", "accepted forward receipt is not stored immutably in this authority");
+    }
+    const path = ownedPath(request.target);
+    let stored;
+    try {
+      stored = this.db.transaction(() => {
+        const exact = getReceiptForLookup(this.db, {
+          ...request,
+          authority: "mementos",
+          max_items: 1
+        });
+        if (exact?.outcome === "terminal_nonacceptance")
+          return exact;
+        if (!lockBinding(this.db, this.capabilityValue, storedAccepted.target_selector)) {
+          return this.terminal(request, callDigest, "accepted_binding_missing", {
+            target_id: storedAccepted.target_id,
+            accepted_receipt_id: storedAccepted.receipt_id
+          });
+        }
+        const binding = getBinding(this.db, this.capabilityValue, storedAccepted.target_selector);
+        if (!binding || binding.accepted_receipt_id !== storedAccepted.receipt_id) {
+          return this.terminal(request, callDigest, "accepted_binding_replaced", {
+            target_id: storedAccepted.target_id,
+            accepted_receipt_id: storedAccepted.receipt_id
+          });
+        }
+        const prior = getAcceptedReceipt(this.db, request);
+        if (prior) {
+          if (prior.normalized_call_digest !== callDigest || prior.accepted_receipt_id !== storedAccepted.receipt_id) {
+            throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_IDEMPOTENCY_MISMATCH", "inverse operation/step identity is bound to a different request");
+          }
+          return insertReceipt(this.db, makeReceipt(request, this.capabilityValue, callDigest, this.now(), {
+            outcome: "duplicate_of_accepted",
+            target_id: prior.target_id,
+            result_revision: prior.result_revision,
+            result_digest: prior.result_digest,
+            duplicate_of_receipt_id: prior.receipt_id,
+            accepted_receipt_id: storedAccepted.receipt_id
+          }));
+        }
+        if (binding.state !== "accepted") {
+          return this.terminal(request, callDigest, "accepted_binding_not_active", {
+            target_id: storedAccepted.target_id,
+            accepted_receipt_id: storedAccepted.receipt_id
+          });
+        }
+        const project = getProjectByExactId(this.db, storedAccepted.target_id);
+        if (!project) {
+          return this.terminal(request, callDigest, "target_missing", {
+            target_id: storedAccepted.target_id,
+            accepted_receipt_id: storedAccepted.receipt_id
+          });
+        }
+        if (project.path !== path) {
+          return this.terminal(request, callDigest, "target_drifted", {
+            target_id: storedAccepted.target_id,
+            accepted_receipt_id: storedAccepted.receipt_id
+          });
+        }
+        const references = mementosProjectReferenceCounts(this.db, project.id);
+        if (hasMementosProjectReferences(references)) {
+          return this.terminal(request, callDigest, "target_has_dependents", {
+            target_id: storedAccepted.target_id,
+            accepted_receipt_id: storedAccepted.receipt_id
+          });
+        }
+        const current = projectRecord(this.db, project, references);
+        if (current.revision !== storedAccepted.result_revision || current.digest !== storedAccepted.result_digest) {
+          return this.terminal(request, callDigest, "target_drifted", {
+            target_id: storedAccepted.target_id,
+            accepted_receipt_id: storedAccepted.receipt_id
+          });
+        }
+        this.writeBoundary("before_object_write", request);
+        let deleted;
+        try {
+          deleted = deleteMementosProjectIfUnreferenced(this.db, storedAccepted.target_id);
+        } catch (cause) {
+          throw new WriteBoundaryError("before_object_write", cause);
+        }
+        if (deleted !== 1) {
+          const remaining = getProjectByExactId(this.db, storedAccepted.target_id);
+          if (remaining && hasMementosProjectReferences(mementosProjectReferenceCounts(this.db, storedAccepted.target_id))) {
+            return this.terminal(request, callDigest, "target_has_dependents", {
+              target_id: storedAccepted.target_id,
+              accepted_receipt_id: storedAccepted.receipt_id
+            });
+          }
+          throw new WriteBoundaryError("before_object_write", new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "conditional inverse did not delete exactly one unreferenced project"));
+        }
+        this.writeBoundary("after_object_write", request);
+        const inverseRecord = {
+          target_id: storedAccepted.target_id,
+          revision: "absent",
+          digest: digestMementosProjectRegistrationValue({
+            target_id: storedAccepted.target_id,
+            accepted_receipt_id: storedAccepted.receipt_id,
+            absent: true
+          })
+        };
+        const inverseReceipt = makeReceipt(request, this.capabilityValue, callDigest, this.now(), {
+          outcome: "accepted",
+          target_id: inverseRecord.target_id,
+          result_revision: inverseRecord.revision,
+          result_digest: inverseRecord.digest,
+          accepted_receipt_id: storedAccepted.receipt_id,
+          created_by_operation: false
+        });
+        this.writeBoundary("before_receipt_write", request);
+        let inserted;
+        try {
+          inserted = insertReceipt(this.db, inverseReceipt);
+        } catch (cause) {
+          throw new WriteBoundaryError("before_receipt_write", cause);
+        }
+        this.writeBoundary("after_receipt_write", request);
+        setBindingRemoved(this.db, storedAccepted, inserted.receipt_id, this.now());
+        return inserted;
+      });
+    } catch (error) {
+      if (!(error instanceof WriteBoundaryError))
+        throw error;
+      stored = this.db.transaction(() => this.terminal(request, callDigest, `write_failed:${error.point}`, {
+        target_id: storedAccepted.target_id,
+        accepted_receipt_id: storedAccepted.receipt_id
+      }));
+    }
+    this.fault("after_commit", request);
+    const receipt = publicReceipt(stored);
+    assertWithinBounds(receipt, request, startedAt);
+    return receipt;
+  }
+  async verifyInverse(request) {
+    const startedAt = Date.now();
+    const accepted = assertInverseRequest(request, this.capabilityValue);
+    const storedAccepted = getStoredReceipt(this.db, accepted.receipt_id);
+    if (!storedAccepted || !sameReceipt(storedAccepted, accepted)) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_ACCEPTED_RECEIPT_NOT_FOUND", "accepted forward receipt is not stored immutably in this authority");
+    }
+    const inverse = getAcceptedReceipt(this.db, request);
+    if (!inverse || inverse.outcome !== "accepted" || inverse.accepted_receipt_id !== accepted.receipt_id || inverse.result_revision !== "absent" || !inverse.result_digest) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND", "accepted conditional inverse receipt was not found");
+    }
+    if (getProjectByExactId(this.db, accepted.target_id)) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "inverse verification found the accepted target still present");
+    }
+    const verification = {
+      target_id: accepted.target_id,
+      accepted_receipt_id: accepted.receipt_id,
+      absent: true,
+      digest: digestMementosProjectRegistrationValue({
+        target_id: accepted.target_id,
+        accepted_receipt_id: accepted.receipt_id,
+        absent: true
+      })
+    };
+    assertWithinBounds(verification, request, startedAt);
+    if (verification.digest !== inverse.result_digest) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CONFLICT", "inverse verification digest does not match its immutable receipt");
+    }
+    return verification;
+  }
+}
+function createMementosProjectRegistrationAuthority(db, options = {}) {
+  return new PackageOwnedMementosProjectRegistrationAuthority(db, options);
+}
+var createLocalMementosProjectRegistrationAuthority = createMementosProjectRegistrationAuthority;
+// src/project-registration/http.ts
+var JSON_HEADERS = { "Content-Type": "application/json" };
+
+class WirePathHandle {
+  absolutePath;
+  constructor(absolutePath) {
+    this.absolutePath = absolutePath;
+  }
+  withOwnedPath(consumer) {
+    return consumer(this.absolutePath);
+  }
+}
+function json(body, status = 200) {
+  return new Response(JSON.stringify(body), { status, headers: JSON_HEADERS });
+}
+function errorStatus(error) {
+  switch (error.code) {
+    case "MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT":
+    case "MEMENTOS_PROJECT_REGISTRATION_INVALID_BOUNDS":
+    case "MEMENTOS_PROJECT_REGISTRATION_CAPABILITY_MISMATCH":
+    case "MEMENTOS_PROJECT_REGISTRATION_DIGEST_MISMATCH":
+    case "MEMENTOS_PROJECT_REGISTRATION_IDEMPOTENCY_MISMATCH":
+    case "MEMENTOS_PROJECT_REGISTRATION_EXACT_ID_REQUIRED":
+      return 400;
+    case "MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND":
+    case "MEMENTOS_PROJECT_REGISTRATION_RECORD_NOT_FOUND":
+    case "MEMENTOS_PROJECT_REGISTRATION_ACCEPTED_RECEIPT_NOT_FOUND":
+      return 404;
+    case "MEMENTOS_PROJECT_REGISTRATION_RESPONSE_TOO_LARGE":
+      return 413;
+    case "MEMENTOS_PROJECT_REGISTRATION_TIME_BUDGET_EXCEEDED":
+      return 408;
+    case "MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE":
+      return 503;
+    default:
+      return 409;
+  }
+}
+async function readJson(request) {
+  try {
+    const value = await request.json();
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function fromWireRequest(body) {
+  const { canonical_path: canonicalPath, ...request } = body;
+  if (typeof canonicalPath !== "string") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "canonical_path is required on the private registration transport");
+  }
+  return {
+    ...request,
+    target: new WirePathHandle(canonicalPath)
+  };
+}
+function fromWireReadRequest(body) {
+  const { canonical_path: canonicalPath, ...request } = body;
+  if (typeof canonicalPath !== "string") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "canonical_path is required on the private exact-read transport");
+  }
+  return {
+    ...request,
+    target: new WirePathHandle(canonicalPath)
+  };
+}
+async function handleMementosProjectRegistrationHttpRequest(request, url, authority, basePath = "/v1/project-registration") {
+  const path = url.pathname;
+  if (path !== basePath && !path.startsWith(`${basePath}/`))
+    return null;
+  const action = path.slice(basePath.length).split("/").filter(Boolean).join("/");
+  const method = request.method.toUpperCase();
+  try {
+    if ((action === "" || action === "capability") && method === "GET") {
+      return json({ capability: await authority.capability() });
+    }
+    if (method !== "POST")
+      return json({ error: "method not allowed" }, 405);
+    const body = await readJson(request);
+    if (!body) {
+      return json({
+        error: "invalid JSON body",
+        code: "MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT"
+      }, 400);
+    }
+    if (action === "create") {
+      return json({ receipt: await authority.create(fromWireRequest(body)) }, 201);
+    }
+    if (action === "receipts/lookup") {
+      return json(await authority.lookupReceipt(body));
+    }
+    if (action === "read-exact") {
+      return json({ record: await authority.readExact(fromWireReadRequest(body)) });
+    }
+    if (action === "compensate") {
+      return json({ receipt: await authority.compensate(fromWireRequest(body)) }, 201);
+    }
+    if (action === "verify-inverse") {
+      return json({ verification: await authority.verifyInverse(fromWireRequest(body)) });
+    }
+    return json({
+      error: "unknown Mementos project-registration route",
+      code: "MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND"
+    }, 404);
+  } catch (cause) {
+    if (cause instanceof MementosProjectRegistrationError) {
+      return json({
+        error: cause.message,
+        code: cause.code,
+        details: cause.details,
+        authoritative: true
+      }, errorStatus(cause));
+    }
+    return json({
+      error: cause instanceof Error ? cause.message : "internal registration error",
+      code: "MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE"
+    }, 500);
+  }
+}
+function extractPath(target) {
+  if (!target || typeof target.withOwnedPath !== "function") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "target must be a package-owned path handle");
+  }
+  return target.withOwnedPath((absolutePath) => absolutePath);
+}
+function toWireRequest(request) {
+  const { target, ...serializable } = request;
+  return {
+    ...serializable,
+    canonical_path: extractPath(target)
+  };
+}
+
+class MementosProjectRegistrationHttpClient {
+  authority = "mementos";
+  baseUrl;
+  fetchImpl;
+  headers;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.headers = {
+      ...options.headers,
+      ...options.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : {},
+      "Content-Type": "application/json"
+    };
+  }
+  async request(action, init = {}) {
+    const response = await this.fetchImpl(`${this.baseUrl}/v1/project-registration${action}`, {
+      ...init,
+      headers: { ...this.headers, ...init.headers ?? {} }
+    });
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE", `Mementos project registration HTTP ${response.status} returned non-JSON`);
+    }
+    if (!response.ok) {
+      throw new MementosProjectRegistrationError(typeof body["code"] === "string" ? body["code"] : "MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE", typeof body["error"] === "string" ? body["error"] : `Mementos project registration HTTP ${response.status}`, body["details"] && typeof body["details"] === "object" ? body["details"] : {});
+    }
+    return body;
+  }
+  async capability() {
+    const body = await this.request("/capability");
+    return body.capability;
+  }
+  async create(request) {
+    const body = await this.request("/create", { method: "POST", body: JSON.stringify(toWireRequest(request)) });
+    return body.receipt;
+  }
+  async readExact(request) {
+    const { target, ...serializable } = request;
+    const body = await this.request("/read-exact", {
+      method: "POST",
+      body: JSON.stringify({ ...serializable, canonical_path: extractPath(target) })
+    });
+    return body.record;
+  }
+  async lookupReceipt(request) {
+    return this.request("/receipts/lookup", { method: "POST", body: JSON.stringify(request) });
+  }
+  async compensate(request) {
+    const body = await this.request("/compensate", { method: "POST", body: JSON.stringify(toWireRequest(request)) });
+    return body.receipt;
+  }
+  async verifyInverse(request) {
+    const body = await this.request("/verify-inverse", {
+      method: "POST",
+      body: JSON.stringify(toWireRequest(request))
+    });
+    return body.verification;
+  }
+}
+function createMementosProjectRegistrationHttpClient(options) {
+  return new MementosProjectRegistrationHttpClient(options);
+}
+export {
+  sqliteMementosProjectRegistrationSchemaSql,
+  sqliteMementosProjectGuardedUpdateSchemaSql,
+  postgresMementosProjectRegistrationSchemaSql,
+  postgresMementosProjectGuardedUpdateSchemaSql,
+  mementosProjectReferenceCounts,
+  hasMementosProjectReferences,
+  handleMementosProjectRegistrationHttpRequest,
+  digestMementosProjectRegistrationValue,
+  deriveMementosProjectRegistrationIdempotencyKey,
+  createMementosProjectRegistrationHttpClient,
+  createMementosProjectRegistrationAuthority,
+  createLocalMementosProjectRegistrationAuthority,
+  canonicalMementosProjectRegistrationJson,
+  PackageOwnedMementosProjectRegistrationAuthority,
+  MementosProjectRegistrationHttpClient,
+  MementosProjectRegistrationError,
+  MEMENTOS_PROJECT_REGISTRATION_SCHEMA_VERSION,
+  MEMENTOS_PROJECT_REGISTRATION_ROUTE,
+  MEMENTOS_PROJECT_REGISTRATION_CALLER_ROUTE,
+  MEMENTOS_PROJECT_REFERENCE_SURFACES,
+  MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE
+};