@creatornader/agent-bridge 0.2.0 → 0.3.1

package/dist/chunk-A6W4QALF.js

@@ -0,0 +1,1258 @@
+#!/usr/bin/env node
+import {
+  securePrivatePath,
+  verifyPrivatePathAccess
+} from "./chunk-NCO7RLBM.js";
+import {
+  validateMessageDraft,
+  validatePrincipal
+} from "./chunk-BZLMF5O5.js";
+
+// src/portable-archive-format.ts
+import { createHash } from "crypto";
+var PORTABLE_ARCHIVE_FORMAT = "agent-bridge.portable-archive";
+var PORTABLE_ARCHIVE_VERSION = 1;
+var PORTABLE_ARCHIVE_MAX_LINE_BYTES = 1024 * 1024;
+var PORTABLE_ARCHIVE_MAX_BYTES = 256 * 1024 * 1024;
+var PORTABLE_ARCHIVE_BATCH_BYTES = 4 * 1024 * 1024;
+var PORTABLE_ARCHIVE_BATCH_ROWS = 1e3;
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+var REQUEST_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var CANONICAL_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}Z$/;
+var PortableArchiveError = class extends Error {
+  constructor(message3) {
+    super(message3);
+    this.code = "invalid_portable_archive";
+  }
+};
+function assertUnicode(value) {
+  if (value.includes("\0")) throw new PortableArchiveError("archive strings must not contain U+0000");
+  for (let index = 0; index < value.length; index += 1) {
+    const unit = value.charCodeAt(index);
+    if (unit >= 55296 && unit <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 56320 && next <= 57343)) throw new PortableArchiveError("archive contains a lone surrogate");
+      index += 1;
+    } else if (unit >= 56320 && unit <= 57343) {
+      throw new PortableArchiveError("archive contains a lone surrogate");
+    }
+  }
+}
+function canonicalJson(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    if (typeof value === "string") assertUnicode(value);
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new PortableArchiveError("archive contains a non-finite number");
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (typeof value !== "object" || value === void 0) throw new PortableArchiveError("archive contains a non-JSON value");
+  const object = value;
+  return `{${Object.keys(object).sort().map((key) => {
+    assertUnicode(key);
+    return `${JSON.stringify(key)}:${canonicalJson(object[key])}`;
+  }).join(",")}}`;
+}
+function normalizeArchiveTimestamp(value, field) {
+  if (typeof value !== "string") throw new PortableArchiveError(`${field} must be a timestamp`);
+  const match = value.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,6}))?(Z|[+-]\d{2}:\d{2})$/);
+  if (!match) throw new PortableArchiveError(`${field} must be RFC 3339 with an explicit offset`);
+  if (match[1].startsWith("0000-")) throw new PortableArchiveError(`${field} year must be between 0001 and 9999`);
+  const milliseconds = (match[2] ?? "").padEnd(3, "0").slice(0, 3);
+  const parsed = /* @__PURE__ */ new Date(`${match[1]}.${milliseconds}${match[3]}`);
+  if (Number.isNaN(parsed.getTime())) throw new PortableArchiveError(`${field} is invalid`);
+  const converted = parsed.toISOString();
+  if (!/^\d{4}-/.test(converted) || converted.startsWith("0000-")) throw new PortableArchiveError(`${field} conversion must remain between years 0001 and 9999`);
+  const canonicalPrefix = converted.slice(0, 19);
+  const micros = (match[2] ?? "").padEnd(6, "0");
+  return `${canonicalPrefix}.${micros}Z`;
+}
+function exactObject(value, keys, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new PortableArchiveError(`${label} must be an object`);
+  const object = value;
+  const actual = Object.keys(object).sort();
+  const expected = [...keys].sort();
+  if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
+    throw new PortableArchiveError(`${label} has unexpected fields`);
+  }
+  return object;
+}
+var MESSAGE_KEYS = [
+  "atribReceiptId",
+  "causationId",
+  "content",
+  "contentType",
+  "correlationId",
+  "createdAt",
+  "data",
+  "deliveryPolicy",
+  "expiresAt",
+  "id",
+  "idempotencyKey",
+  "informedBy",
+  "metadata",
+  "priority",
+  "project",
+  "replyToId",
+  "source",
+  "targets",
+  "threadId",
+  "type"
+];
+function validateArchiveWorkspace(value) {
+  if (typeof value !== "string" || value !== value.trim() || value.length < 1 || value.length > 128) {
+    throw new PortableArchiveError("workspace must be trimmed and between 1 and 128 characters");
+  }
+  assertUnicode(value);
+  return value;
+}
+function validatePortableArchiveRequestId(value) {
+  if (typeof value !== "string" || value !== value.trim() || !REQUEST_UUID.test(value)) {
+    throw new PortableArchiveError("archive exportRequestId must be a UUID");
+  }
+  return value.toLowerCase();
+}
+function string(value, field, nullable3 = false) {
+  if (nullable3 && value === null) return null;
+  if (typeof value !== "string") throw new PortableArchiveError(`${field} must be a string${nullable3 ? " or null" : ""}`);
+  assertUnicode(value);
+  return value;
+}
+function json(value, field) {
+  if (value === null) return null;
+  try {
+    canonicalJson(value);
+  } catch {
+    throw new PortableArchiveError(`${field} must be JSON`);
+  }
+  return value;
+}
+function stringArray(value, field) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) throw new PortableArchiveError(`${field} must be a string array`);
+  value.forEach((entry) => assertUnicode(entry));
+  return value;
+}
+function parsePortableArchiveMessage(value) {
+  const object = exactObject(value, MESSAGE_KEYS, "message");
+  const id = string(object.id, "message.id");
+  if (!UUID.test(id)) throw new PortableArchiveError("message.id must be a UUID");
+  const priority = string(object.priority, "message.priority");
+  if (!["info", "high", "urgent"].includes(priority)) throw new PortableArchiveError("message.priority is invalid");
+  const deliveryPolicy = object.deliveryPolicy;
+  if (!deliveryPolicy || typeof deliveryPolicy !== "object" || Array.isArray(deliveryPolicy)) throw new PortableArchiveError("message.deliveryPolicy must be an object");
+  const policy = deliveryPolicy;
+  if (policy.mode === "mailbox") {
+    exactObject(policy, ["mode"], "message.deliveryPolicy");
+  } else if (policy.mode === "leased") {
+    const keys = Object.keys(policy);
+    exactObject(policy, policy.notBefore === void 0 ? ["maxAttempts", "mode", "retryBaseDelayMs", "retryJitterRatio", "retryMaxDelayMs"] : ["maxAttempts", "mode", "notBefore", "retryBaseDelayMs", "retryJitterRatio", "retryMaxDelayMs"], "message.deliveryPolicy");
+    if (!Number.isSafeInteger(policy.maxAttempts) || Number(policy.maxAttempts) < 1 || Number(policy.maxAttempts) > 100 || !Number.isSafeInteger(policy.retryBaseDelayMs) || Number(policy.retryBaseDelayMs) < 1 || Number(policy.retryBaseDelayMs) > 36e5 || !Number.isSafeInteger(policy.retryMaxDelayMs) || Number(policy.retryMaxDelayMs) < Number(policy.retryBaseDelayMs) || Number(policy.retryMaxDelayMs) > 864e5 || typeof policy.retryJitterRatio !== "number" || !Number.isFinite(policy.retryJitterRatio) || Number(policy.retryJitterRatio) < 0 || Number(policy.retryJitterRatio) > 1 || keys.length < 5) {
+      throw new PortableArchiveError("message.deliveryPolicy is invalid");
+    }
+  } else throw new PortableArchiveError("message.deliveryPolicy.mode is invalid");
+  const createdAt = string(object.createdAt, "message.createdAt");
+  if (!CANONICAL_TIMESTAMP.test(createdAt) || normalizeArchiveTimestamp(createdAt, "message.createdAt") !== createdAt) throw new PortableArchiveError("message.createdAt is not canonical");
+  const expiresAt = string(object.expiresAt, "message.expiresAt", true);
+  if (expiresAt !== null && (!CANONICAL_TIMESTAMP.test(expiresAt) || normalizeArchiveTimestamp(expiresAt, "message.expiresAt") !== expiresAt)) throw new PortableArchiveError("message.expiresAt is not canonical");
+  const notBefore = policy.notBefore;
+  if (notBefore !== void 0 && (typeof notBefore !== "string" || !CANONICAL_TIMESTAMP.test(notBefore) || normalizeArchiveTimestamp(notBefore, "message.deliveryPolicy.notBefore") !== notBefore)) throw new PortableArchiveError("message.deliveryPolicy.notBefore is not canonical");
+  const targets = stringArray(object.targets, "message.targets");
+  if (policy.mode === "leased" && targets.length === 0) throw new PortableArchiveError("leased delivery requires at least one target");
+  if (typeof notBefore === "string" && expiresAt !== null && notBefore >= expiresAt) throw new PortableArchiveError("delivery notBefore must be before expiresAt");
+  const project = string(object.project, "message.project", true);
+  const source = string(object.source, "message.source");
+  const type = string(object.type, "message.type");
+  const content = string(object.content, "message.content");
+  const contentType = string(object.contentType, "message.contentType");
+  const data = json(object.data, "message.data");
+  const threadId = string(object.threadId, "message.threadId", true);
+  const replyToId = string(object.replyToId, "message.replyToId", true);
+  const correlationId = string(object.correlationId, "message.correlationId", true);
+  const causationId = string(object.causationId, "message.causationId", true);
+  const idempotencyKey = string(object.idempotencyKey, "message.idempotencyKey", true);
+  const atribReceiptId = string(object.atribReceiptId, "message.atribReceiptId", true);
+  const informedBy = stringArray(object.informedBy, "message.informedBy");
+  const metadata = json(object.metadata, "message.metadata");
+  const parsedPolicy = deliveryPolicy;
+  let normalized;
+  try {
+    const principal = validatePrincipal({ workspace: "archive", agent: source });
+    if (principal.agent !== source) throw new Error("message.source is not canonical");
+    normalized = validateMessageDraft({
+      id,
+      project: project ?? void 0,
+      type,
+      content,
+      contentType,
+      data,
+      targets,
+      threadId: threadId ?? void 0,
+      replyToId: replyToId ?? void 0,
+      correlationId: correlationId ?? void 0,
+      causationId: causationId ?? void 0,
+      priority,
+      expiresAt: expiresAt ?? void 0,
+      idempotencyKey: idempotencyKey ?? void 0,
+      atribReceiptId: atribReceiptId ?? void 0,
+      informedBy,
+      metadata,
+      deliveryPolicy: parsedPolicy
+    });
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "invalid message";
+    throw new PortableArchiveError(`message violates Agent Bridge domain constraints: ${reason}`);
+  }
+  const normalizedPolicy = normalized.deliveryPolicy.mode === "leased" && parsedPolicy.mode === "leased" && parsedPolicy.notBefore ? { ...normalized.deliveryPolicy, notBefore: parsedPolicy.notBefore } : normalized.deliveryPolicy;
+  const actual = {
+    project,
+    type,
+    content,
+    contentType,
+    data,
+    targets,
+    threadId,
+    replyToId,
+    correlationId,
+    causationId,
+    priority,
+    idempotencyKey,
+    atribReceiptId,
+    informedBy,
+    metadata,
+    deliveryPolicy: parsedPolicy
+  };
+  const expected = {
+    project: normalized.project ?? null,
+    type: normalized.type,
+    content: normalized.content,
+    contentType: normalized.contentType,
+    data: normalized.data ?? null,
+    targets: normalized.targets,
+    threadId: normalized.threadId ?? null,
+    replyToId: normalized.replyToId ?? null,
+    correlationId: normalized.correlationId ?? null,
+    causationId: normalized.causationId ?? null,
+    priority: normalized.priority,
+    idempotencyKey: normalized.idempotencyKey ?? null,
+    atribReceiptId: normalized.atribReceiptId ?? null,
+    informedBy: normalized.informedBy ?? [],
+    metadata: normalized.metadata ?? null,
+    deliveryPolicy: normalizedPolicy
+  };
+  if (normalized.id !== id || canonicalJson(actual) !== canonicalJson(expected)) {
+    throw new PortableArchiveError("message is not in canonical Agent Bridge domain form");
+  }
+  return {
+    id,
+    project,
+    source,
+    type,
+    content,
+    contentType,
+    data,
+    targets,
+    threadId,
+    replyToId,
+    correlationId,
+    causationId,
+    priority,
+    expiresAt,
+    idempotencyKey,
+    atribReceiptId,
+    informedBy,
+    metadata,
+    deliveryPolicy: parsedPolicy,
+    createdAt
+  };
+}
+function parsePortableArchiveReceipt(value) {
+  const object = exactObject(value, ["messageId", "principal", "readAt"], "receipt");
+  const messageId = string(object.messageId, "receipt.messageId");
+  if (!UUID.test(messageId)) throw new PortableArchiveError("receipt.messageId must be a UUID");
+  const readAt = string(object.readAt, "receipt.readAt");
+  if (!CANONICAL_TIMESTAMP.test(readAt) || normalizeArchiveTimestamp(readAt, "receipt.readAt") !== readAt) throw new PortableArchiveError("receipt.readAt is not canonical");
+  const principal = string(object.principal, "receipt.principal");
+  if (principal !== principal.trim() || principal.length < 1 || principal.length > 128) throw new PortableArchiveError("receipt.principal is invalid");
+  return { messageId, principal, readAt };
+}
+function encodePortableArchive(contents) {
+  const requestId = validatePortableArchiveRequestId(contents.exportRequestId);
+  const workspace = validateArchiveWorkspace(contents.workspace);
+  const messages = contents.messages.map(parsePortableArchiveMessage).sort((left, right) => left.createdAt < right.createdAt ? -1 : left.createdAt > right.createdAt ? 1 : left.id < right.id ? -1 : left.id > right.id ? 1 : 0);
+  if (new Set(messages.map((message3) => message3.id)).size !== messages.length) throw new PortableArchiveError("duplicate message id");
+  const messagesById = new Map(messages.map((message3) => [message3.id, message3]));
+  const byMessage = /* @__PURE__ */ new Map();
+  for (const receipt3 of contents.receipts.map(parsePortableArchiveReceipt)) {
+    const receiptMessage = messagesById.get(receipt3.messageId);
+    if (!receiptMessage) throw new PortableArchiveError("receipt references a missing message");
+    if (receiptMessage.targets.length > 0 && !receiptMessage.targets.includes(receipt3.principal)) throw new PortableArchiveError("receipt principal is not eligible for the message");
+    const list = byMessage.get(receipt3.messageId) ?? [];
+    if (list.some((entry) => entry.principal === receipt3.principal)) throw new PortableArchiveError("duplicate receipt");
+    list.push(receipt3);
+    byMessage.set(receipt3.messageId, list);
+  }
+  const lines = [canonicalJson({ exportRequestId: requestId, format: PORTABLE_ARCHIVE_FORMAT, kind: "header", version: PORTABLE_ARCHIVE_VERSION, workspace })];
+  for (const message3 of messages) {
+    lines.push(canonicalJson({ kind: "message", message: message3 }));
+    for (const receipt3 of (byMessage.get(message3.id) ?? []).sort((left, right) => left.principal < right.principal ? -1 : left.principal > right.principal ? 1 : 0)) lines.push(canonicalJson({ kind: "receipt", receipt: receipt3 }));
+  }
+  if (lines.some((line) => Buffer.byteLength(line) > PORTABLE_ARCHIVE_MAX_LINE_BYTES)) throw new PortableArchiveError("archive line exceeds 1 MiB");
+  const body = Buffer.from(`${lines.join("\n")}
+`, "utf8");
+  const digest = `sha256:${createHash("sha256").update(body).digest("hex")}`;
+  const footer = canonicalJson({ digest, kind: "footer", messages: messages.length, receipts: contents.receipts.length });
+  const result = Buffer.concat([body, Buffer.from(`${footer}
+`, "utf8")]);
+  if (result.length > PORTABLE_ARCHIVE_MAX_BYTES) throw new PortableArchiveError("archive exceeds maximum size");
+  return result;
+}
+function decodePortableArchive(input) {
+  const bytes = Buffer.from(input);
+  if (!bytes.length || bytes.length > PORTABLE_ARCHIVE_MAX_BYTES) throw new PortableArchiveError("archive size is invalid");
+  if (bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) throw new PortableArchiveError("archive must not contain a BOM");
+  if (bytes[bytes.length - 1] !== 10 || bytes.includes(13) || bytes.includes(0)) throw new PortableArchiveError("archive must use UTF-8 and LF framing");
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new PortableArchiveError("archive is not valid UTF-8");
+  }
+  const lines = text.slice(0, -1).split("\n");
+  if (lines.length < 2 || lines.some((line) => !line || Buffer.byteLength(line) > PORTABLE_ARCHIVE_MAX_LINE_BYTES)) throw new PortableArchiveError("archive contains an invalid line");
+  const records = lines.map((line) => {
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch {
+      throw new PortableArchiveError("archive contains invalid JSON");
+    }
+    if (canonicalJson(value) !== line) throw new PortableArchiveError("archive contains noncanonical JSON");
+    return value;
+  });
+  const header = exactObject(records[0], ["exportRequestId", "format", "kind", "version", "workspace"], "header");
+  if (header.kind !== "header" || header.format !== PORTABLE_ARCHIVE_FORMAT || header.version !== PORTABLE_ARCHIVE_VERSION) throw new PortableArchiveError("unsupported archive header");
+  const requestId = validatePortableArchiveRequestId(header.exportRequestId);
+  if (requestId !== header.exportRequestId) throw new PortableArchiveError("archive header exportRequestId is not canonical");
+  const workspace = validateArchiveWorkspace(header.workspace);
+  const footer = exactObject(records[records.length - 1], ["digest", "kind", "messages", "receipts"], "footer");
+  if (footer.kind !== "footer" || typeof footer.digest !== "string" || !Number.isSafeInteger(footer.messages) || Number(footer.messages) < 0 || !Number.isSafeInteger(footer.receipts) || Number(footer.receipts) < 0) throw new PortableArchiveError("invalid archive footer");
+  const footerOffset = Buffer.byteLength(`${lines.slice(0, -1).join("\n")}
+`);
+  const digest = `sha256:${createHash("sha256").update(bytes.subarray(0, footerOffset)).digest("hex")}`;
+  if (footer.digest !== digest) throw new PortableArchiveError("archive digest mismatch");
+  const messages = [];
+  const receipts = [];
+  const ids = /* @__PURE__ */ new Set();
+  const receiptKeys = /* @__PURE__ */ new Set();
+  let currentMessage;
+  let previousMessageKey = "";
+  let previousPrincipal = "";
+  for (const raw of records.slice(1, -1)) {
+    const record = raw;
+    if (record.kind === "message") {
+      exactObject(record, ["kind", "message"], "message record");
+      const message3 = parsePortableArchiveMessage(record.message);
+      const orderKey = `${message3.createdAt}\0${message3.id}`;
+      if (orderKey <= previousMessageKey || ids.has(message3.id)) throw new PortableArchiveError("messages are duplicated or out of order");
+      previousMessageKey = orderKey;
+      currentMessage = message3;
+      previousPrincipal = "";
+      ids.add(message3.id);
+      messages.push(message3);
+    } else if (record.kind === "receipt") {
+      exactObject(record, ["kind", "receipt"], "receipt record");
+      const receipt3 = parsePortableArchiveReceipt(record.receipt);
+      if (!currentMessage || receipt3.messageId !== currentMessage.id || receipt3.principal <= previousPrincipal) throw new PortableArchiveError("receipts are out of order or not adjacent to their message");
+      if (currentMessage.targets.length > 0 && !currentMessage.targets.includes(receipt3.principal)) throw new PortableArchiveError("receipt principal is not eligible for the message");
+      const key = `${receipt3.messageId}\0${receipt3.principal}`;
+      if (receiptKeys.has(key)) throw new PortableArchiveError("duplicate receipt");
+      previousPrincipal = receipt3.principal;
+      receiptKeys.add(key);
+      receipts.push(receipt3);
+    } else throw new PortableArchiveError("unknown archive record kind");
+  }
+  if (messages.length !== footer.messages || receipts.length !== footer.receipts) throw new PortableArchiveError("archive counts do not match footer");
+  return { exportRequestId: requestId, workspace, messages, receipts, digest };
+}
+
+// src/portable-archive-file.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  closeSync,
+  constants,
+  fstatSync,
+  fsyncSync,
+  lstatSync,
+  openSync,
+  readSync
+} from "fs";
+import { dirname, resolve } from "path";
+function exact(value, fields, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new PortableArchiveError(`${label} must be an object`);
+  const record = value;
+  const actual = Object.keys(record).sort();
+  const expected = [...fields].sort();
+  if (actual.length !== expected.length || actual.some((field, index) => field !== expected[index])) throw new PortableArchiveError(`${label} has unexpected fields`);
+  return record;
+}
+function parseLine(bytes, lineNumber) {
+  if (!bytes.length || bytes.length > PORTABLE_ARCHIVE_MAX_LINE_BYTES || bytes.includes(13) || bytes.includes(0)) {
+    throw new PortableArchiveError(`archive line ${lineNumber} is invalid`);
+  }
+  if (lineNumber === 1 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) throw new PortableArchiveError("archive must not contain a BOM");
+  let line;
+  try {
+    line = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new PortableArchiveError(`archive line ${lineNumber} is not valid UTF-8`);
+  }
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    throw new PortableArchiveError(`archive line ${lineNumber} contains invalid JSON`);
+  }
+  if (canonicalJson(value) !== line) throw new PortableArchiveError(`archive line ${lineNumber} contains noncanonical JSON`);
+  const outer = value;
+  let record;
+  if (outer.kind === "header") {
+    const header = exact(value, ["exportRequestId", "format", "kind", "version", "workspace"], "header");
+    if (header.format !== PORTABLE_ARCHIVE_FORMAT || header.version !== PORTABLE_ARCHIVE_VERSION) throw new PortableArchiveError("unsupported archive header");
+    const requestId = validatePortableArchiveRequestId(header.exportRequestId);
+    if (requestId !== header.exportRequestId) throw new PortableArchiveError("archive header exportRequestId is not canonical");
+    record = { kind: "header", requestId, workspace: validateArchiveWorkspace(header.workspace) };
+  } else if (outer.kind === "message") {
+    const wrapped = exact(value, ["kind", "message"], "message record");
+    record = { kind: "message", message: parsePortableArchiveMessage(wrapped.message) };
+  } else if (outer.kind === "receipt") {
+    const wrapped = exact(value, ["kind", "receipt"], "receipt record");
+    record = { kind: "receipt", receipt: parsePortableArchiveReceipt(wrapped.receipt) };
+  } else if (outer.kind === "footer") {
+    const footer = exact(value, ["digest", "kind", "messages", "receipts"], "footer");
+    if (typeof footer.digest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(footer.digest) || !Number.isSafeInteger(footer.messages) || Number(footer.messages) < 0 || !Number.isSafeInteger(footer.receipts) || Number(footer.receipts) < 0) throw new PortableArchiveError("invalid archive footer");
+    record = { kind: "footer", digest: footer.digest, messages: Number(footer.messages), receipts: Number(footer.receipts) };
+  } else throw new PortableArchiveError(`archive line ${lineNumber} has an unknown record kind`);
+  return { raw: bytes, record };
+}
+function sameFile(left, right) {
+  return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+}
+var PortableArchiveFile = class {
+  constructor(path) {
+    this.closed = false;
+    const target = resolve(path);
+    this.path = target;
+    verifyPrivatePathAccess(dirname(target), "directory");
+    verifyPrivatePathAccess(target, "file");
+    const before = lstatSync(target);
+    const noFollow = typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0;
+    this.descriptor = openSync(target, constants.O_RDWR | noFollow);
+    try {
+      this.identity = fstatSync(this.descriptor);
+      const after = lstatSync(target);
+      if (!this.identity.isFile() || before.isSymbolicLink() || !sameFile(before, this.identity) || !sameFile(after, this.identity)) {
+        throw new PortableArchiveError("archive path identity changed or is not a regular file");
+      }
+      if (this.identity.size < 1 || this.identity.size > PORTABLE_ARCHIVE_MAX_BYTES) throw new PortableArchiveError("archive size is invalid");
+    } catch (error) {
+      closeSync(this.descriptor);
+      throw error;
+    }
+  }
+  assertIdentity() {
+    if (this.closed) throw new PortableArchiveError("archive file is closed");
+    if (!sameFile(this.identity, fstatSync(this.descriptor))) throw new PortableArchiveError("archive file changed between passes");
+  }
+  *lines() {
+    this.assertIdentity();
+    const chunk = Buffer.allocUnsafe(64 * 1024);
+    let position = 0;
+    let pending = Buffer.alloc(0);
+    let lineNumber = 0;
+    let endedWithLf = false;
+    while (position < this.identity.size) {
+      const read = readSync(this.descriptor, chunk, 0, Math.min(chunk.length, this.identity.size - position), position);
+      if (read <= 0) throw new PortableArchiveError("archive ended before its recorded size");
+      position += read;
+      const input = pending.length ? Buffer.concat([pending, chunk.subarray(0, read)]) : Buffer.from(chunk.subarray(0, read));
+      let start = 0;
+      for (let index = 0; index < input.length; index += 1) {
+        if (input[index] !== 10) continue;
+        const line = input.subarray(start, index);
+        lineNumber += 1;
+        endedWithLf = true;
+        yield parseLine(line, lineNumber);
+        start = index + 1;
+      }
+      pending = Buffer.from(input.subarray(start));
+      if (pending.length > PORTABLE_ARCHIVE_MAX_LINE_BYTES) throw new PortableArchiveError("archive line exceeds 1 MiB");
+      if (pending.length) endedWithLf = false;
+    }
+    if (pending.length || !endedWithLf) throw new PortableArchiveError("archive must end with one LF");
+    this.assertIdentity();
+  }
+  *validatedRecords(expected) {
+    const digest = createHash2("sha256");
+    let requestId;
+    let workspace;
+    let footer;
+    let messages = 0;
+    let receipts = 0;
+    let previousMessage = "";
+    let currentMessage;
+    let previousPrincipal = "";
+    let lineNumber = 0;
+    for (const { raw, record } of this.lines()) {
+      lineNumber += 1;
+      if (footer) throw new PortableArchiveError("archive contains records after the footer");
+      if (record.kind !== "footer") digest.update(raw).update("\n");
+      if (lineNumber === 1) {
+        if (record.kind !== "header") throw new PortableArchiveError("archive must start with one header");
+        requestId = record.requestId;
+        workspace = record.workspace;
+        continue;
+      }
+      if (record.kind === "header") throw new PortableArchiveError("archive contains more than one header");
+      if (record.kind === "message") {
+        const order = `${record.message.createdAt}\0${record.message.id}`;
+        if (order <= previousMessage) throw new PortableArchiveError("messages are duplicated or out of order");
+        previousMessage = order;
+        currentMessage = record.message;
+        previousPrincipal = "";
+        messages += 1;
+        yield record;
+      } else if (record.kind === "receipt") {
+        if (!currentMessage || record.receipt.messageId !== currentMessage.id || record.receipt.principal <= previousPrincipal) throw new PortableArchiveError("receipts are out of order or not adjacent to their message");
+        if (currentMessage.targets.length > 0 && !currentMessage.targets.includes(record.receipt.principal)) throw new PortableArchiveError("receipt principal is not eligible for the message");
+        previousPrincipal = record.receipt.principal;
+        receipts += 1;
+        yield record;
+      } else footer = record;
+    }
+    if (!requestId || !workspace || !footer) throw new PortableArchiveError("archive footer is missing");
+    const calculated = `sha256:${digest.digest("hex")}`;
+    if (footer.digest !== calculated || footer.messages !== messages || footer.receipts !== receipts) throw new PortableArchiveError("archive footer verification failed");
+    const metadata = { exportRequestId: requestId, workspace, digest: calculated, messageCount: messages, receiptCount: receipts };
+    if (expected && (expected.exportRequestId !== metadata.exportRequestId || expected.workspace !== metadata.workspace || expected.digest !== metadata.digest || expected.messageCount !== metadata.messageCount || expected.receiptCount !== metadata.receiptCount)) {
+      throw new PortableArchiveError("archive changed between passes");
+    }
+    return metadata;
+  }
+  verify() {
+    const iterator = this.validatedRecords();
+    let next = iterator.next();
+    while (!next.done) next = iterator.next();
+    this.verified = next.value;
+    return next.value;
+  }
+  proveDurable() {
+    this.assertIdentity();
+    const before = lstatSync(this.path);
+    if (before.isSymbolicLink() || !sameFile(this.identity, before)) throw new PortableArchiveError("archive path changed before durability proof");
+    fsyncSync(this.descriptor);
+    const afterFileSync = lstatSync(this.path);
+    if (afterFileSync.isSymbolicLink() || !sameFile(this.identity, afterFileSync)) throw new PortableArchiveError("archive path changed during durability proof");
+    if (process.platform !== "win32") {
+      const directory = openSync(dirname(this.path), "r");
+      try {
+        fsyncSync(directory);
+      } finally {
+        closeSync(directory);
+      }
+    }
+    const afterDirectorySync = lstatSync(this.path);
+    if (afterDirectorySync.isSymbolicLink() || !sameFile(this.identity, afterDirectorySync)) throw new PortableArchiveError("archive path changed during durability proof");
+  }
+  async *messageBatches() {
+    const batch = [];
+    let batchBytes = 0;
+    const expected = this.verified ?? this.verify();
+    for (const record of this.validatedRecords(expected)) {
+      if (record.kind === "message") {
+        const bytes = Buffer.byteLength(canonicalJson({ kind: "message", message: record.message })) + 1;
+        if (batch.length && (batch.length === PORTABLE_ARCHIVE_BATCH_ROWS || batchBytes + bytes > PORTABLE_ARCHIVE_BATCH_BYTES)) {
+          yield batch.splice(0);
+          batchBytes = 0;
+        }
+        batch.push(record.message);
+        batchBytes += bytes;
+      }
+    }
+    if (batch.length) yield batch;
+  }
+  async *receiptBatches() {
+    const batch = [];
+    let batchBytes = 0;
+    const expected = this.verified ?? this.verify();
+    for (const record of this.validatedRecords(expected)) {
+      if (record.kind === "receipt") {
+        const bytes = Buffer.byteLength(canonicalJson({ kind: "receipt", receipt: record.receipt })) + 1;
+        if (batch.length && (batch.length === PORTABLE_ARCHIVE_BATCH_ROWS || batchBytes + bytes > PORTABLE_ARCHIVE_BATCH_BYTES)) {
+          yield batch.splice(0);
+          batchBytes = 0;
+        }
+        batch.push(record.receipt);
+        batchBytes += bytes;
+      }
+    }
+    if (batch.length) yield batch;
+  }
+  close() {
+    if (!this.closed) {
+      this.closed = true;
+      closeSync(this.descriptor);
+    }
+  }
+};
+
+// src/portable-archive.ts
+import { createHash as createHash3 } from "crypto";
+async function streamPortableArchive(session, workspaceValue, exportRequestIdValue, write) {
+  const workspace = validateArchiveWorkspace(workspaceValue);
+  const exportRequestId = validatePortableArchiveRequestId(exportRequestIdValue);
+  const hash = createHash3("sha256");
+  let messageCount = 0;
+  let receiptCount = 0;
+  let totalBytes = 0;
+  const line = async (value, includeInDigest = true) => {
+    const bytes = Buffer.from(`${canonicalJson(value)}
+`, "utf8");
+    if (bytes.length - 1 > PORTABLE_ARCHIVE_MAX_LINE_BYTES) throw new PortableArchiveError("archive export line exceeds 1 MiB");
+    if (totalBytes + bytes.length > PORTABLE_ARCHIVE_MAX_BYTES) throw new PortableArchiveError("archive export exceeds maximum size");
+    if (includeInDigest) hash.update(bytes);
+    await write(bytes);
+    totalBytes += bytes.length;
+  };
+  await line({ exportRequestId, format: "agent-bridge.portable-archive", kind: "header", version: 1, workspace });
+  const messages = session.messages()[Symbol.asyncIterator]();
+  let nextMessage = await messages.next();
+  const receipts = session.receipts()[Symbol.asyncIterator]();
+  let nextReceipt = await receipts.next();
+  let previousMessage = "";
+  while (!nextMessage.done) {
+    const message3 = parsePortableArchiveMessage(nextMessage.value);
+    const order = `${message3.createdAt}\0${message3.id}`;
+    if (order <= previousMessage) throw new Error("archive export messages are duplicated or out of order");
+    previousMessage = order;
+    await line({ kind: "message", message: message3 });
+    messageCount += 1;
+    let previousPrincipal = "";
+    while (!nextReceipt.done && nextReceipt.value.messageId === message3.id) {
+      const receipt3 = parsePortableArchiveReceipt(nextReceipt.value);
+      if (receipt3.principal <= previousPrincipal) throw new Error("archive export receipts are duplicated or out of order");
+      if (message3.targets.length > 0 && !message3.targets.includes(receipt3.principal)) throw new Error("archive export receipt principal is not eligible");
+      previousPrincipal = receipt3.principal;
+      await line({ kind: "receipt", receipt: receipt3 });
+      receiptCount += 1;
+      nextReceipt = await receipts.next();
+    }
+    nextMessage = await messages.next();
+  }
+  if (!nextReceipt.done) throw new Error("archive export receipt references a missing message");
+  const digest = `sha256:${hash.digest("hex")}`;
+  await line({ digest, kind: "footer", messages: messageCount, receipts: receiptCount }, false);
+  return { exportRequestId, workspace, digest, messageCount, receiptCount };
+}
+async function exportPortableArchive(store, workspace, exportRequestIdValue) {
+  const exportRequestId = validatePortableArchiveRequestId(exportRequestIdValue);
+  const start = await store.beginExport(exportRequestId, workspace);
+  if (start.status === "completed") throw new PortableArchiveError("archive export request is already complete");
+  const session = start.session;
+  const chunks = [];
+  try {
+    await streamPortableArchive(session, workspace, exportRequestId, (bytes) => {
+      chunks.push(bytes);
+    });
+    await session.abandon("not_published");
+    return Buffer.concat(chunks);
+  } catch (error) {
+    await session.abandon("stream_failed").catch(() => void 0);
+    throw error;
+  } finally {
+    await session.close();
+  }
+}
+function inMemoryPasses(messages, receipts) {
+  return {
+    async *messageBatches() {
+      let batch = [];
+      let bytes = 0;
+      for (const message3 of messages) {
+        const size = Buffer.byteLength(canonicalJson({ kind: "message", message: message3 })) + 1;
+        if (batch.length && (batch.length === PORTABLE_ARCHIVE_BATCH_ROWS || bytes + size > PORTABLE_ARCHIVE_BATCH_BYTES)) {
+          yield batch;
+          batch = [];
+          bytes = 0;
+        }
+        batch.push(message3);
+        bytes += size;
+      }
+      if (batch.length) yield batch;
+    },
+    async *receiptBatches() {
+      let batch = [];
+      let bytes = 0;
+      for (const receipt3 of receipts) {
+        const size = Buffer.byteLength(canonicalJson({ kind: "receipt", receipt: receipt3 })) + 1;
+        if (batch.length && (batch.length === PORTABLE_ARCHIVE_BATCH_ROWS || bytes + size > PORTABLE_ARCHIVE_BATCH_BYTES)) {
+          yield batch;
+          batch = [];
+          bytes = 0;
+        }
+        batch.push(receipt3);
+        bytes += size;
+      }
+      if (batch.length) yield batch;
+    }
+  };
+}
+async function importPortableArchive(store, bytes, options) {
+  const archive = decodePortableArchive(bytes);
+  const requestId = validatePortableArchiveRequestId(options.requestId);
+  return store.importWorkspace(requestId, {
+    exportRequestId: archive.exportRequestId,
+    workspace: archive.workspace,
+    digest: archive.digest,
+    messageCount: archive.messages.length,
+    receiptCount: archive.receipts.length
+  }, inMemoryPasses(archive.messages, archive.receipts), { apply: options.apply === true });
+}
+
+// src/sqlite-portable-archive-store.ts
+import { existsSync, lstatSync as lstatSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var parse = (value) => typeof value === "string" ? JSON.parse(value) : value;
+var nullable = (value) => value == null ? null : String(value);
+function message(row) {
+  const policy = parse(row.delivery_policy);
+  if (policy.mode === "leased" && policy.notBefore) policy.notBefore = normalizeArchiveTimestamp(policy.notBefore, "deliveryPolicy.notBefore");
+  return {
+    id: String(row.id),
+    project: nullable(row.project),
+    source: String(row.source),
+    type: String(row.type),
+    content: String(row.content),
+    contentType: String(row.content_type),
+    data: parse(row.data) ?? null,
+    targets: parse(row.targets) ?? [],
+    threadId: nullable(row.thread_id),
+    replyToId: nullable(row.reply_to_id),
+    correlationId: nullable(row.correlation_id),
+    causationId: nullable(row.causation_id),
+    priority: row.priority,
+    expiresAt: row.expires_at == null ? null : normalizeArchiveTimestamp(String(row.expires_at), "expiresAt"),
+    idempotencyKey: nullable(row.idempotency_key),
+    atribReceiptId: nullable(row.atrib_receipt_id),
+    informedBy: parse(row.informed_by) ?? [],
+    metadata: parse(row.metadata) ?? null,
+    deliveryPolicy: policy,
+    createdAt: normalizeArchiveTimestamp(String(row.created_at), "createdAt")
+  };
+}
+function receipt(row) {
+  return { messageId: String(row.message_id), principal: String(row.principal), readAt: normalizeArchiveTimestamp(String(row.read_at), "readAt") };
+}
+function canonicalBatchBytes(kind, batch) {
+  return batch.reduce((total, value) => total + Buffer.byteLength(canonicalJson({ kind, [kind]: value })) + 1, 0);
+}
+function assertPrivateDatabase(path) {
+  if (path === ":memory:") return void 0;
+  verifyPrivatePathAccess(dirname2(path), "directory");
+  securePrivatePath(path, "file");
+  const stat = lstatSync2(path);
+  if (!stat.isFile() || stat.isSymbolicLink()) throw new PortableArchiveError("local archive database must be a regular file");
+  if (typeof process.getuid === "function" && stat.uid !== process.getuid()) throw new PortableArchiveError("local archive database is not owned by the current user");
+  return stat;
+}
+var SQLitePortableArchiveStore = class {
+  constructor(path) {
+    this.path = path;
+    if (path !== ":memory:" && !existsSync(path)) throw new PortableArchiveError("local archive database does not exist");
+    const before = assertPrivateDatabase(path);
+    const { DatabaseSync } = require2("node:sqlite");
+    this.db = new DatabaseSync(path);
+    try {
+      if (before) {
+        const after = lstatSync2(path);
+        if (before.dev !== after.dev || before.ino !== after.ino || before.isSymbolicLink() || !after.isFile()) {
+          throw new PortableArchiveError("local archive database identity changed while opening");
+        }
+        verifyPrivatePathAccess(path, "file");
+      }
+      this.db.exec("PRAGMA foreign_keys=ON; PRAGMA busy_timeout=2000");
+      const tables = new Set(this.db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map((row) => String(row.name)));
+      if (!tables.has("bridge_messages") || !tables.has("bridge_receipts")) throw new PortableArchiveError("database is not a canonical local Agent Bridge store");
+      if (tables.has("edge_outbox") || tables.has("edge_inbox")) throw new PortableArchiveError("edge databases cannot be used as portable archives");
+    } catch (error) {
+      try {
+        this.db.close();
+      } finally {
+        throw error;
+      }
+    }
+  }
+  async beginExport(requestIdValue, workspaceValue) {
+    validatePortableArchiveRequestId(requestIdValue);
+    const workspace = validateArchiveWorkspace(workspaceValue);
+    this.db.exec("BEGIN");
+    let ended = false;
+    const finish = (sql) => {
+      if (!ended) {
+        this.db.exec(sql);
+        ended = true;
+      }
+    };
+    const db = this.db;
+    const session = {
+      async *messages() {
+        for (const row of db.prepare("SELECT * FROM bridge_messages WHERE workspace=? ORDER BY created_at,id").iterate(workspace)) yield message(row);
+      },
+      async *receipts() {
+        for (const row of db.prepare(`SELECT receipt.message_id,receipt.principal,receipt.read_at
+          FROM bridge_receipts receipt JOIN bridge_messages message
+            ON message.workspace=receipt.workspace AND message.id=receipt.message_id
+          WHERE receipt.workspace=? ORDER BY message.created_at,message.id,receipt.principal`).iterate(workspace)) yield receipt(row);
+      },
+      async complete() {
+        finish("COMMIT");
+      },
+      async reconcile() {
+        finish("COMMIT");
+      },
+      async abandon() {
+        finish("ROLLBACK");
+      },
+      close() {
+        finish("ROLLBACK");
+      }
+    };
+    return { status: "active", session, replayed: false };
+  }
+  async importWorkspace(requestId, archive, passes, options) {
+    requestId = validatePortableArchiveRequestId(requestId);
+    validateArchiveWorkspace(archive.workspace);
+    this.db.exec("BEGIN IMMEDIATE");
+    let messagesCreated = 0;
+    let messagesReplayed = 0;
+    let receiptsCreated = 0;
+    let receiptsReplayed = 0;
+    try {
+      const selectMessage = this.db.prepare("SELECT * FROM bridge_messages WHERE workspace=? AND id=?");
+      const selectIdempotent = this.db.prepare("SELECT id FROM bridge_messages WHERE workspace=? AND source=? AND idempotency_key=?");
+      const insertMessage = this.db.prepare(`INSERT INTO bridge_messages (
+        id,workspace,project,source,type,content,content_type,data,targets,thread_id,reply_to_id,
+        correlation_id,causation_id,priority,expires_at,idempotency_key,atrib_receipt_id,informed_by,
+        metadata,delivery_policy,created_at
+      ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`);
+      let messageCount = 0;
+      for await (const batch of passes.messageBatches()) {
+        if (batch.length < 1 || batch.length > PORTABLE_ARCHIVE_BATCH_ROWS || canonicalBatchBytes("message", batch) > PORTABLE_ARCHIVE_BATCH_BYTES) throw new PortableArchiveError("archive message batch is invalid");
+        for (const value of batch) {
+          const archived = parsePortableArchiveMessage(value);
+          messageCount += 1;
+          const existingRow = selectMessage.get(archive.workspace, archived.id);
+          if (existingRow) {
+            if (canonicalJson(message(existingRow)) !== canonicalJson(archived)) throw new PortableArchiveError(`message conflict: ${archived.id}`);
+            messagesReplayed += 1;
+            continue;
+          }
+          if (archived.idempotencyKey) {
+            const idempotent = selectIdempotent.get(archive.workspace, archived.source, archived.idempotencyKey);
+            if (idempotent) throw new PortableArchiveError(`idempotency conflict: ${archived.idempotencyKey}`);
+          }
+          insertMessage.run(
+            archived.id,
+            archive.workspace,
+            archived.project,
+            archived.source,
+            archived.type,
+            archived.content,
+            archived.contentType,
+            archived.data === null ? null : JSON.stringify(archived.data),
+            JSON.stringify(archived.targets),
+            archived.threadId,
+            archived.replyToId,
+            archived.correlationId,
+            archived.causationId,
+            archived.priority,
+            archived.expiresAt,
+            archived.idempotencyKey,
+            archived.atribReceiptId,
+            archived.informedBy.length ? JSON.stringify(archived.informedBy) : null,
+            archived.metadata === null ? null : JSON.stringify(archived.metadata),
+            JSON.stringify(archived.deliveryPolicy),
+            archived.createdAt
+          );
+          messagesCreated += 1;
+        }
+      }
+      if (messageCount !== archive.messageCount) throw new PortableArchiveError("archive message count changed between passes");
+      const selectReceipt = this.db.prepare("SELECT read_at FROM bridge_receipts WHERE workspace=? AND message_id=? AND principal=?");
+      const selectReceiptMessage = this.db.prepare("SELECT targets FROM bridge_messages WHERE workspace=? AND id=?");
+      const insertReceipt = this.db.prepare("INSERT INTO bridge_receipts(workspace,message_id,principal,read_at) VALUES (?,?,?,?)");
+      let receiptCount = 0;
+      for await (const batch of passes.receiptBatches()) {
+        if (batch.length < 1 || batch.length > PORTABLE_ARCHIVE_BATCH_ROWS || canonicalBatchBytes("receipt", batch) > PORTABLE_ARCHIVE_BATCH_BYTES) throw new PortableArchiveError("archive receipt batch is invalid");
+        for (const value of batch) {
+          const archived = parsePortableArchiveReceipt(value);
+          receiptCount += 1;
+          const receiptMessage = selectReceiptMessage.get(archive.workspace, archived.messageId);
+          const targets = receiptMessage ? parse(receiptMessage.targets) : void 0;
+          if (!targets || targets.length > 0 && !targets.includes(archived.principal)) throw new PortableArchiveError(`receipt principal is not eligible: ${archived.messageId}/${archived.principal}`);
+          const existing = selectReceipt.get(archive.workspace, archived.messageId, archived.principal);
+          if (existing) {
+            if (normalizeArchiveTimestamp(String(existing.read_at), "readAt") !== archived.readAt) throw new PortableArchiveError(`receipt conflict: ${archived.messageId}/${archived.principal}`);
+            receiptsReplayed += 1;
+          } else {
+            insertReceipt.run(archive.workspace, archived.messageId, archived.principal, archived.readAt);
+            receiptsCreated += 1;
+          }
+        }
+      }
+      if (receiptCount !== archive.receiptCount) throw new PortableArchiveError("archive receipt count changed between passes");
+      this.db.exec(options.apply ? "COMMIT" : "ROLLBACK");
+      return { requestId, workspace: archive.workspace, digest: archive.digest, apply: options.apply, messages: { created: messagesCreated, replayed: messagesReplayed }, receipts: { created: receiptsCreated, replayed: receiptsReplayed } };
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {
+      }
+      throw error;
+    }
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/postgres-portable-archive-store.ts
+var parse2 = (value) => typeof value === "string" ? JSON.parse(value) : value;
+var nullable2 = (value) => value == null ? null : String(value);
+function message2(row) {
+  const deliveryPolicy = row.delivery_mode === "mailbox" ? { mode: "mailbox" } : {
+    mode: "leased",
+    maxAttempts: Number(row.delivery_max_attempts),
+    retryBaseDelayMs: Number(row.delivery_retry_base_delay_ms),
+    retryMaxDelayMs: Number(row.delivery_retry_max_delay_ms),
+    retryJitterRatio: Number(row.delivery_retry_jitter_ratio),
+    ...row.delivery_not_before ? { notBefore: normalizeArchiveTimestamp(String(row.delivery_not_before), "deliveryPolicy.notBefore") } : {}
+  };
+  return {
+    id: String(row.id),
+    project: nullable2(row.project),
+    source: String(row.source),
+    type: String(row.type),
+    content: String(row.content),
+    contentType: String(row.content_type),
+    data: parse2(row.data) ?? null,
+    targets: parse2(row.targets) ?? [],
+    threadId: nullable2(row.thread_id),
+    replyToId: nullable2(row.reply_to_id),
+    correlationId: nullable2(row.correlation_id),
+    causationId: nullable2(row.causation_id),
+    priority: row.priority,
+    expiresAt: row.expires_at ? normalizeArchiveTimestamp(String(row.expires_at), "expiresAt") : null,
+    idempotencyKey: nullable2(row.idempotency_key),
+    atribReceiptId: nullable2(row.atrib_receipt_id),
+    informedBy: parse2(row.informed_by) ?? [],
+    metadata: parse2(row.metadata) ?? null,
+    deliveryPolicy,
+    createdAt: normalizeArchiveTimestamp(String(row.created_at), "createdAt")
+  };
+}
+function receipt2(row) {
+  return {
+    messageId: String(row.message_id),
+    principal: String(row.principal),
+    readAt: normalizeArchiveTimestamp(String(row.read_at), "readAt")
+  };
+}
+var PostgresPortableArchiveStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  async beginExport(requestId, workspace) {
+    const normalizedRequestId = validatePortableArchiveRequestId(requestId);
+    const connection = this.db.connect ? await this.db.connect() : this.db;
+    let snapshotOpen = false;
+    let beginCommitted = false;
+    let beginReplayed = false;
+    let released = false;
+    let final = false;
+    let messagesRead = false;
+    let receiptsRead = false;
+    const release = () => {
+      if (!released && connection !== this.db && typeof connection.release === "function") connection.release();
+      released = true;
+    };
+    try {
+      await connection.query("BEGIN");
+      const begun = await connection.query(
+        "SELECT * FROM agent_bridge.archive_begin_operation($1,'export',$2,NULL,NULL,NULL)",
+        [normalizedRequestId, workspace]
+      );
+      const prior = begun.rows[0];
+      beginReplayed = Boolean(prior?.replayed);
+      await connection.query("COMMIT");
+      beginCommitted = true;
+      if (prior?.completed) {
+        release();
+        return {
+          status: "completed",
+          metadata: {
+            exportRequestId: normalizedRequestId,
+            workspace,
+            digest: `sha256:${String(prior.client_verified_digest)}`,
+            messageCount: Number(prior.message_count),
+            receiptCount: Number(prior.receipt_count),
+            publishedAt: normalizeArchiveTimestamp(String(prior.published_at), "publishedAt")
+          }
+        };
+      }
+      if (beginReplayed) {
+        const unavailable = async function* () {
+          throw new Error("replayed archive export is reconciliation-only");
+        };
+        const reconciliationSession = {
+          messages: unavailable,
+          receipts: unavailable,
+          complete: async () => {
+            throw new Error("replayed archive export cannot be published again");
+          },
+          reconcile: async (result) => {
+            if (final || result.exportRequestId !== normalizedRequestId || result.workspace !== workspace) {
+              throw new Error("archive export session cannot be reconciled");
+            }
+            await connection.query(
+              "SELECT * FROM agent_bridge.archive_reconcile_export($1,$2,$3,$4,$5,$6::timestamptz)",
+              [normalizedRequestId, workspace, result.digest.slice("sha256:".length), result.messageCount, result.receiptCount, result.publishedAt]
+            );
+            final = true;
+          },
+          abandon: async (reason) => {
+            if (final) return;
+            await connection.query(
+              "SELECT * FROM agent_bridge.archive_abandon_operation($1,$2,$3)",
+              [normalizedRequestId, workspace, reason]
+            );
+            final = true;
+          },
+          close: release
+        };
+        return { status: "active", session: reconciliationSession, replayed: true };
+      }
+      await connection.query("BEGIN ISOLATION LEVEL REPEATABLE READ");
+      snapshotOpen = true;
+      await connection.query(
+        "SELECT agent_bridge.archive_authorize_transaction($1,'export',$2,NULL)",
+        [normalizedRequestId, workspace]
+      );
+    } catch (error) {
+      await connection.query("ROLLBACK").catch(() => void 0);
+      let abandonmentError;
+      if (beginCommitted) {
+        try {
+          await connection.query(
+            "SELECT * FROM agent_bridge.archive_abandon_operation($1,$2,'snapshot_failed')",
+            [normalizedRequestId, workspace]
+          );
+        } catch (failure) {
+          abandonmentError = failure;
+        }
+      }
+      release();
+      if (abandonmentError) {
+        const combined = new Error("archive snapshot and abandonment both failed");
+        combined.errors = [error, abandonmentError];
+        throw combined;
+      }
+      throw error;
+    }
+    const endSnapshot = async (commit) => {
+      if (!snapshotOpen) return;
+      if (commit) {
+        await connection.query(
+          "SELECT agent_bridge.archive_close_transaction_authorization($1)",
+          [normalizedRequestId]
+        );
+        await connection.query("COMMIT");
+      } else {
+        await connection.query("ROLLBACK");
+      }
+      snapshotOpen = false;
+    };
+    const session = {
+      messages: async function* () {
+        if (final || messagesRead) throw new Error("archive export message pass is unavailable");
+        messagesRead = true;
+        let createdAt = null;
+        let id = null;
+        for (; ; ) {
+          const result = await connection.query(
+            "SELECT * FROM agent_bridge.archive_export_messages($1,$2,$3::timestamptz,$4::uuid,200)",
+            [normalizedRequestId, workspace, createdAt, id]
+          );
+          for (const row of result.rows) yield message2(row);
+          if (result.rows.length === 0) return;
+          const last = result.rows[result.rows.length - 1];
+          createdAt = String(last.created_at);
+          id = String(last.id);
+        }
+      },
+      receipts: async function* () {
+        if (final || receiptsRead) throw new Error("archive export receipt pass is unavailable");
+        receiptsRead = true;
+        let createdAt = null;
+        let messageId = null;
+        let principal = null;
+        for (; ; ) {
+          const result = await connection.query(
+            "SELECT * FROM agent_bridge.archive_export_receipts($1,$2,$3::timestamptz,$4::uuid,$5,500)",
+            [normalizedRequestId, workspace, createdAt, messageId, principal]
+          );
+          for (const row of result.rows) yield receipt2(row);
+          if (result.rows.length === 0) return;
+          const last = result.rows[result.rows.length - 1];
+          createdAt = String(last.message_created_at);
+          messageId = String(last.message_id);
+          principal = String(last.principal);
+        }
+      },
+      complete: async (result) => {
+        if (final || result.exportRequestId !== normalizedRequestId || result.workspace !== workspace || !messagesRead || !receiptsRead) {
+          throw new Error("archive export session cannot be completed");
+        }
+        await connection.query(
+          "SELECT * FROM agent_bridge.archive_complete_export($1,$2,$3,$4,$5,$6::timestamptz,$7)",
+          [normalizedRequestId, workspace, result.digest.slice("sha256:".length), result.messageCount, result.receiptCount, result.publishedAt, "published"]
+        );
+        await endSnapshot(true);
+        final = true;
+      },
+      reconcile: async () => {
+        throw new Error("fresh archive export cannot be reconciled");
+      },
+      abandon: async (reason) => {
+        if (final) return;
+        await endSnapshot(false);
+        await connection.query(
+          "SELECT * FROM agent_bridge.archive_abandon_operation($1,$2,$3)",
+          [normalizedRequestId, workspace, reason]
+        );
+        final = true;
+      },
+      close: async () => {
+        if (snapshotOpen) {
+          await connection.query("ROLLBACK").catch(() => void 0);
+          snapshotOpen = false;
+        }
+        release();
+      }
+    };
+    return { status: "active", session, replayed: beginReplayed };
+  }
+  async importWorkspace(requestId, metadata, passes, options) {
+    const normalizedRequestId = validatePortableArchiveRequestId(requestId);
+    const connection = this.db.connect ? await this.db.connect() : this.db;
+    try {
+      await connection.query("BEGIN");
+      const digest = metadata.digest.slice("sha256:".length);
+      const begun = await connection.query(
+        "SELECT * FROM agent_bridge.archive_begin_operation($1,'import',$2,$3,$4,$5)",
+        [normalizedRequestId, metadata.workspace, digest, metadata.messageCount, metadata.receiptCount]
+      );
+      const prior = begun.rows[0];
+      if (prior?.completed) {
+        await connection.query("COMMIT");
+        return {
+          requestId: normalizedRequestId,
+          workspace: metadata.workspace,
+          digest: metadata.digest,
+          apply: Boolean(prior.apply),
+          messages: {
+            created: Number(prior.message_inserted_count),
+            replayed: Number(prior.message_count) - Number(prior.message_inserted_count)
+          },
+          receipts: {
+            created: Number(prior.receipt_inserted_count),
+            replayed: Number(prior.receipt_count) - Number(prior.receipt_inserted_count)
+          }
+        };
+      }
+      await connection.query(
+        "SELECT agent_bridge.archive_authorize_transaction($1,'import',$2,$3)",
+        [normalizedRequestId, metadata.workspace, digest]
+      );
+      let messageOrdinal = 0;
+      for await (const batch of passes.messageBatches()) {
+        await connection.query(
+          "SELECT * FROM agent_bridge.archive_import_messages($1,$2,$3,$4,$5::jsonb)",
+          [normalizedRequestId, metadata.workspace, digest, messageOrdinal, JSON.stringify(batch)]
+        );
+        messageOrdinal += 1;
+      }
+      let receiptOrdinal = 0;
+      for await (const batch of passes.receiptBatches()) {
+        await connection.query(
+          "SELECT * FROM agent_bridge.archive_import_receipts($1,$2,$3,$4,$5::jsonb)",
+          [normalizedRequestId, metadata.workspace, digest, receiptOrdinal, JSON.stringify(batch)]
+        );
+        receiptOrdinal += 1;
+      }
+      const completed = await connection.query(
+        "SELECT * FROM agent_bridge.archive_complete_import($1,$2,$3)",
+        [normalizedRequestId, metadata.workspace, options.apply]
+      );
+      const result = completed.rows[0];
+      await connection.query(options.apply ? "COMMIT" : "ROLLBACK");
+      return {
+        requestId: normalizedRequestId,
+        workspace: metadata.workspace,
+        digest: metadata.digest,
+        apply: options.apply,
+        messages: {
+          created: Number(result.message_inserted_count),
+          replayed: Number(result.message_count) - Number(result.message_inserted_count)
+        },
+        receipts: {
+          created: Number(result.receipt_inserted_count),
+          replayed: Number(result.receipt_count) - Number(result.receipt_inserted_count)
+        }
+      };
+    } catch (error) {
+      await connection.query("ROLLBACK").catch(() => void 0);
+      throw error;
+    } finally {
+      if (connection !== this.db && typeof connection.release === "function") connection.release();
+    }
+  }
+};
+
+export {
+  PORTABLE_ARCHIVE_FORMAT,
+  PORTABLE_ARCHIVE_VERSION,
+  PORTABLE_ARCHIVE_MAX_LINE_BYTES,
+  PORTABLE_ARCHIVE_MAX_BYTES,
+  PORTABLE_ARCHIVE_BATCH_BYTES,
+  PORTABLE_ARCHIVE_BATCH_ROWS,
+  PortableArchiveError,
+  canonicalJson,
+  normalizeArchiveTimestamp,
+  validateArchiveWorkspace,
+  validatePortableArchiveRequestId,
+  parsePortableArchiveMessage,
+  parsePortableArchiveReceipt,
+  encodePortableArchive,
+  decodePortableArchive,
+  PortableArchiveFile,
+  streamPortableArchive,
+  exportPortableArchive,
+  importPortableArchive,
+  SQLitePortableArchiveStore,
+  PostgresPortableArchiveStore
+};
+//# sourceMappingURL=chunk-A6W4QALF.js.map