@alneas/eaos-server 0.0.0-stage → 0.2.0

package/dist/chunk-INCHXAFK.js

@@ -0,0 +1,1395 @@
+import {
+  atomicSqlBindings,
+  inheritAtomicSqlSession
+} from "./chunk-3VITSHN3.js";
+
+// src/plugin-data/json-documents.ts
+import { assertBusinessId } from "@alneas/eaos-core/plugin-sdk";
+import { assertDataContractBinding, createJsonDocumentAssertion } from "@alneas/eaos-server/lifecycle-engine";
+
+// src/plugin-data/index.ts
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+import { assertPayloadWithinPolicy as assertPayloadWithinPolicy2, resolvePluginStoragePolicy as resolvePluginStoragePolicy2 } from "@alneas/eaos-core/plugin-sdk";
+
+// src/plugin-data/commands.ts
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+var RecordCommandService = class {
+  /**
+   * Compiles the declared operation schemas and binds real host persistence/admission capabilities.
+   * @param host - Live authorization and durable store or transaction; transaction takes precedence when provided.
+   * @param definition - Plugin schemas, write-operation allowlist, record-ID resolver, initial-state factory, reducer and invariant validator.
+   * @throws Throws for absent durable store/transaction or live authorization and for invalid strict Ajv schemas.
+   * 
+   * @example
+   * ```typescript
+   * import { RecordCommandService, type CommandState, type CommandHost } from '@alneas/eaos-server/plugin-data';
+   * export function connectAggregate<T extends CommandState>(host: CommandHost<T>, definition: ConstructorParameters<typeof RecordCommandService<T>>[1]) { return new RecordCommandService(host, definition); }
+   * ```
+   */
+  constructor(host, definition) {
+    this.host = host;
+    this.definition = definition;
+    if (!host?.store && typeof host?.transaction !== "function" || typeof host.authorize !== "function") throw new Error("Durable store and live authorization required");
+    const ajv2 = new Ajv({ strict: true, coerceTypes: false });
+    addFormats(ajv2);
+    this.validators = new Map(Object.entries(definition.schemas).map(([key, schema]) => [key, ajv2.compile(schema)]));
+  }
+  host;
+  definition;
+  validators;
+  /**
+   * Validates and admits one aggregate operation, running a reducer against a private current snapshot.
+   * @param principal - Host-authenticated current tenant/user context; structural validation alone proves no membership.
+   * @param operation - Declared schema key; membership in definition.writes selects persistence.
+   * @param input - Operation-schema input; writes require a safe integer revision matching the current snapshot, including 0 for a new/unstored aggregate.
+   * @returns A tenant/record/revision envelope with cloned reducer data, or resulting state when the reducer returns undefined; read-only reducers do not persist mutations.
+   * @throws Rejects malformed principal (401), denied live admission (403), schema/scope errors (400), stale revision/capacity/CAS conflict (409), invalid foreign records/reducer scope, and propagated reducer/invariant/clock/store/transaction failures.
+   * 
+   * @remarks
+   * Record ID defaults to state and must be nonblank/up to 256 characters. Writes append actor/UTC history and reject over 5000 entries or 8 MiB JSON state. Host transaction projections may start at revision 0. Rejections can follow partial plain-store/adapter effects; callers must reload before retrying uncertain outcomes.
+   * 
+   * @example
+   * ```typescript
+   * import { RecordCommandService, type CommandState, type PluginPrincipal } from '@alneas/eaos-server/plugin-data';
+   * export function executeAggregate<T extends CommandState>(service: RecordCommandService<T>, principal: PluginPrincipal, operation: string, input: unknown) { return service.execute(principal, operation, input); }
+   * ```
+   */
+  async execute(principal, operation, input) {
+    assertPrincipal(principal);
+    const p = structuredClone(principal), args = structuredClone(input);
+    const allow = async (state) => {
+      if (await this.host.authorize(structuredClone(p), operation, structuredClone(args), state && structuredClone(state)) !== true) throw new PluginError(403, "Plugin access denied");
+    };
+    await allow();
+    if (!this.validators.get(operation)?.(args)) throw new PluginError(400, "Invalid command");
+    const id2 = this.definition.recordId?.(args) ?? "state";
+    if (typeof id2 !== "string" || !id2.trim() || id2.length > 256) throw new PluginError(400, "Invalid record scope");
+    const run = async (store) => {
+      const record = await store.read(p.tenantId, id2);
+      if (record && (record.id !== id2 || record.value.tenantId !== p.tenantId || !Number.isSafeInteger(record.revision) || record.revision < (this.host.transaction ? 0 : 1))) throw new Error("Foreign or invalid plugin record");
+      const state = structuredClone(record?.value ?? this.definition.initial(p.tenantId, id2)), current = structuredClone(state), revision = record?.revision ?? 0;
+      this.definition.validate(state);
+      await allow(current);
+      const write = this.definition.writes.includes(operation);
+      if (write && (!Number.isSafeInteger(args.revision) || args.revision !== revision)) throw new PluginError(409, "Plugin revision changed");
+      const at = (this.host.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+      const result = await this.definition.reduce({ principal: structuredClone(p), operation, args, state, at, recordId: id2 });
+      if (write) {
+        if (state.tenantId !== p.tenantId) throw new Error("Reducer changed tenant");
+        state.history.push({ operation, actorId: p.userId, at });
+        this.definition.validate(state);
+        if (state.history.length > 5e3 || Buffer.byteLength(JSON.stringify(state)) > 8 * 1024 * 1024) throw new PluginError(409, "Plugin aggregate capacity reached");
+        await allow(current);
+        const next = { id: id2, revision: revision + 1, value: state };
+        if (!record || revision === 0) await store.create(p.tenantId, next);
+        else if (!await store.replace(p.tenantId, next, revision)) throw new PluginError(409, "Plugin revision changed");
+      } else await allow(current);
+      if (this.host.transaction) await allow(current);
+      return { tenantId: p.tenantId, recordId: id2, revision: revision + (write ? 1 : 0), data: structuredClone(result === void 0 ? state : result) };
+    };
+    return this.host.transaction ? this.host.transaction(p, run) : run(this.host.store);
+  }
+};
+
+// src/plugin-data/audit.ts
+var eventKey = (sequence) => "audit/event/" + String(sequence).padStart(16, "0");
+var jsonHash = (value) => atomicHash(value === void 0 ? null : JSON.parse(JSON.stringify(value)));
+async function appendAtomicAudit(tx, p, operation, input, result, commandKey = null) {
+  assertPrincipal(p);
+  if (!operation || operation.length > 240 || commandKey !== null && !commandKey.startsWith("command/")) throw new PluginError(400, "Invalid trusted audit operation");
+  const head = await tx.get("audit/head");
+  if (head && (head.value.version !== 1 || head.value.tenantId !== p.tenantId || !Number.isSafeInteger(head.value.sequence) || head.value.sequence < 1 || !/^[a-f0-9]{64}$/.test(head.value.hash))) throw new PluginError(409, "Audit head differs");
+  if (head) {
+    const previous = await tx.get(eventKey(head.value.sequence));
+    if (!previous || previous.value.hash !== head.value.hash) throw new PluginError(409, "Previous audit event unavailable");
+    const { hash: hash2, ...v } = previous.value;
+    if (hash2 !== atomicHash(v)) throw new PluginError(409, "Previous audit integrity differs");
+  }
+  const sequence = (head?.value.sequence ?? 0) + 1;
+  if (!Number.isSafeInteger(sequence) || sequence > 1e12) throw new PluginError(409, "Audit sequence at capacity");
+  const value = { version: 1, tenantId: p.tenantId, sequence, operation, actorId: p.userId, at: (/* @__PURE__ */ new Date()).toISOString(), inputHash: jsonHash(input), resultHash: jsonHash(result), commandKey, previousHash: head?.value.hash ?? null }, event = { ...value, hash: atomicHash(value) };
+  await tx.put(eventKey(sequence), event, 0);
+  await tx.put("audit/head", { version: 1, tenantId: p.tenantId, sequence, hash: event.hash }, head?.revision ?? 0);
+  return event;
+}
+async function readAtomicAudit(tx, p, afterSequence = 0, limit = 50) {
+  assertPrincipal(p);
+  if (!Number.isSafeInteger(afterSequence) || afterSequence < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 100) throw new PluginError(400, "Invalid audit page");
+  const rows = await tx.list("audit/event/", afterSequence ? eventKey(afterSequence) : "", limit + 1);
+  const events = [];
+  for (const row of rows.slice(0, limit)) {
+    const { hash: hash2, ...v } = row.value;
+    if (v.tenantId !== p.tenantId || v.version !== 1 || !Number.isSafeInteger(v.sequence) || v.sequence < 1 || row.id !== eventKey(v.sequence) || row.revision !== 1 || hash2 !== atomicHash(v)) throw new PluginError(409, "Audit event integrity differs");
+    events.push(row.value);
+  }
+  return { events, nextSequence: rows.length > limit ? events.at(-1).sequence : null };
+}
+async function verifyAtomicAudit(tx, p) {
+  assertPrincipal(p);
+  const head = await tx.get("audit/head");
+  let after = 0, count = 0, previousHash = null;
+  for (; ; ) {
+    const page = await readAtomicAudit(tx, p, after, 100);
+    for (const event of page.events) {
+      if (++count > 1e4) throw new PluginError(409, "Audit verification exceeds 10000 events; host archival verifier required");
+      if (event.sequence !== count || event.previousHash !== previousHash) throw new PluginError(409, "Audit sequence or previous hash differs");
+      if (event.commandKey) {
+        const receipt = await tx.get(event.commandKey);
+        if (!receipt || receipt.revision !== 1 || receipt.value.hash !== event.inputHash || jsonHash(receipt.value.result) !== event.resultHash) throw new PluginError(409, "Audit command receipt differs");
+      }
+      previousHash = event.hash;
+      after = event.sequence;
+    }
+    if (page.nextSequence === null) break;
+  }
+  if (count === 0 && head || count > 0 && (!head || head.value.version !== 1 || head.value.tenantId !== p.tenantId || head.value.sequence !== count || head.value.hash !== previousHash)) throw new PluginError(409, "Audit head or event tail differs");
+  return { tenantId: p.tenantId, status: "verified", count, headHash: previousHash, coverage: "atomic-journal-v1", externalTrustAnchor: false };
+}
+
+// src/plugin-data/atomic.ts
+import { canonicalJsonHash } from "@alneas/eaos-core/serialization";
+import { assertPayloadWithinPolicy, resolvePluginStoragePolicy } from "@alneas/eaos-core/plugin-sdk";
+function storagePayload(policy, value) {
+  try {
+    return assertPayloadWithinPolicy(policy, value);
+  } catch (error) {
+    if (error instanceof Error && error.message === "Storage policy payload limit exceeded") throw new PluginError(409, error.message);
+    throw error;
+  }
+}
+function joinedAtomicSqlExecutor(session, principal) {
+  assertPrincipal(principal);
+  const binding = atomicSqlBindings.get(session);
+  if (!binding || binding.principal.tenantId !== principal.tenantId || binding.principal.userId !== principal.userId) throw new Error("Live joined SQL transaction required");
+  return {
+    dialect: binding.dialect,
+    /**
+     * Executes trusted SQL on this session's still-active joined connection.
+     * @param tenantId - Must match the verified tenant bound to the original session.
+     * @param sql - Trusted parameterized SQL with explicit tenant predicates.
+     * @param binds - Positional bind values in placeholder order.
+     * @returns Query rows and affected-row metadata from the existing transaction.
+     * @throws Rejects expired/mismatched bindings, foreign tenant or underlying SQL failure.
+     * @see joinedAtomicSqlExecutor for scoped usage that does not retain this capability.
+     */
+    async execute(tenantId, sql, binds) {
+      if (atomicSqlBindings.get(session) !== binding || tenantId !== binding.principal.tenantId) throw new Error("Joined SQL transaction expired or tenant differs");
+      return binding.connection.execute(sql, binds);
+    }
+  };
+}
+function atomicHash(value) {
+  return canonicalJsonHash(value);
+}
+async function atomicCommand(tx, p, operation, input, work) {
+  if (!/^[A-Za-z0-9_-]{1,80}$/.test(input.commandId)) throw new PluginError(400, "Command ID required");
+  const key = `command/${atomicHash([p.userId, operation, input.commandId])}`, hash2 = atomicHash(input);
+  const old = await tx.get(key);
+  if (old) {
+    if (old.value.hash !== hash2) throw new PluginError(409, "Command ID reused with different input");
+    return old.value.result;
+  }
+  const result = await work();
+  await tx.put(key, { hash: hash2, result }, 0);
+  await appendAtomicAudit(tx, p, operation, input, result, key);
+  return result;
+}
+function recordCursor(scope, after) {
+  return Buffer.from(JSON.stringify({ scope: atomicHash(scope), after })).toString("base64url");
+}
+function parseRecordCursor(scope, cursor) {
+  if (!cursor) return "";
+  try {
+    const value = JSON.parse(Buffer.from(cursor, "base64url").toString());
+    if (value.scope !== atomicHash(scope) || typeof value.after !== "string") throw new Error();
+    return idInput(value.after);
+  } catch {
+    throw new PluginError(400, "Invalid scoped cursor");
+  }
+}
+var idInput = (id2) => {
+  if (typeof id2 !== "string" || !/^[A-Za-z0-9_.:/-]{1,240}$/.test(id2)) throw new PluginError(400, "Invalid record key");
+  return id2;
+};
+function createAtomicRepository(table, driver, options = {}) {
+  if (!/^[a-z][a-z0-9_]{0,62}$/.test(table) || !driver?.transaction) throw new Error("Trusted table and transaction driver required");
+  const prefix = options.namespace ? `${options.namespace}:` : "";
+  const storagePolicy = resolvePluginStoragePolicy(options.storagePolicy);
+  const documents = options.documents && structuredClone(options.documents);
+  if (documents?.some((d) => d.table !== table || d.namespace !== options.namespace)) throw Error("JSON document storage binding differs");
+  const validateDocument = documents && createRecordDocumentValidator(documents);
+  if (prefix && !/^[a-z][a-z0-9_]{0,62}:$/.test(prefix)) throw new Error("Invalid plugin storage namespace");
+  const physicalId = (id2) => {
+    if (prefix && id2.length + prefix.length > 256) throw new PluginError(400, "Record id is too long for the shared plugin table");
+    return `${prefix}${id2}`;
+  };
+  const logicalId = (id2) => prefix ? id2.startsWith(prefix) ? id2.slice(prefix.length) : null : id2;
+  const bind = (n) => driver.dialect === "oracle" ? `:${n}` : driver.dialect === "postgres" ? `$${n}` : "?";
+  const decode = (tenant, row) => {
+    const id2 = logicalId(String(row.id ?? row.ID));
+    if (id2 === null || !id2) throw new Error("Record belongs to another plugin storage namespace");
+    const record = { id: id2, revision: Number(row.revision ?? row.REVISION), value: JSON.parse(String(row.payload ?? row.PAYLOAD)) };
+    validateDocument?.(tenant, record);
+    return record;
+  };
+  return { async run(principal, work) {
+    assertPrincipal(principal);
+    const p = structuredClone(principal);
+    return driver.transaction(p, async (conn) => {
+      let active = true;
+      const check = () => {
+        if (!active) throw new Error("Transaction session expired");
+      };
+      const session = {
+        async get(id2) {
+          check();
+          idInput(id2);
+          const r = await conn.execute(`SELECT id,revision,payload FROM ${table} WHERE tenant_id=${bind(1)} AND id=${bind(2)}`, [p.tenantId, physicalId(id2)]);
+          return r.rows?.[0] ? decode(p.tenantId, r.rows[0]) : null;
+        },
+        async getMany(ids) {
+          check();
+          ids.forEach(idInput);
+          const found = /* @__PURE__ */ new Map();
+          const unique = [...new Set(ids)];
+          for (let offset = 0; offset < unique.length; offset += 200) {
+            const batch = unique.slice(offset, offset + 200);
+            const r = await conn.execute(`SELECT id,revision,payload FROM ${table} WHERE tenant_id=${bind(1)} AND id IN (${batch.map((_, i) => bind(i + 2)).join(",")})`, [p.tenantId, ...batch.map(physicalId)]);
+            for (const raw of r.rows ?? []) {
+              const row = decode(p.tenantId, raw);
+              found.set(row.id, row);
+            }
+          }
+          return ids.map((id2) => found.get(id2) ?? null);
+        },
+        async putMany(changes) {
+          check();
+          if (new Set(changes.map((c) => c.id)).size !== changes.length) throw new PluginError(400, "Duplicate batch record key");
+          const prepared = changes.map((c) => {
+            idInput(c.id);
+            if (!Number.isSafeInteger(c.expected) || c.expected < 0 || c.expected >= Number.MAX_SAFE_INTEGER) throw new PluginError(400, "Invalid revision");
+            validateDocument?.(p.tenantId, { id: c.id, revision: c.expected + 1, value: c.value });
+            return { ...c, payload: storagePayload(storagePolicy, c.value) };
+          });
+          if (!conn.executeMany) {
+            const result = [];
+            for (const c of prepared) result.push(await session.put(c.id, c.value, c.expected));
+            return result;
+          }
+          try {
+            for (const inserting of [true, false]) {
+              const group = prepared.filter((c) => c.expected === 0 === inserting);
+              const sql = inserting ? `INSERT INTO ${table}(tenant_id,id,revision,payload) VALUES(${bind(1)},${bind(2)},1,${bind(3)})` : `UPDATE ${table} SET revision=${bind(1)},payload=${bind(2)} WHERE tenant_id=${bind(3)} AND id=${bind(4)} AND revision=${bind(5)}`;
+              for (let offset = 0; offset < group.length; offset += 100) {
+                const batch = group.slice(offset, offset + 100), result = await conn.executeMany(sql, batch.map((c) => inserting ? [p.tenantId, physicalId(c.id), c.payload] : [c.expected + 1, c.payload, p.tenantId, physicalId(c.id), c.expected]));
+                if (result.affectedRows.length !== batch.length || result.affectedRows.some((n) => n !== 1)) throw new PluginError(409, "Record revision changed");
+              }
+            }
+          } catch (e) {
+            if (["SQLITE_CONSTRAINT_PRIMARYKEY", "SQLITE_CONSTRAINT_UNIQUE", "23505", "ORA-00001"].includes(e?.code) || e?.errorNum === 1) throw new PluginError(409, "Record already exists");
+            throw e;
+          }
+          return prepared.map((c) => ({ id: c.id, revision: c.expected + 1, value: structuredClone(c.value) }));
+        },
+        async list(prefix2, after = "", limit = 100) {
+          check();
+          if (prefix2 !== "") idInput(prefix2);
+          if (after) idInput(after);
+          if (!Number.isInteger(limit) || limit < 1 || limit > 101) throw new PluginError(400, "Invalid page limit");
+          const tail = driver.dialect === "oracle" ? `FETCH FIRST ${limit} ROWS ONLY` : `LIMIT ${limit}`;
+          const physicalPrefix = physicalId(prefix2), physicalAfter = after ? physicalId(after) : `${physicalPrefix} `;
+          const r = await conn.execute(`SELECT id,revision,payload FROM ${table} WHERE tenant_id=${bind(1)} AND id>=${bind(2)} AND id<${bind(3)} AND id>${bind(4)} ORDER BY id ${tail}`, [p.tenantId, physicalPrefix, `${physicalPrefix}\uFFFF`, physicalAfter]);
+          return (r.rows ?? []).map((row) => decode(p.tenantId, row));
+        },
+        async put(id2, value, expected) {
+          check();
+          idInput(id2);
+          if (!Number.isSafeInteger(expected) || expected < 0 || expected >= Number.MAX_SAFE_INTEGER) throw new PluginError(400, "Invalid revision");
+          validateDocument?.(p.tenantId, { id: id2, revision: expected + 1, value });
+          const payload = storagePayload(storagePolicy, value);
+          try {
+            const r = expected === 0 ? await conn.execute(`INSERT INTO ${table}(tenant_id,id,revision,payload) VALUES(${bind(1)},${bind(2)},1,${bind(3)})`, [p.tenantId, physicalId(id2), payload]) : await conn.execute(`UPDATE ${table} SET revision=${bind(1)},payload=${bind(2)} WHERE tenant_id=${bind(3)} AND id=${bind(4)} AND revision=${bind(5)}`, [expected + 1, payload, p.tenantId, physicalId(id2), expected]);
+            if (r.affectedRows !== 1) throw new PluginError(409, "Record revision changed");
+          } catch (e) {
+            if (["SQLITE_CONSTRAINT_PRIMARYKEY", "SQLITE_CONSTRAINT_UNIQUE", "23505", "ORA-00001"].includes(e?.code) || e?.errorNum === 1) throw new PluginError(409, "Record already exists");
+            throw e;
+          }
+          return { id: id2, revision: expected + 1, value: structuredClone(value) };
+        }
+      };
+      atomicSqlBindings.set(session, { connection: conn, principal: p, dialect: driver.dialect });
+      try {
+        return await work(session);
+      } finally {
+        active = false;
+        atomicSqlBindings.delete(session);
+      }
+    });
+  } };
+}
+function createAtomicRecordStore(session, principal) {
+  assertPrincipal(principal);
+  const tenantId = principal.tenantId;
+  const scope = (requested) => {
+    if (requested !== tenantId) throw new PluginError(403, "Atomic record tenant differs");
+  };
+  return {
+    read: async (requested, id2) => {
+      scope(requested);
+      return session.get(id2);
+    },
+    list: async (requested, limit) => {
+      scope(requested);
+      return session.list("", "", limit);
+    },
+    listPage: async (requested, limit, after = "") => {
+      scope(requested);
+      return session.list("", after, limit);
+    },
+    create: async (requested, record) => {
+      scope(requested);
+      if (record.revision !== 1) throw new PluginError(400, "Invalid initial record revision");
+      await session.put(record.id, record.value, 0);
+    },
+    replace: async (requested, record, expected) => {
+      scope(requested);
+      if (record.revision !== expected + 1) throw new PluginError(400, "Invalid next record revision");
+      await session.put(record.id, record.value, expected);
+      return true;
+    }
+  };
+}
+function createPluginAtomicRepository(manifest, driver, catalog) {
+  const storage = manifest.schema.storage;
+  if (storage) {
+    if (!catalog) throw Error("Contract-backed record storage requires a trusted schema catalog");
+    const documents = recordDocuments(catalog, storage);
+    return createAtomicRepository(storage.table, driver, { namespace: storage.namespace, storagePolicy: manifest.schema.storagePolicy, ...documents?.length ? { documents } : {} });
+  }
+  if (manifest.schema.ownedTables.length !== 1) throw new Error("Plugin manifest must declare one storage table or shared storage metadata");
+  return createAtomicRepository(manifest.schema.ownedTables[0], driver, { storagePolicy: manifest.schema.storagePolicy });
+}
+function createSqliteAtomicDriver(db) {
+  let tail = Promise.resolve();
+  return { dialect: "sqlite", transaction(_p, work) {
+    const next = tail.then(async () => {
+      db.exec("BEGIN IMMEDIATE");
+      try {
+        const result = await work({ async execute(sql, binds) {
+          const q = db.query(sql);
+          return /^SELECT\b/i.test(sql) ? { rows: q.all(...binds), affectedRows: 0 } : { affectedRows: q.run(...binds).changes };
+        } });
+        db.exec("COMMIT");
+        return result;
+      } catch (e) {
+        db.exec("ROLLBACK");
+        throw e;
+      }
+    });
+    tail = next.catch(() => void 0);
+    return next;
+  } };
+}
+function createOracleAtomicDriver(host, types) {
+  return { dialect: "oracle", transaction: (p, work) => host.withTenantConnection("PLUGIN_RECORDS", async (conn) => {
+    try {
+      const execute = async (sql, binds) => {
+        const r = await conn.execute(sql, binds.map((value) => typeof value === "string" && value.length > 4e3 ? { val: value, type: types.clobType } : value), { autoCommit: false, outFormat: types.objectFormat, .../^SELECT\b/i.test(sql) ? { fetchInfo: { PAYLOAD: { type: types.stringType } } } : {} });
+        return { rows: r.rows, affectedRows: r.rowsAffected ?? 0 };
+      };
+      const result = await work({ execute, ...conn.executeMany ? { async executeMany(sql, binds) {
+        if (binds.some((row) => row.some((value) => typeof value === "string" && value.length > 4e3))) {
+          const affectedRows = [];
+          for (const row of binds) affectedRows.push((await execute(sql, row)).affectedRows);
+          return { affectedRows };
+        }
+        const result2 = await conn.executeMany(sql, binds, { autoCommit: false, dmlRowCounts: true });
+        if (!Array.isArray(result2.dmlRowCounts) || result2.dmlRowCounts.length !== binds.length || result2.dmlRowCounts.some((n) => !Number.isSafeInteger(n) || n < 0)) throw new Error("Oracle batch did not return valid row counts");
+        return { affectedRows: result2.dmlRowCounts };
+      } } : {} });
+      await conn.commit();
+      return result;
+    } catch (e) {
+      await conn.rollback();
+      throw e;
+    }
+  }, { tenantId: p.tenantId, userId: p.userId }) };
+}
+
+// src/plugin-data/outbox.ts
+import { randomUUID } from "node:crypto";
+import { OutboxDispatcher, createOutboxEvent } from "@alneas/eaos-core";
+var outboxKey = (id2) => `outbox/${id2}`;
+async function enqueueOutboxEvent(tx, input) {
+  const event = createOutboxEvent(input);
+  const key = outboxKey(event.id);
+  const existing = await tx.get(key);
+  if (existing) {
+    if (existing.value.payloadHash !== event.payloadHash || existing.value.topic !== event.topic || existing.value.idempotencyKey !== event.idempotencyKey) throw new PluginError(409, "Outbox idempotency key reused with different input");
+    return structuredClone(existing.value);
+  }
+  await tx.put(key, event, 0);
+  return structuredClone(event);
+}
+function createAtomicWorkflowEventSink(tx, topicPrefix = "workflow") {
+  if (!tx || typeof tx.put !== "function") throw new Error("Atomic transaction is required");
+  if (!/^[A-Za-z0-9_.:/-]+$/.test(topicPrefix)) throw new Error("Invalid workflow event topic prefix");
+  return {
+    async append(event) {
+      await enqueueOutboxEvent(tx, {
+        tenantId: event.tenantId,
+        producer: event.producer,
+        topic: `${topicPrefix}.${event.type}`,
+        idempotencyKey: event.idempotencyKey,
+        payload: structuredClone(event),
+        id: event.eventId,
+        occurredAt: event.occurredAt
+      });
+    }
+  };
+}
+function createAtomicOutboxStore(options) {
+  const p = structuredClone(options.principal);
+  const staleAfterMs = options.staleAfterMs ?? 5 * 6e4;
+  if (!Number.isFinite(staleAfterMs) || staleAfterMs < 1e3) throw new Error("Invalid outbox stale timeout");
+  return {
+    async claim(now, limit) {
+      if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100) throw new Error("Invalid outbox batch size");
+      return options.repository.run(p, async (tx) => {
+        const claimed = [];
+        let after = "", scanned = 0;
+        for (; ; ) {
+          const rows = await tx.list("outbox/", after, 100);
+          for (const row of rows) {
+            if (claimed.length >= limit) break;
+            if (++scanned > 3e4) throw new PluginError(409, "Outbox scan at capacity");
+            if (row.value.tenantId !== p.tenantId || row.id !== outboxKey(row.value.id)) throw new PluginError(409, "Outbox scope differs");
+            const due = row.value.status === "pending" && Date.parse(row.value.availableAt) <= now.getTime();
+            const stale = row.value.status === "processing" && Date.parse(row.value.claimedAt ?? "") <= now.getTime() - staleAfterMs;
+            if (!due && !stale) continue;
+            const next2 = { ...row.value, status: "processing", attempts: row.value.attempts + 1, claimedAt: now.toISOString(), claimToken: randomUUID(), lastError: void 0 };
+            claimed.push((await tx.put(row.id, next2, row.revision)).value);
+          }
+          if (claimed.length >= limit || rows.length < 100) break;
+          const next = rows.at(-1).id;
+          if (next <= after) throw new PluginError(409, "Outbox page did not advance");
+          after = next;
+        }
+        return claimed;
+      });
+    },
+    async markPublished(id2, claimToken, publishedAt) {
+      await options.repository.run(p, async (tx) => {
+        const row = await tx.get(outboxKey(id2));
+        if (!row || row.value.status !== "processing" || row.value.claimToken !== claimToken) throw new PluginError(409, "Outbox claim changed");
+        await tx.put(row.id, { ...row.value, status: "published", publishedAt: publishedAt.toISOString(), claimedAt: void 0, claimToken: void 0 }, row.revision);
+      });
+    },
+    async markFailed(id2, claimToken, error, retryAt) {
+      await options.repository.run(p, async (tx) => {
+        const row = await tx.get(outboxKey(id2));
+        if (!row || row.value.status !== "processing" || row.value.claimToken !== claimToken) throw new PluginError(409, "Outbox claim changed");
+        await tx.put(row.id, { ...row.value, status: retryAt ? "pending" : "failed", availableAt: retryAt?.toISOString() ?? row.value.availableAt, claimedAt: void 0, claimToken: void 0, lastError: error }, row.revision);
+      });
+    }
+  };
+}
+function createAtomicOutboxDispatcher(options) {
+  const { repository, principal, staleAfterMs, now, ...dispatcher } = options;
+  return new OutboxDispatcher({ ...dispatcher, now, store: createAtomicOutboxStore({ repository, principal, staleAfterMs, now }) });
+}
+async function requeueOutboxEvent(tx, tenantId, id2, availableAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  if (!id2 || id2.length > 256 || !Number.isFinite(Date.parse(availableAt))) throw new PluginError(400, "Invalid outbox recovery");
+  const row = await tx.get(outboxKey(id2));
+  if (!row || row.value.tenantId !== tenantId || row.value.id !== id2 || row.value.status !== "failed") throw new PluginError(409, "Failed outbox event unavailable");
+  const next = { ...row.value, status: "pending", availableAt, claimedAt: void 0, claimToken: void 0, lastError: void 0 };
+  await tx.put(row.id, next, row.revision);
+  return next;
+}
+
+// src/plugin-data/scoped-records.ts
+import Ajv2 from "ajv";
+function uniqueRecordKey(name, values) {
+  if (!/^[a-z][a-z0-9_-]{0,60}$/.test(name) || !values.length) throw new Error("Invalid trusted uniqueness declaration");
+  if (values.some((value) => typeof value !== "string" || !value.trim())) throw new PluginError(409, "Unique identity fields must be nonempty strings");
+  return `unique/${atomicHash([name, values])}`;
+}
+var ScopedRecordService = class _ScopedRecordService {
+  /**
+   * Compiles strict noncoercing command schemas for one trusted record definition.
+   * @param host - Durable tenant-scoped store, live authorization, optional clock and shared atomic repository.
+   * @param definition - Plugin-owned operation names, schemas, reducers, paging and identity rules.
+   * @param atomicSession - Optional already active internal session used for joined composition/uniqueness; its lifetime must not exceed the enclosing repository callback.
+   * @throws Throws when durable store or live authorization is missing, or strict schema compilation fails.
+   * 
+   * @example
+   * ```typescript
+   * import { ScopedRecordService, type ScopedRecordHost, type ScopedRecordDefinition } from '@alneas/eaos-server/plugin-data';
+   * type Row = { tenantId: string; id: string; title: string };
+   * type RevisionedRow = Row & { revision: number };
+   * export function connectRecords(host: ScopedRecordHost<Row>, definition: ScopedRecordDefinition<Row, RevisionedRow>) { return new ScopedRecordService(host, definition); }
+   * ```
+   */
+  constructor(host, definition, atomicSession) {
+    this.host = host;
+    this.definition = definition;
+    this.atomicSession = atomicSession;
+    if (!host?.store || typeof host.authorize !== "function") throw new Error("Durable scoped record store and live authorization required");
+    const ajv2 = new Ajv2({ strict: true, coerceTypes: false });
+    this.validators = new Map(Object.entries(definition.schemas).map(([name, schema]) => [name, ajv2.compile(schema)]));
+  }
+  host;
+  definition;
+  atomicSession;
+  validators;
+  async allow(principal, operation, input, current) {
+    assertPrincipal(principal);
+    if (await this.host.authorize(structuredClone(principal), operation, structuredClone(input), current && structuredClone(current)) !== true) throw new PluginError(403, `${this.definition.label} access denied`);
+  }
+  /**
+   * Exposes the same live tenant/permission check to a plugin's read-only
+   * domain previews. Preview operations do not persist records, but they must
+   * still be authorized through the host before invoking domain logic.
+   */
+  async authorizeOperation(principal, operation, input, current) {
+    await this.allow(principal, operation, input, current);
+  }
+  currentTime() {
+    return this.host.now?.() ?? /* @__PURE__ */ new Date();
+  }
+  excluded(id2) {
+    return id2.startsWith("audit/") || !!this.definition.unique?.length && id2.startsWith("unique/") || Object.values(this.definition.schemas).some((schema) => schema?.properties?.commandId) && /^(?:command|event)\//.test(id2) || this.definition.excludedIdPrefixes?.some((prefix) => id2.startsWith(prefix)) === true;
+  }
+  decode(principal, record) {
+    if (record.id !== record.value.id || record.value.tenantId !== principal.tenantId || !Number.isSafeInteger(record.revision) || record.revision < 1) throw new Error(`Invalid scoped ${this.definition.label} record`);
+    return { ...structuredClone(record.value), revision: record.revision };
+  }
+  async load(principal, id2) {
+    if (this.excluded(id2)) throw new PluginError(404, `${this.definition.label} not found`);
+    const record = await this.host.store.read(principal.tenantId, id2);
+    if (!record) throw new PluginError(404, `${this.definition.label} not found`);
+    return this.decode(principal, record);
+  }
+  matches(args, value) {
+    return (!this.definition.filter || this.definition.filter(args, value)) && (!args.search || this.definition.searchableFields?.some((key) => typeof value[key] === "string" && String(value[key]).toLocaleLowerCase().includes(args.search.toLocaleLowerCase()))) === true;
+  }
+  /** Read all authorized records for plugin-owned reports; providers must support keyset paging. */
+  async readAllAuthorized(principal, operation, input, accept) {
+    if (this.host.repository) return this.host.repository.run(principal, (tx) => this.readAllFromStore(principal, operation, input, accept, createAtomicRecordStore(tx, principal)));
+    return this.readAllFromStore(principal, operation, input, accept, this.host.store);
+  }
+  async readAllFromStore(principal, operation, input, accept, store) {
+    await this.allow(principal, operation, input);
+    if (!store.listPage) throw new PluginError(409, "Paged record storage required for complete reports");
+    const values = [];
+    let after = "";
+    for (; ; ) {
+      const rows = await store.listPage(principal.tenantId, 100, after);
+      for (const raw of rows) {
+        if (this.excluded(raw.id)) continue;
+        const value = this.decode(principal, raw);
+        if (accept(value) && await this.host.authorize(structuredClone(principal), operation, structuredClone(input), structuredClone(value)) === true) values.push(value);
+      }
+      if (rows.length < 100) break;
+      const next = rows.at(-1).id;
+      if (next <= after) throw new Error("Record page did not advance");
+      after = next;
+    }
+    await this.allow(principal, operation, input);
+    return values;
+  }
+  async reserveUnique(value, previous) {
+    if (!this.definition.unique?.length) return;
+    const tx = this.atomicSession;
+    if (!tx) throw new PluginError(409, "Transactional storage required for unique business identities");
+    for (const constraint of this.definition.unique) {
+      if (!constraint.fields.length) throw new Error("Invalid trusted uniqueness declaration");
+      const key = (record) => uniqueRecordKey(constraint.name, constraint.fields.map((field) => record[field]));
+      const applies = (record) => {
+        const active = constraint.when ? constraint.when(structuredClone(record)) : true;
+        if (typeof active !== "boolean") throw new Error("Unique predicate must return a boolean");
+        return active;
+      };
+      const nextActive = applies(value), oldActive = previous ? applies(previous) : false, nextKey = nextActive ? key(value) : null, oldKey = previous && oldActive ? key(previous) : null;
+      if (nextKey) {
+        const reservation = await tx.get(nextKey);
+        if (reservation && reservation.value.recordId !== null && reservation.value.recordId !== value.id) throw new PluginError(409, `${this.definition.label} identity already exists`);
+        if (!reservation || reservation.value.recordId === null) await tx.put(nextKey, { recordId: value.id }, reservation?.revision ?? 0);
+      }
+      if (oldKey && oldKey !== nextKey) {
+        const old = await tx.get(oldKey);
+        if (!old || old.value.recordId !== value.id) throw new PluginError(409, "Unique identity reservation conflicts");
+        await tx.put(oldKey, { recordId: null }, old.revision);
+      }
+    }
+  }
+  /**
+   * Dispatches one admitted record operation and optionally joins it to durable command/audit receipt handling.
+   * @param principal - Verified current tenant/user principal; host authorization is rechecked throughout the operation.
+   * @param operation - Declared list/get/create/update/archive or plugin custom reducer key.
+   * @param input - Operation-schema input; mutations require matching record revision and optional durable commandId when declared.
+   * @returns List operations return the configured listKey with scoped records and paging metadata; get/mutations return a decoded revisioned record. Paged results may be incomplete and carry nextCursor/mayHaveMore.
+   * @throws Rejects invalid principal (401), denied/revoked admission (403), schema/operation errors (400), missing/excluded record (404), stale revision/uniqueness/CAS conflict or missing required transactional capability (409), foreign/corrupt records, and propagated domain/store/clock/callback failures.
+   * 
+   * @remarks
+   * Pagination scans at most 10000 rows per request, selecting authorized/filter-matching records. Without paging, filtering applies only to the bounded store result. Repository writes with declared commandId replay the stored identical result; other repository writes append audit. Recheck live resource permission before replay, and reload uncertain plain-store outcomes rather than retrying blindly.
+   * 
+   * @example
+   * ```typescript
+   * import { ScopedRecordService, type PluginPrincipal } from '@alneas/eaos-server/plugin-data';
+   * export function dispatch<T extends {tenantId: string; id: string}, S extends T & {revision: number}>(service: ScopedRecordService<T, S>, principal: PluginPrincipal, operation: string, input: unknown) { return service.execute(principal, operation, input); }
+   * ```
+   */
+  async execute(principal, operation, input) {
+    if (this.host.repository) {
+      await this.allow(principal, operation, input);
+      const p = structuredClone(principal);
+      return this.host.repository.run(p, async (tx) => {
+        const service = new _ScopedRecordService({ ...this.host, repository: void 0, store: createAtomicRecordStore(tx, p) }, this.definition, tx);
+        const write = operation !== this.definition.operations.list && operation !== this.definition.operations.get;
+        const journaled = write && this.definition.schemas[operation]?.properties?.commandId && typeof input?.commandId === "string";
+        const perform = () => service.execute(p, operation, input);
+        if (journaled && !this.validators.get(operation)?.(input)) throw new PluginError(400, `Invalid ${this.definition.label} command`);
+        const result = journaled ? await atomicCommand(tx, p, operation, input, perform) : await perform();
+        if (write && !journaled) await appendAtomicAudit(tx, p, operation, input, result);
+        const resource = operation === this.definition.operations.list ? void 0 : await service.load(p, result.id);
+        await this.allow(p, operation, input, resource);
+        return result;
+      });
+    }
+    await this.allow(principal, operation, input);
+    const validate = this.validators.get(operation);
+    if (!validate || !validate(input)) throw new PluginError(400, `Invalid ${this.definition.label} command`);
+    if (!this.atomicSession && operation !== this.definition.operations.list && operation !== this.definition.operations.get && this.definition.schemas[operation]?.properties?.commandId && typeof input?.commandId === "string") throw new PluginError(409, "Transactional storage required for durable command receipts");
+    const args = input, at = (this.host.now?.() ?? /* @__PURE__ */ new Date()).toISOString(), ops = this.definition.operations;
+    if (this.definition.afterWrite && !this.atomicSession && operation !== ops.list && operation !== ops.get) throw new PluginError(409, "Transactional storage required for owning record composition");
+    if (operation === ops.list) {
+      const limit = args.limit ?? 50, values = [];
+      if (this.definition.pagination && this.host.store.listPage) {
+        const { cursor, ...criteria } = args, scope = [principal.tenantId, principal.userId, operation, criteria];
+        let position = parseRecordCursor(scope, cursor), finished = false, scannedCount = 0;
+        while (values.length < limit && scannedCount < 1e4) {
+          const rows = await this.host.store.listPage(principal.tenantId, 100, position);
+          if (!rows.length) {
+            finished = true;
+            break;
+          }
+          for (const raw of rows) {
+            position = raw.id;
+            scannedCount++;
+            if (this.excluded(raw.id)) continue;
+            const value = this.decode(principal, raw);
+            if (this.matches(args, value) && await this.host.authorize(structuredClone(principal), operation, { ...criteria, id: value.id }, structuredClone(value)) === true) values.push(value);
+            if (values.length === limit) break;
+          }
+          if (values.length < limit && rows.length < 100) {
+            finished = true;
+            break;
+          }
+        }
+        await this.allow(principal, operation, input);
+        return { [this.definition.listKey]: values, scannedLimit: limit, scannedCount, mayHaveMore: !finished, nextCursor: finished ? null : recordCursor(scope, position) };
+      }
+      if (args.cursor) throw new PluginError(409, "Paged record storage unavailable");
+      const records = await this.host.store.list(principal.tenantId, limit);
+      for (const raw of records) {
+        if (this.excluded(raw.id)) continue;
+        const value = this.decode(principal, raw);
+        if (this.matches(args, value) && await this.host.authorize(structuredClone(principal), operation, { id: value.id }, structuredClone(value)) === true) values.push(value);
+      }
+      await this.allow(principal, operation, input);
+      return { [this.definition.listKey]: values, scannedLimit: limit, mayHaveMore: records.length === limit };
+    }
+    if (operation === ops.create) {
+      const value = this.definition.create(args, principal, at);
+      if (value.tenantId !== principal.tenantId || !value.id || this.excluded(value.id)) throw new Error(`Invalid ${this.definition.label} scope`);
+      await this.allow(principal, operation, value);
+      await this.reserveUnique(value);
+      await this.host.store.create(principal.tenantId, { id: value.id, revision: 1, value });
+      const created = { ...value, revision: 1 };
+      if (this.definition.afterWrite) {
+        await this.definition.afterWrite(structuredClone(principal), operation, structuredClone(args), structuredClone(created));
+        await this.allow(principal, operation, input, created);
+      }
+      return created;
+    }
+    const current = await this.load(principal, textInput(args.id, "id", 128));
+    await this.allow(principal, operation, input, current);
+    if (operation === ops.get) return current;
+    const previous = structuredClone(current);
+    const expected = revisionInput(args.revision);
+    if (expected !== current.revision) throw new PluginError(409, `${this.definition.label} changed`);
+    if (operation === ops.archive) {
+      this.definition.archive(current, at, args, principal);
+    } else if (operation === ops.update) {
+      const patch = args.patch;
+      const patchSchema = this.definition.schemas[ops.update]?.properties?.patch?.properties;
+      if (patchSchema) exactKeys(patch, Object.keys(patchSchema));
+      this.definition.update(current, patch, at);
+    } else if (this.definition.custom?.[operation]) {
+      this.definition.custom[operation](current, args, at, principal);
+    } else {
+      throw new PluginError(400, `Unknown ${this.definition.label} operation`);
+    }
+    await this.allow(principal, operation, input, current);
+    await this.reserveUnique(current, previous);
+    const nextRevision = expected + 1;
+    const { revision: _revision, ...payload } = current;
+    if (!await this.host.store.replace(principal.tenantId, { id: current.id, revision: nextRevision, value: payload }, expected)) throw new PluginError(409, `${this.definition.label} changed`);
+    current.revision = nextRevision;
+    if (this.definition.afterWrite) {
+      await this.definition.afterWrite(structuredClone(principal), operation, structuredClone(args), structuredClone(current), previous);
+      await this.allow(principal, operation, input, current);
+    }
+    return current;
+  }
+};
+
+// src/plugin-data/composite.ts
+function createCompositePluginService(services, operationOwners) {
+  const owned = new Map(Object.entries(operationOwners));
+  for (const [operation, owner] of owned) {
+    if (!services[owner]) throw new Error(`Unknown composite service: ${owner} (${operation})`);
+  }
+  return {
+    async execute(principal, operation, input) {
+      const owner = owned.get(operation);
+      if (!owner) throw new PluginError(400, "Unknown bundled plugin operation");
+      return services[owner].execute(principal, operation, input);
+    }
+  };
+}
+
+// src/plugin-data/annotations.ts
+var annotationOperations = ["get_annotations", "set_check", "add_comment", "resolve_comment"];
+function annotationSchemas(target) {
+  const id2 = { type: "string", pattern: "^[a-zA-Z0-9_-]{1,80}$" }, revision = { type: "integer", minimum: 0, maximum: 9007199254740990 };
+  const visibility = { enum: ["private", "shared"] }, anchorId = { anyOf: [{ type: "string", minLength: 1, maxLength: 1e3 }, { type: "null" }] };
+  const schema = (properties, required) => ({ type: "object", additionalProperties: false, required: [...Object.keys(target), ...required], properties: { ...target, ...properties } });
+  return {
+    get_annotations: schema({ visibility, cursor: { type: "string", maxLength: 1e3 } }, ["visibility"]),
+    set_check: schema({ commandId: id2, revision, itemId: { type: "string", minLength: 1, maxLength: 1e3 }, checked: { type: "boolean" } }, ["commandId", "revision", "itemId", "checked"]),
+    add_comment: schema({ commandId: id2, visibility, anchorId, body: { type: "string", minLength: 1, maxLength: 4e3 } }, ["commandId", "visibility", "anchorId", "body"]),
+    resolve_comment: schema({ commandId: id2, revision, visibility, commentId: id2, resolved: { type: "boolean" } }, ["commandId", "revision", "visibility", "commentId", "resolved"])
+  };
+}
+async function documentAnnotations(tx, p, target, operation, a, now) {
+  if (!/^[a-f0-9]{64}$/.test(target.scope)) throw new Error("Trusted annotation scope required");
+  const owner = atomicHash(p.userId), checksKey = `checks/${target.scope}/${owner}`;
+  const prefix = `comments/${target.scope}/${a.visibility === "shared" ? "shared" : owner}/`;
+  const visible = (row) => ({ ...row.value, revision: row.revision, canResolve: row.value.authorId === p.userId });
+  if (operation === "get_annotations") {
+    const scope = [p.tenantId, p.userId, target.scope, a.visibility], after = parseRecordCursor(scope, a.cursor);
+    if (after && !after.startsWith(prefix)) throw new PluginError(400, "Invalid comment cursor");
+    const checks = await tx.get(checksKey), rows = await tx.list(prefix, after, 51);
+    return { checkIds: target.checkIds, checks: checks?.value ?? {}, revision: checks?.revision ?? 0, comments: rows.slice(0, 50).map(visible), ...rows.length > 50 ? { cursor: recordCursor(scope, rows[49].id) } : {} };
+  }
+  if (operation === "set_check") {
+    if (!target.checkIds.includes(a.itemId)) throw new PluginError(400, "Unknown reading check");
+    const old = await tx.get(checksKey), value = { ...old?.value };
+    if (a.checked) Object.defineProperty(value, a.itemId, { value: true, enumerable: true, configurable: true, writable: true });
+    else delete value[a.itemId];
+    if (Object.keys(value).length > 1e3) throw new PluginError(400, "Reading check capacity exceeded");
+    const saved = await tx.put(checksKey, value, a.revision);
+    return { checks: saved.value, revision: saved.revision };
+  }
+  if (operation === "add_comment") {
+    if (!a.body.trim() || a.anchorId !== null && !target.anchorIds.includes(a.anchorId)) throw new PluginError(400, "Comment body and valid anchor required");
+    const comment = { id: crypto.randomUUID(), anchorId: a.anchorId, body: a.body.trim(), visibility: a.visibility, authorId: p.userId, createdAt: now, resolved: false };
+    return visible(await tx.put(prefix + comment.id, comment, 0));
+  }
+  if (operation === "resolve_comment") {
+    const row = await tx.get(prefix + a.commentId);
+    if (!row) throw new PluginError(404, "Comment unavailable");
+    if (row.value.authorId !== p.userId) throw new PluginError(403, "Only the comment author may resolve it");
+    return visible(await tx.put(row.id, { ...row.value, resolved: a.resolved }, a.revision));
+  }
+  throw new PluginError(400, "Unknown annotation operation");
+}
+
+// src/plugin-data/delivery.ts
+import Ajv3 from "ajv";
+import { randomUUID as randomUUID2 } from "node:crypto";
+var deliveryOperations = ["enqueue_delivery", "get_delivery", "run_delivery", "recover_delivery", "cancel_delivery"];
+var id = { type: "string", pattern: "^[a-zA-Z0-9_-]{1,80}$" };
+var hash = { type: "string", pattern: "^[a-f0-9]{64}$" };
+var enqueueDeliverySchema = { type: "object", additionalProperties: false, required: ["commandId", "jobId", "channel", "kind", "target", "contentHash", "approvalRequestId"], properties: { commandId: id, jobId: id, channel: id, kind: { enum: ["publish", "withdraw"] }, target: { type: "object", maxProperties: 10, additionalProperties: true }, contentHash: hash, approvalRequestId: id } };
+var deliveryJobSchema = { type: "object", additionalProperties: false, required: ["jobId"], properties: { jobId: id } };
+var recoverDeliverySchema = { type: "object", additionalProperties: false, required: ["jobId", "revision"], properties: { jobId: id, revision: { type: "integer", minimum: 1, maximum: 9007199254740990 } } };
+var ajv = new Ajv3({ strict: true });
+var validators = { enqueue_delivery: ajv.compile(enqueueDeliverySchema), cancel_delivery: ajv.compile(deliveryJobSchema), get_delivery: ajv.compile(deliveryJobSchema), run_delivery: ajv.compile(deliveryJobSchema), recover_delivery: ajv.compile(recoverDeliverySchema) };
+var ArtifactDeliveryService = class {
+  /**
+   * Binds the host atomic delivery ledger, public publication ports and live operation authorization.
+   * @param options - Real atomic repository, idempotent host delivery ports and current operation/resource authorization; construction does not validate or execute those ports.
+   * 
+   * @example
+   * ```typescript
+   * import { ArtifactDeliveryService } from '@alneas/eaos-server/plugin-data';
+   * export function connectDelivery(options: ConstructorParameters<typeof ArtifactDeliveryService>[0]) { return new ArtifactDeliveryService(options); }
+   * ```
+   */
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async allow(p, op, a, j) {
+    assertPrincipal(p);
+    if (await this.options.authorize(structuredClone(p), op, structuredClone(a), structuredClone(j)) !== true) throw new PluginError(403, "Delivery access denied");
+  }
+  async verify(p, j) {
+    if (await this.options.ports.verify(p, structuredClone(j)) !== true) throw new PluginError(403, "Public delivery approval unavailable");
+  }
+  /**
+   * Enqueues, reads, runs, cancels or explicitly recovers one durable approved delivery job.
+   * @param p - Verified current tenant principal; operation/resource admission is rechecked before transitions.
+   * @param op - One of deliveryOperations; each input is checked by its closed schema.
+   * @param a - jobId for every operation; enqueue additionally needs commandId/channel/kind/target/contentHash/approvalRequestId, and recovery needs the exact running job revision.
+   * @returns The durable AtomicRow<DeliveryJob>, possibly an existing identical enqueue receipt or already terminal job; query get_delivery for current state after receipt replay.
+   * @throws Rejects invalid principal/input (401/400), denied live/public approval (403), absent job (404), busy channel/worker, stale recovery or unavailable cancellation port (409), invalid built artifact and propagated repository/port failures; effects may already have occurred.
+   * 
+   * @remarks
+   * Publish starts at build, withdrawal at activate; completion follows successful purge. Cancellation requires a reconciliation port and never removes a newer host version. Completed jobs require a new withdrawal job instead of cancellation. Recovery requires exact revision and drained(old token), marks failed and clears ownership for retry. Failure retains the last durable phase and a sanitized error, while the original host error may reject the call.
+   * 
+   * @example
+   * ```typescript
+   * import { ArtifactDeliveryService, type PluginPrincipal } from '@alneas/eaos-server/plugin-data';
+   * export function readDelivery(service: ArtifactDeliveryService, principal: PluginPrincipal, jobId: string) { return service.execute(principal, 'get_delivery', { jobId }); }
+   * ```
+   */
+  async execute(p, op, a) {
+    p = structuredClone(p);
+    a = structuredClone(a);
+    await this.allow(p, op, a);
+    if (!Object.hasOwn(validators, op) || !validators[op](a)) throw new PluginError(400, "Invalid delivery job");
+    const repo = this.options.repository, ports = this.options.ports, key = "delivery/" + a.jobId;
+    if (op === "enqueue_delivery") {
+      if (!a.commandId || !a.channel || !a.target || !["publish", "withdraw"].includes(a.kind ?? "") || !/^[a-f0-9]{64}$/.test(a.contentHash ?? "") || !a.approvalRequestId || JSON.stringify(a.target).length > 4e3) throw new PluginError(400, "Invalid delivery request");
+      await this.verify(p, a);
+      return repo.run(p, async (tx) => atomicCommand(tx, p, op, a, async () => {
+        const j = { jobId: a.jobId, channel: a.channel, kind: a.kind, target: a.target, contentHash: a.contentHash, approvalRequestId: a.approvalRequestId, requestedBy: p.userId, createdAt: (/* @__PURE__ */ new Date()).toISOString(), state: "queued", phase: a.kind === "publish" ? "build" : "activate", attempts: 0 };
+        const channel = "delivery-channel/" + atomicHash(j.channel), lock = await tx.get(channel);
+        if (lock?.value.jobId) throw new PluginError(409, "Channel has unfinished delivery");
+        await this.allow(p, op, a, j);
+        await tx.put(channel, { jobId: j.jobId }, lock?.revision ?? 0);
+        return tx.put(key, j, 0);
+      }));
+    }
+    const row = await repo.run(p, (tx) => tx.get(key));
+    if (!row) throw new PluginError(404, "Delivery unavailable");
+    await this.allow(p, op, a, row.value);
+    if (op === "get_delivery") return row;
+    if (op === "recover_delivery") {
+      if (row.revision !== a.revision || row.value.state !== "running" || await ports.drained?.(p, structuredClone(row.value)) !== true) throw new PluginError(409, "Recovery requires a drained worker at this revision");
+      return repo.run(p, async (tx) => {
+        await this.allow(p, op, a, row.value);
+        const j = { ...row.value, state: "failed" };
+        delete j.token;
+        return tx.put(key, j, row.revision);
+      });
+    }
+    if (["done", "cancelled"].includes(row.value.state)) {
+      if (op === "cancel_delivery" && row.value.state === "done") throw new PluginError(409, "Use a new withdrawal job for completed delivery");
+      return row;
+    }
+    if (row.value.state === "running") throw new PluginError(409, "Delivery worker already running");
+    if (op === "cancel_delivery" && !ports.cancel) throw new PluginError(409, "Cancellation reconciliation port unavailable");
+    if (op !== "cancel_delivery" && !["purge", "cancel"].includes(row.value.phase)) await this.verify(p, row.value);
+    let current = await repo.run(p, async (tx) => {
+      await this.allow(p, op, a, row.value);
+      return tx.put(key, { ...row.value, ...op === "cancel_delivery" ? { phase: "cancel" } : {}, state: "running", token: randomUUID2(), attempts: row.value.attempts + 1, error: void 0 }, row.revision);
+    });
+    try {
+      while (current.value.phase !== "done") {
+        const j = current.value;
+        await this.allow(p, op, a, j);
+        if (!["purge", "cancel"].includes(j.phase)) await this.verify(p, j);
+        let patch;
+        if (j.phase === "cancel") {
+          await this.allow(p, "cancel_delivery", a, j);
+          if (!ports.cancel) throw new PluginError(409, "Cancellation reconciliation port unavailable");
+          await ports.cancel(p, structuredClone(j));
+          patch = { phase: "done", state: "cancelled" };
+        } else if (j.phase === "build") {
+          const artifact = await ports.build(p, structuredClone(j));
+          if (!artifact || typeof artifact.key !== "string" || artifact.key.length > 1e3 || !/^[a-f0-9]{64}$/.test(artifact.contentHash) || !Number.isSafeInteger(artifact.bytes) || artifact.bytes < 1) throw new Error("Invalid delivery artifact");
+          patch = { artifact, phase: "activate" };
+        } else if (j.phase === "activate") {
+          await ports.activate(p, structuredClone(j));
+          patch = { phase: "purge" };
+        } else {
+          await ports.purge(p, structuredClone(j));
+          patch = { phase: "done", state: "done" };
+        }
+        current = await repo.run(p, async (tx) => {
+          await this.allow(p, op, a, j);
+          const saved = await tx.put(key, { ...j, ...patch }, current.revision);
+          if (patch.phase === "done") {
+            const ck = "delivery-channel/" + atomicHash(j.channel), lock = await tx.get(ck);
+            if (lock?.value.jobId !== j.jobId) throw new PluginError(409, "Delivery channel ownership changed");
+            await tx.put(ck, { jobId: null }, lock.revision);
+          }
+          return saved;
+        });
+      }
+      return current;
+    } catch (e) {
+      await repo.run(p, async (tx) => {
+        const fresh = await tx.get(key);
+        if (fresh && fresh.value.token === current.value.token && fresh.value.state === "running") await tx.put(key, { ...fresh.value, state: "failed", error: "Delivery step failed; inspect host logs and retry" }, fresh.revision);
+      });
+      throw e;
+    }
+  }
+};
+
+// src/plugin-data/index.ts
+function createMcpToolBinder(service, tools, key) {
+  return tools.map((tool) => ({ ...tool, handler: (args, context) => tool.handler(args, { ...context, [key]: service }) }));
+}
+function createMcpOperationHandler(operation, key) {
+  return async (args, context) => {
+    const service = context?.[key];
+    if (!service || typeof service.execute !== "function") throw new Error("Use createPlugin with verified principal");
+    return service.execute(context ?? {}, operation, args);
+  };
+}
+var PluginError = class extends Error {
+  /**
+   * Creates an intentional plugin failure with one supported client-facing HTTP status.
+   * @param status - Supported bad-input/authentication/permission/missing/conflict/gone HTTP status.
+   * @param message - Safe public error description exposed by createPluginRouter.
+   * 
+   * @example
+   * ```typescript
+   * import { PluginError } from '@alneas/eaos-server/plugin-data';
+   * const denied = new PluginError(403, 'Record access denied');
+   * ```
+   */
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+function storagePayload2(policy, value) {
+  try {
+    return assertPayloadWithinPolicy2(policy, value);
+  } catch (error) {
+    if (error instanceof Error && error.message === "Storage policy payload limit exceeded") throw new PluginError(409, error.message);
+    throw error;
+  }
+}
+function assertPrincipal(p) {
+  if (!p || typeof p.tenantId !== "string" || !p.tenantId.trim() || typeof p.userId !== "string" || !p.userId.trim() || !Array.isArray(p.roles) || p.roles.some((r) => typeof r !== "string")) throw new PluginError(401, "Authenticated principal required");
+}
+function createPluginRouter(resolvePrincipal, options = {}) {
+  const maxSize = options.maxBodyBytes ?? 128 * 1024;
+  if (!Number.isSafeInteger(maxSize) || maxSize < 1024 || maxSize > 8 * 1024 * 1024) throw Error("Invalid plugin request body bound");
+  const app = new Hono();
+  app.use("*", bodyLimit({ maxSize, onError: (c) => c.json({ error: "Request body too large" }, 413) }));
+  app.use("*", async (c, next) => {
+    const p = await resolvePrincipal(c);
+    if (!p) throw new PluginError(401, "Unauthorized");
+    assertPrincipal(p);
+    c.set("principal", p);
+    await next();
+  });
+  app.onError((e, c) => c.json({ error: e instanceof PluginError ? e.message : "Plugin operation failed" }, e instanceof PluginError ? e.status : 500));
+  return app;
+}
+function createStandardPluginServer(manifest, ServiceClass, bindTools, options, resolvePrincipal, configureRoutes, routerOptions) {
+  if (typeof resolvePrincipal !== "function") throw new Error("Verified principal resolver required");
+  const service = new ServiceClass(options), routes = createPluginRouter(resolvePrincipal, routerOptions);
+  configureRoutes?.(routes, service);
+  routes.post("/:operation", async (c) => c.json(await service.execute(c.get("principal"), c.req.param("operation"), await jsonBody(c))));
+  return { ...manifest, createRoutes: () => routes, mcp: { tools: bindTools(service) } };
+}
+async function jsonBody(c) {
+  if (!/^application\/json(?:;|$)/i.test(c.req.header("Content-Type") ?? "")) throw new PluginError(400, "JSON body required");
+  const value = await c.req.json().catch(() => null);
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new PluginError(400, "JSON object required");
+  return value;
+}
+function exactKeys(value, keys) {
+  if (Object.keys(value).some((k) => !keys.includes(k))) throw new PluginError(400, "Unknown input field");
+}
+function textInput(value, name, max = 256) {
+  if (typeof value !== "string" || !value.trim() || value.length > max) throw new PluginError(400, `Invalid ${name}`);
+  return value;
+}
+function revisionInput(value) {
+  if (!Number.isSafeInteger(value) || Number(value) < 1) throw new PluginError(400, "Revision required");
+  return Number(value);
+}
+function validateNamespace(namespace) {
+  if (!/^[a-z][a-z0-9_]{0,62}$/.test(namespace)) throw new Error("Invalid plugin storage namespace");
+  return `${namespace}:`;
+}
+function createSqlRecordStore(table, driver, options = {}) {
+  if (!/^[a-z][a-z0-9_]{0,62}$/.test(table)) throw new Error("Invalid plugin table");
+  const prefix = options.namespace ? validateNamespace(options.namespace) : "";
+  const storagePolicy = resolvePluginStoragePolicy2(options.storagePolicy);
+  const documents = options.documents && structuredClone(options.documents);
+  if (documents?.some((d) => d.table !== table || d.namespace !== options.namespace)) throw Error("JSON document storage binding differs");
+  const validateDocument = documents && createRecordDocumentValidator(documents);
+  const physicalId = (id2) => {
+    if (prefix && id2.length + prefix.length > 256) throw new PluginError(400, "Record id is too long for the shared plugin table");
+    return `${prefix}${id2}`;
+  };
+  const logicalId = (id2) => prefix ? id2.startsWith(prefix) ? id2.slice(prefix.length) : null : id2;
+  const bind = (i) => driver.dialect === "postgres" ? `$${i}` : driver.dialect === "oracle" ? `:${i}` : "?";
+  const decode = (tenant, row) => {
+    const id2 = logicalId(String(row.id ?? row.ID));
+    if (id2 === null || !id2) throw new Error("Record belongs to another plugin storage namespace");
+    const record = { id: id2, revision: Number(row.revision ?? row.REVISION), value: JSON.parse(String(row.payload ?? row.PAYLOAD)) };
+    validateDocument?.(tenant, record);
+    return record;
+  };
+  const listPage = async (tenant, limit, after = "") => {
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100) throw new PluginError(400, "Limit must be between 1 and 100");
+    if (after && (typeof after !== "string" || !/^[A-Za-z0-9_.:/-]{1,240}$/.test(after))) throw new PluginError(400, "Invalid page position");
+    const bindings = [tenant], filters = [`tenant_id = ${bind(1)}`];
+    if (prefix) {
+      bindings.push(prefix, prefix.slice(0, -1) + ";");
+      filters.push(`id >= ${bind(bindings.length - 1)} AND id < ${bind(bindings.length)}`);
+    }
+    if (after) {
+      bindings.push(physicalId(after));
+      filters.push(`id > ${bind(bindings.length)}`);
+    }
+    const tail = driver.dialect === "oracle" ? `FETCH FIRST ${limit} ROWS ONLY` : `LIMIT ${limit}`;
+    return (await driver.execute(tenant, `SELECT id, revision, payload FROM ${table} WHERE ${filters.join(" AND ")} ORDER BY id ${tail}`, bindings)).rows?.map((row) => decode(tenant, row)) ?? [];
+  };
+  return {
+    async read(tenant, id2) {
+      const result = await driver.execute(tenant, `SELECT id, revision, payload FROM ${table} WHERE tenant_id = ${bind(1)} AND id = ${bind(2)}`, [tenant, physicalId(id2)]);
+      return result.rows?.[0] ? decode(tenant, result.rows[0]) : null;
+    },
+    list: (tenant, limit) => listPage(tenant, limit),
+    listPage,
+    async create(tenant, record) {
+      if (validateDocument && record.revision !== 1) throw new PluginError(409, "New record revision must be 1");
+      validateDocument?.(tenant, record);
+      const payload = storagePayload2(storagePolicy, record.value);
+      try {
+        await driver.execute(tenant, `INSERT INTO ${table} (tenant_id, id, revision, payload) VALUES (${bind(1)}, ${bind(2)}, ${bind(3)}, ${bind(4)})`, [tenant, physicalId(record.id), record.revision, payload]);
+      } catch (error) {
+        if (["SQLITE_CONSTRAINT_PRIMARYKEY", "SQLITE_CONSTRAINT_UNIQUE", "23505", "ORA-00001"].includes(error?.code) || error?.errorNum === 1) throw new PluginError(409, "Record already exists");
+        throw error;
+      }
+    },
+    async replace(tenant, record, expected) {
+      if (!Number.isSafeInteger(expected) || expected < 1 || record.revision !== expected + 1) throw new Error("Invalid revision transition");
+      validateDocument?.(tenant, record);
+      const result = await driver.execute(tenant, `UPDATE ${table} SET revision = ${bind(1)}, payload = ${bind(2)} WHERE tenant_id = ${bind(3)} AND id = ${bind(4)} AND revision = ${bind(5)}`, [record.revision, storagePayload2(storagePolicy, record.value), tenant, physicalId(record.id), expected]);
+      if (typeof result.affectedRows !== "number") throw new Error("Record driver must report affectedRows");
+      return result.affectedRows === 1;
+    },
+    async delete(tenant, id2, expected) {
+      if (documents?.filter((d) => id2.startsWith(d.recordPrefix ?? "")).sort((a, b) => (b.recordPrefix ?? "").length - (a.recordPrefix ?? "").length)[0]?.immutable) throw new PluginError(409, "Immutable document cannot be deleted");
+      const hasRevision = typeof expected === "number";
+      const sql = hasRevision ? `DELETE FROM ${table} WHERE tenant_id = ${bind(1)} AND id = ${bind(2)} AND revision = ${bind(3)}` : `DELETE FROM ${table} WHERE tenant_id = ${bind(1)} AND id = ${bind(2)}`;
+      const bindings = hasRevision ? [tenant, physicalId(id2), expected] : [tenant, physicalId(id2)];
+      const result = await driver.execute(tenant, sql, bindings);
+      return (result.affectedRows ?? 0) >= 1;
+    }
+  };
+}
+function normalizeD1ConstraintError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (/UNIQUE constraint failed|PRIMARY KEY constraint failed|SQLITE_CONSTRAINT/i.test(message)) {
+    const constraintErr = new Error(message);
+    constraintErr.code = "SQLITE_CONSTRAINT_PRIMARYKEY";
+    throw constraintErr;
+  }
+  throw error instanceof Error ? error : new Error(message);
+}
+function createCloudflareD1Driver(options) {
+  const hasBinding = Boolean(options.binding && typeof options.binding.prepare === "function");
+  const hasHttp = Boolean(options.accountId?.trim() && options.databaseId?.trim() && options.apiToken?.trim());
+  if (!hasBinding && !hasHttp) {
+    throw new Error("Cloudflare D1 driver requires either a Worker D1 binding or accountId, databaseId, and apiToken");
+  }
+  const bootstrapTable = options.autoBootstrapTable;
+  if (bootstrapTable && !/^[a-z][a-z0-9_]{0,62}$/.test(bootstrapTable)) {
+    throw new Error("Invalid D1 bootstrap table name");
+  }
+  const fetcher = options.fetch ?? globalThis.fetch;
+  const apiBase = (options.apiBaseUrl ?? "https://api.cloudflare.com/client/v4").replace(/\/$/, "");
+  let bootstrapped = !bootstrapTable;
+  const runRaw = async (sql, bindings) => {
+    const isSelect = /^\s*SELECT\b/i.test(sql);
+    try {
+      if (hasBinding && options.binding) {
+        const stmt = options.binding.prepare(sql).bind(...bindings);
+        if (isSelect) {
+          const res2 = await stmt.all();
+          return { rows: res2.results ?? [], affectedRows: res2.meta?.changes ?? 0 };
+        }
+        const res = await stmt.run();
+        return { rows: [], affectedRows: res.meta?.changes ?? 0 };
+      }
+      const url = `${apiBase}/accounts/${encodeURIComponent(options.accountId)}/d1/database/${encodeURIComponent(options.databaseId)}/query`;
+      const response = await fetcher(url, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${options.apiToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ sql, params: bindings })
+      });
+      const body = await response.json().catch(() => null);
+      if (!response.ok || !body?.success) {
+        const errMsg = body?.errors?.map((e) => e.message).filter(Boolean).join("; ") || `D1 HTTP query failed (${response.status})`;
+        return normalizeD1ConstraintError(new Error(errMsg));
+      }
+      const first = body.result?.[0];
+      return {
+        rows: first?.results ?? [],
+        affectedRows: typeof first?.meta?.changes === "number" ? first.meta.changes : 0
+      };
+    } catch (error) {
+      return normalizeD1ConstraintError(error);
+    }
+  };
+  return {
+    dialect: "sqlite",
+    async execute(_tenantId, sql, bindings) {
+      if (!bootstrapped && bootstrapTable) {
+        await runRaw(
+          `CREATE TABLE IF NOT EXISTS ${bootstrapTable} (tenant_id TEXT NOT NULL, id TEXT NOT NULL, revision INTEGER NOT NULL, payload TEXT NOT NULL, PRIMARY KEY (tenant_id, id))`,
+          []
+        );
+        bootstrapped = true;
+      }
+      return runRaw(sql, bindings);
+    }
+  };
+}
+function createPluginRecordStore(manifest, driver, catalog) {
+  const storage = manifest.schema.storage;
+  if (storage) {
+    if (!catalog) throw Error("Contract-backed record storage requires a trusted schema catalog");
+    const documents = recordDocuments(catalog, storage);
+    return createSqlRecordStore(storage.table, driver, { namespace: storage.namespace, storagePolicy: manifest.schema.storagePolicy, ...documents?.length ? { documents } : {} });
+  }
+  if (manifest.schema.ownedTables.length !== 1) throw new Error("Plugin manifest must declare one storage table or shared storage metadata");
+  return createSqlRecordStore(manifest.schema.ownedTables[0], driver, { storagePolicy: manifest.schema.storagePolicy });
+}
+
+// src/plugin-data/json-documents.ts
+function createValidatedRecordHost(host, documents) {
+  const copy = { ...host };
+  if (host.store) copy.store = createValidatedRecordStore(host.store, documents);
+  if (host.repository) copy.repository = createValidatedAtomicRepository(host.repository, documents);
+  if (host.transaction) {
+    const transaction = host.transaction.bind(host);
+    copy.transaction = (principal, work) => transaction(principal, (store) => work(createValidatedRecordStore(store, documents)));
+  }
+  return new Proxy(copy, { get(target, key, receiver) {
+    if (key === "store" || key === "repository" || key === "transaction") return Reflect.get(target, key, receiver);
+    const value = Reflect.get(host, key, host);
+    return typeof value === "function" ? value.bind(host) : value;
+  } });
+}
+function recordDocuments(catalog, binding) {
+  assertDataContractBinding(catalog, binding);
+  const columns = catalog.tables.find((t) => t.name === binding.table).schema.properties;
+  if (!columns.id || !columns.revision || !columns.payload) throw Error("Record stores require an envelope table with id, revision and payload");
+  const documents = catalog.contracts.find((c) => c.id === binding.contractId).jsonDocuments?.filter((d) => d.table === binding.table && d.column === "payload" && d.namespace === binding.namespace) ?? [];
+  if (binding.jsonDocuments !== void 0 && (!binding.jsonDocuments.length || new Set(binding.jsonDocuments).size !== binding.jsonDocuments.length || binding.jsonDocuments.some((id2) => !documents.some((d) => d.id === id2)))) throw Error("Declared JSON document contract is unavailable for this storage binding");
+  return documents;
+}
+function createRecordDocumentValidator(documents) {
+  if (!documents.length) throw Error("Record document contracts are required");
+  const routes = documents.map((document) => {
+    const copy = structuredClone(document);
+    if (copy.column !== "payload" || copy.schema.type !== "object" || copy.schema.additionalProperties !== false) throw Error("Closed payload document contract required");
+    return { document: copy, validate: createJsonDocumentAssertion(copy) };
+  }).sort((a, b) => (b.document.recordPrefix ?? "").length - (a.document.recordPrefix ?? "").length);
+  const prefixes = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    const prefix = route.document.recordPrefix ?? "";
+    if (prefixes.has(prefix)) throw Error("Ambiguous record document route");
+    prefixes.add(prefix);
+  }
+  return (tenantId, record) => {
+    assertBusinessId(tenantId);
+    assertBusinessId(record.id);
+    if (!Number.isSafeInteger(record.revision) || record.revision < 1) throw new PluginError(409, "Invalid record revision");
+    const route = routes.find((r) => record.id.startsWith(r.document.recordPrefix ?? ""));
+    if (!route) throw new PluginError(409, "Record document contract unavailable");
+    if (route.document.immutable && record.revision !== 1) throw new PluginError(409, "Immutable document cannot be replaced");
+    try {
+      route.validate(record.value);
+    } catch {
+      throw new PluginError(409, `Record differs from JSON contract ${route.document.id}@${route.document.version}`);
+    }
+    const value = record.value;
+    if (Object.hasOwn(value, "tenantId") && value.tenantId !== tenantId) throw new PluginError(409, "JSON document tenant differs");
+  };
+}
+function createValidatedRecordStore(store, documents) {
+  const ownedDocuments = structuredClone(documents);
+  const validate = createRecordDocumentValidator(ownedDocuments);
+  const check = (tenant, row) => {
+    validate(tenant, row);
+    return row;
+  };
+  return {
+    async read(tenant, id2) {
+      const row = await store.read(tenant, id2);
+      if (row && row.id !== id2) throw new PluginError(409, "Record identity differs");
+      return row && check(tenant, row);
+    },
+    async list(tenant, limit) {
+      return (await store.list(tenant, limit)).map((row) => check(tenant, row));
+    },
+    ...store.listPage ? { async listPage(tenant, limit, after) {
+      return (await store.listPage(tenant, limit, after)).map((row) => check(tenant, row));
+    } } : {},
+    async create(tenant, row) {
+      if (row.revision !== 1) throw new PluginError(409, "New record revision must be 1");
+      validate(tenant, row);
+      await store.create(tenant, row);
+    },
+    async replace(tenant, row, expected) {
+      if (!Number.isSafeInteger(expected) || expected < 1 || row.revision !== expected + 1) throw new PluginError(409, "Invalid revision transition");
+      validate(tenant, row);
+      return store.replace(tenant, row, expected);
+    },
+    ...store.delete ? { delete: async (tenant, id2, expected) => {
+      const immutable = [...ownedDocuments].sort((a, b) => (b.recordPrefix ?? "").length - (a.recordPrefix ?? "").length).find((d) => id2.startsWith(d.recordPrefix ?? ""))?.immutable;
+      if (immutable) throw new PluginError(409, "Immutable document cannot be deleted");
+      return store.delete(tenant, id2, expected);
+    } } : {}
+  };
+}
+function createValidatedAtomicRepository(repository, documents) {
+  const validate = createRecordDocumentValidator(structuredClone(documents));
+  return { async run(principal, work) {
+    assertPrincipal(principal);
+    const p = structuredClone(principal);
+    return repository.run(p, async (source) => {
+      let active = true;
+      const check = () => {
+        if (!active) throw Error("Transaction session expired");
+      };
+      const read = (row, id2) => {
+        check();
+        if (row) {
+          if (id2 !== void 0 && row.id !== id2) throw Error("Record identity differs");
+          validate(p.tenantId, row);
+        }
+        return row;
+      };
+      const preflight = (id2, value, expected) => {
+        check();
+        if (!Number.isSafeInteger(expected) || expected < 0 || expected >= Number.MAX_SAFE_INTEGER) throw Error("Invalid expected revision");
+        const row = { id: id2, value: structuredClone(value), revision: expected + 1 };
+        validate(p.tenantId, row);
+        return row;
+      };
+      const session = {
+        async get(id2) {
+          check();
+          return read(await source.get(id2), id2);
+        },
+        async list(prefix, after, limit) {
+          check();
+          const rows = await source.list(prefix, after, limit);
+          return rows.map((row) => {
+            if (!row.id.startsWith(prefix)) throw Error("Record list scope differs");
+            return read(row);
+          });
+        },
+        async put(id2, value, expected) {
+          const row = preflight(id2, value, expected);
+          const saved = read(await source.put(id2, row.value, expected), id2);
+          if (saved.revision !== row.revision) throw Error("Saved revision differs");
+          return saved;
+        },
+        ...source.getMany ? { async getMany(ids) {
+          check();
+          const rows = await source.getMany(ids);
+          if (rows.length !== ids.length) throw Error("Batch read length differs");
+          return rows.map((row, i) => read(row, ids[i]));
+        } } : {},
+        ...source.putMany ? { async putMany(changes) {
+          check();
+          if (new Set(changes.map((c) => c.id)).size !== changes.length) throw Error("Duplicate batch record key");
+          const rows = changes.map((c) => preflight(c.id, c.value, c.expected));
+          const saved = await source.putMany(changes.map((c, i) => ({ ...c, value: rows[i].value })));
+          if (saved.length !== rows.length) throw Error("Batch write length differs");
+          return saved.map((row, i) => {
+            const result = read(row, rows[i].id);
+            if (result.revision !== rows[i].revision) throw Error("Saved revision differs");
+            return result;
+          });
+        } } : {}
+      };
+      const release = inheritAtomicSqlSession(source, session);
+      try {
+        return await work(session);
+      } finally {
+        active = false;
+        release();
+      }
+    });
+  } };
+}
+
+export {
+  createValidatedRecordHost,
+  recordDocuments,
+  createRecordDocumentValidator,
+  createValidatedRecordStore,
+  createValidatedAtomicRepository,
+  RecordCommandService,
+  appendAtomicAudit,
+  readAtomicAudit,
+  verifyAtomicAudit,
+  joinedAtomicSqlExecutor,
+  atomicHash,
+  atomicCommand,
+  recordCursor,
+  parseRecordCursor,
+  createAtomicRepository,
+  createAtomicRecordStore,
+  createPluginAtomicRepository,
+  createSqliteAtomicDriver,
+  createOracleAtomicDriver,
+  enqueueOutboxEvent,
+  createAtomicWorkflowEventSink,
+  createAtomicOutboxStore,
+  createAtomicOutboxDispatcher,
+  requeueOutboxEvent,
+  uniqueRecordKey,
+  ScopedRecordService,
+  createCompositePluginService,
+  annotationOperations,
+  annotationSchemas,
+  documentAnnotations,
+  deliveryOperations,
+  enqueueDeliverySchema,
+  deliveryJobSchema,
+  recoverDeliverySchema,
+  ArtifactDeliveryService,
+  createMcpToolBinder,
+  createMcpOperationHandler,
+  PluginError,
+  assertPrincipal,
+  createPluginRouter,
+  createStandardPluginServer,
+  jsonBody,
+  exactKeys,
+  textInput,
+  revisionInput,
+  createSqlRecordStore,
+  createCloudflareD1Driver,
+  createPluginRecordStore
+};
+//# sourceMappingURL=chunk-INCHXAFK.js.map