@xyo-network/event-kit-node 0.1.1 → 0.1.2

package/dist/node/runtime.mjs

@@ -0,0 +1,1640 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/runtime/boundedFetch.ts
+import { Buffer as Buffer2 } from "node:buffer";
+
+// src/runtime/abort.ts
+import { clearTimeout, setTimeout } from "node:timers";
+function publisherAbortScope(signals, timeoutMs) {
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  const timer = timeoutMs === void 0 ? void 0 : setTimeout(abort, timeoutMs);
+  timer?.unref();
+  for (const signal of signals) {
+    if (signal.aborted) controller.abort();
+    else signal.addEventListener("abort", abort, { once: true });
+  }
+  return {
+    signal: controller.signal,
+    dispose() {
+      if (timer !== void 0) clearTimeout(timer);
+      for (const signal of signals) signal.removeEventListener("abort", abort);
+    }
+  };
+}
+
+// src/runtime/boundedFetch.ts
+function createBoundedPublisherFetch(options = {}) {
+  const owner = new AbortController();
+  const timeout = options.requestTimeoutMs ?? 1e4;
+  const maximum = options.maxResponseBytes ?? 16 * 1024 * 1024;
+  const concurrency = options.maxConcurrency ?? 16;
+  if (!Number.isSafeInteger(timeout) || timeout < 100 || timeout > 6e4 || !Number.isSafeInteger(maximum) || maximum < 1 || maximum > 64 * 1024 * 1024 || !Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > 64)
+    throw new Error("Invalid publisher fetch limits");
+  const active = /* @__PURE__ */ new Set();
+  const nativeFetch = globalThis.fetch.bind(globalThis);
+  const fetchFn = (input, init) => {
+    if (active.size >= concurrency)
+      return Promise.reject(new Error("Publisher HTTP concurrency limit exceeded"));
+    const operation = (async () => {
+      const signals = [
+        owner.signal,
+        ...options.signal === void 0 ? [] : [options.signal],
+        ...init?.signal == null ? [] : [init.signal],
+        ...input instanceof Request ? [input.signal] : []
+      ];
+      const scope = publisherAbortScope(signals, timeout);
+      try {
+        scope.signal.throwIfAborted();
+        const response = await nativeFetch(input, {
+          ...init,
+          redirect: "error",
+          signal: scope.signal
+        });
+        if (response.body === null)
+          return response;
+        const reader = response.body.getReader();
+        const chunks = [];
+        let size = 0;
+        try {
+          for (; ; ) {
+            const chunk = await reader.read();
+            if (chunk.done)
+              break;
+            const bytes = chunk.value;
+            if (!(bytes instanceof Uint8Array)) throw new Error("Publisher HTTP body returned a non-byte chunk");
+            size += bytes.byteLength;
+            if (size > maximum) {
+              await reader.cancel();
+              throw new Error("Publisher HTTP body exceeds its bound");
+            }
+            chunks.push(bytes);
+          }
+        } finally {
+          reader.releaseLock();
+        }
+        const headers = new Headers(response.headers);
+        headers.delete("content-encoding");
+        headers.delete("transfer-encoding");
+        headers.set("content-length", String(size));
+        return new Response(Buffer2.concat(chunks), {
+          status: response.status,
+          statusText: response.statusText,
+          headers
+        });
+      } finally {
+        scope.dispose();
+      }
+    })();
+    active.add(operation);
+    void operation.then(() => active.delete(operation), () => active.delete(operation));
+    return operation;
+  };
+  return {
+    fetchFn,
+    async close() {
+      owner.abort();
+      await Promise.allSettled(active);
+    },
+    get activeRequests() {
+      return active.size;
+    }
+  };
+}
+function createBoundedPublisherEthersTransport(options = {}) {
+  const bounded = createBoundedPublisherFetch(options);
+  const getUrl = async (request2, cancellation) => {
+    const controller = new AbortController();
+    cancellation?.addListener(() => controller.abort());
+    cancellation?.checkSignal();
+    const response = await bounded.fetchFn(request2.url, {
+      body: request2.body === null ? void 0 : Buffer2.from(request2.body),
+      headers: request2.headers,
+      method: request2.method,
+      signal: controller.signal
+    });
+    return {
+      body: new Uint8Array(await response.arrayBuffer()),
+      headers: Object.fromEntries(response.headers),
+      statusCode: response.status,
+      statusMessage: response.statusText
+    };
+  };
+  return {
+    getUrl,
+    async close() {
+      await bounded.close();
+    },
+    get activeRequests() {
+      return bounded.activeRequests;
+    }
+  };
+}
+
+// src/runtime/handshakeDiscovery.ts
+import { decryptWakeSubscription, sourceWakeFilterHash } from "@xyo-network/event-kit-protocol";
+import { EndpointChallengeResponseZod } from "@xyo-network/event-kit-schemas";
+function createPublisherHandshakeDiscovery(options) {
+  const clock = options.nowSeconds ?? (() => Math.floor(Date.now() / 1e3));
+  const owner = new AbortController();
+  let accepting;
+  let viewing;
+  let status = {
+    authorizationChainId: options.authorizationChainId,
+    keyLoaded: false,
+    activeKeyIds: [],
+    pendingSubscriptions: 0,
+    rejectedSubscriptions: 0,
+    challengeFailures: 0
+  };
+  async function activeView(signal) {
+    signal.throwIfAborted();
+    viewing ??= options.client.subscriptions().finally(() => {
+      viewing = void 0;
+    });
+    const view = await viewing;
+    signal.throwIfAborted();
+    if (!view.ok || view.indexedThrough !== view.finalizedHead)
+      throw new Error("Publisher subscription view is unavailable or stale");
+    status = {
+      ...status,
+      finalizedHead: view.finalizedHead,
+      indexedThrough: view.indexedThrough,
+      pendingSubscriptions: view.subscriptions.filter((item) => item.state === "pending").length,
+      rejectedSubscriptions: view.rejections.length
+    };
+    return view;
+  }
+  async function acceptCandidate(subscriber, subscription, signal) {
+    try {
+      let pending = options.state.get("outbound-challenges", subscription);
+      if (pending !== void 0 && pending.response === void 0 && clock() >= pending.expiresAt)
+        pending = void 0;
+      if (pending === void 0) {
+        const issued = await options.client.issueChallenge({
+          issuedAt: clock(),
+          lifetimeSeconds: 300,
+          subscriber,
+          subscription
+        });
+        pending = {
+          challengeHash: issued.challengeHash,
+          subscriber,
+          subscription,
+          expiresAt: issued.challenge.expiresAt
+        };
+        options.state.set("outbound-challenges", subscription, pending);
+      }
+      if (pending.response === void 0) {
+        const begun = await options.client.beginChallenge({ challengeHash: pending.challengeHash, nowSeconds: clock });
+        if (begun.kind !== "started")
+          return;
+        signal.throwIfAborted();
+        const response2 = await options.transport.post(begun.target.endpoint, begun.challenge, signal);
+        if (response2.status !== 200)
+          throw new Error("Endpoint challenge was rejected");
+        pending = { ...pending, response: EndpointChallengeResponseZod.parse(response2.body) };
+        options.state.set("outbound-challenges", subscription, pending);
+      }
+      signal.throwIfAborted();
+      const response = pending.response;
+      if (response === void 0)
+        throw new Error("Endpoint proof is unavailable");
+      await options.client.completeChallengeAndAccept({
+        ...pending,
+        response,
+        nowSeconds: clock
+      });
+    } catch {
+      if (signal.aborted)
+        return;
+      const failures = options.state.get("challenge-failures", subscription) ?? 0;
+      options.state.set("challenge-failures", subscription, failures + 1);
+      const pending = options.state.get("outbound-challenges", subscription);
+      if (pending !== void 0 && clock() >= pending.expiresAt)
+        options.state.remove("outbound-challenges", subscription);
+    }
+  }
+  async function accept(signal) {
+    signal.throwIfAborted();
+    const now = clock();
+    if (now < (options.state.get("challenge-rate", "next-pass") ?? 0))
+      return;
+    options.state.set("challenge-rate", "next-pass", now + 10);
+    const found = await options.client.acceptanceCandidates();
+    if (!found.ok)
+      throw new Error("Publisher acceptance candidates are unavailable");
+    const offset = options.state.get("challenge-rate", "offset") ?? 0;
+    const candidates = found.candidates;
+    let attempted = 0;
+    for (let index = 0; index < Math.min(candidates.length, 128) && attempted < 4; index += 1) {
+      const candidate = candidates[(offset + index) % candidates.length];
+      if (candidate === void 0)
+        break;
+      options.state.set("challenge-rate", "offset", (offset + index + 1) % candidates.length);
+      const next = options.state.get("challenge-controller-rate", candidate.subscriber) ?? 0;
+      if (now < next)
+        continue;
+      options.state.set("challenge-controller-rate", candidate.subscriber, now + 30);
+      attempted += 1;
+      signal.throwIfAborted();
+      await acceptCandidate(candidate.subscriber, candidate.tuple.subscription.objectHash, signal);
+    }
+  }
+  return {
+    async discover(signal) {
+      const view = await activeView(signal);
+      const key = view.hasCurrentAdvertisement ? view.key : void 0;
+      const loaded = key === void 0 ? void 0 : await options.keys.getPrivateKey({
+        encryptionKey: key.objectHash,
+        keyId: key.body.keyId,
+        publisher: options.publisher
+      });
+      status = {
+        ...status,
+        keyLoaded: loaded !== void 0,
+        activeKeyIds: key === void 0 ? [] : [key.body.keyId]
+      };
+      const subscriptions = [];
+      const active = view.subscriptions.filter((item) => item.state === "active");
+      if (active.length > (options.maxSubscriptions ?? 64))
+        throw new Error("Publisher active subscription limit exceeded");
+      for (const lifecycle of active) {
+        if (lifecycle.state !== "active" || lifecycle.activeFromBlock === void 0)
+          continue;
+        try {
+          const tuple = lifecycle.tuples.find((item) => item.subscription.objectHash === lifecycle.selectedSubscription);
+          if (tuple === void 0)
+            throw new Error("Active publisher subscription has no selected tuple");
+          const encrypted = tuple.subscription.body;
+          if (encrypted.chainId !== options.authorizationChainId)
+            throw new Error("Subscription authorization chain mismatch");
+          const publisherKey = await options.keys.getPrivateKey({
+            encryptionKey: encrypted.encryptionKey,
+            keyId: encrypted.keyId,
+            publisher: options.publisher
+          });
+          if (publisherKey === void 0)
+            throw new Error("Subscription encryption key is unavailable");
+          const plaintext = await decryptWakeSubscription({
+            publisherKey,
+            subscriber: tuple.subscriber,
+            subscription: encrypted
+          });
+          options.transport.assertAllowed(plaintext.endpoint);
+          subscriptions.push({
+            subscriptionHash: tuple.subscription.objectHash,
+            authorizationChainId: options.authorizationChainId,
+            controller: tuple.subscriber,
+            audience: plaintext.audience,
+            endpoint: plaintext.endpoint,
+            deploymentId: plaintext.deploymentId,
+            ...plaintext.queueId === null ? {} : { queueId: plaintext.queueId },
+            source: plaintext.filter.source,
+            fromPosition: plaintext.filter.fromPosition,
+            maxPositionsPerWake: plaintext.filter.maxPositionsPerWake,
+            filterHash: await sourceWakeFilterHash(plaintext.filter)
+          });
+        } catch {
+          status = { ...status, rejectedSubscriptions: status.rejectedSubscriptions + 1 };
+        }
+      }
+      return subscriptions;
+    },
+    async isActive(subscription, signal) {
+      const view = await activeView(signal);
+      return view.subscriptions.some((item) => item.state === "active" && item.selectedSubscription === subscription.subscriptionHash && item.tuples.some((tuple) => tuple.subscription.objectHash === subscription.subscriptionHash && tuple.subscriber === subscription.controller));
+    },
+    async acceptPending(signal) {
+      if (accepting === void 0) {
+        const scope = publisherAbortScope([owner.signal, signal]);
+        accepting = accept(scope.signal).finally(() => {
+          scope.dispose();
+          accepting = void 0;
+        });
+      }
+      await accepting;
+    },
+    async close() {
+      await Promise.allSettled([accepting, viewing].filter((item) => item !== void 0));
+    },
+    status() {
+      return { ...status, challengeFailures: options.state.entries("challenge-failures").reduce((sum, item) => sum + item.value, 0) };
+    }
+  };
+}
+
+// src/runtime/httpsTransport.ts
+import { Buffer as Buffer3 } from "node:buffer";
+import { lookup } from "node:dns/promises";
+import { request } from "node:https";
+import { BlockList, isIP } from "node:net";
+import { z } from "zod";
+
+// src/runtime/sources.ts
+import { createHash } from "node:crypto";
+import { canonicalJson } from "@xyo-network/event-kit-protocol";
+import { completedUtcIntervalPosition, WakeSourceZod } from "@xyo-network/event-kit-schemas";
+import { PayloadBuilder } from "@xyo-network/sdk";
+import { asXL1BlockNumber } from "@xyo-network/xl1-sdk";
+import { FetchRequest, JsonRpcProvider } from "ethers";
+function publisherSourceKey(source) {
+  return createHash("sha256").update(canonicalJson(WakeSourceZod.parse(source))).digest("hex");
+}
+async function boundedPublisherOperation(operation, signal, timeoutMs = 1e4) {
+  const scope = publisherAbortScope([signal], timeoutMs);
+  const combined = scope.signal;
+  let rejectAbort;
+  const aborted = new Promise((_resolve, reject) => {
+    rejectAbort = () => reject(new Error("Publisher operation aborted or timed out"));
+    combined.addEventListener("abort", rejectAbort, { once: true });
+  });
+  try {
+    combined.throwIfAborted();
+    return await Promise.race([operation, aborted]);
+  } finally {
+    if (rejectAbort !== void 0)
+      combined.removeEventListener("abort", rejectAbort);
+    scope.dispose();
+  }
+}
+function createXl1PublisherSource(options) {
+  const source = WakeSourceZod.parse(options.source);
+  if (source.kind !== "xl1-finalized")
+    throw new Error("Expected an XL1 finalized source");
+  return {
+    source,
+    async head(signal) {
+      const chainId = String(await boundedPublisherOperation(Promise.resolve(options.viewer.chainId()), signal));
+      if (chainId !== source.chainId)
+        throw new Error("XL1 source chain identity changed");
+      const position = Number(await boundedPublisherOperation(Promise.resolve(options.viewer.finalization.headNumber()), signal));
+      if (!Number.isSafeInteger(position) || position < 0)
+        throw new Error("XL1 finalized head is invalid");
+      const block = await boundedPublisherOperation(Promise.resolve(options.viewer.block.blockByNumber(asXL1BlockNumber(position, true))), signal);
+      if (block?.[0].block !== position || !/^[0-9a-f]{64}$/u.test(block[0]._hash)) {
+        throw new Error("XL1 finalized head block is unavailable or inconsistent");
+      }
+      if (String(block[0].chain) !== source.chainId || await PayloadBuilder.hash(block[0]) !== block[0]._hash) {
+        throw new Error("XL1 finalized head block chain or hash is inconsistent");
+      }
+      return { position, hash: block[0]._hash };
+    }
+  };
+}
+function createEthereumFinalizedPublisherSource(options) {
+  const source = WakeSourceZod.parse(options.source);
+  if (source.kind !== "ethereum-finalized")
+    throw new Error("Expected an Ethereum finalized source");
+  const { chainId, genesisHash } = source;
+  const url = new URL(options.rpcUrl);
+  if (url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.hash !== "") {
+    throw new Error("Ethereum source RPC must use HTTPS without URL credentials or fragments");
+  }
+  const connection = new FetchRequest(url.href);
+  connection.timeout = options.requestTimeoutMs ?? 1e4;
+  const transport = createBoundedPublisherEthersTransport({
+    requestTimeoutMs: options.requestTimeoutMs,
+    maxResponseBytes: 2 * 1024 * 1024,
+    maxConcurrency: 8
+  });
+  connection.getUrlFunc = transport.getUrl;
+  connection.setThrottleParams({ maxAttempts: 1 });
+  const provider = new JsonRpcProvider(connection, void 0, { batchMaxCount: 1, cacheTimeout: -1 });
+  let reading;
+  let closed = false;
+  let closing;
+  const close = () => closing ??= (async () => {
+    closed = true;
+    provider.destroy();
+    await transport.close();
+  })();
+  const onAbort = () => {
+    void close();
+  };
+  async function read() {
+    const requests = [provider.getNetwork(), provider.getBlock(0), provider.getBlock("finalized")];
+    const values = await Promise.all(requests).catch(async (error) => {
+      await Promise.allSettled(requests);
+      throw error;
+    });
+    const [network, genesis, block] = values;
+    if (network.chainId.toString() !== chainId || genesis?.hash?.slice(2).toLowerCase() !== genesisHash) {
+      throw new Error("Ethereum source chain identity mismatch");
+    }
+    if (block?.hash === null || block === null || !/^0x[0-9a-fA-F]{64}$/u.test(block.hash) || !Number.isSafeInteger(block.number) || block.number < 0) throw new Error("Ethereum finalized head is unavailable");
+    return { position: block.number, hash: block.hash.slice(2).toLowerCase() };
+  }
+  return {
+    source,
+    close,
+    async head(signal) {
+      signal.throwIfAborted();
+      if (closed) throw new Error("Ethereum source is closed");
+      signal.addEventListener("abort", onAbort, { once: true });
+      reading ??= read().finally(() => {
+        reading = void 0;
+      });
+      try {
+        return await boundedPublisherOperation(reading, signal, options.requestTimeoutMs ?? 1e4);
+      } finally {
+        signal.removeEventListener("abort", onAbort);
+      }
+    }
+  };
+}
+function createUtcIntervalPublisherSource(options) {
+  const source = WakeSourceZod.parse(options.source);
+  if (source.kind !== "utc-interval")
+    throw new Error("Expected a UTC interval source");
+  const nowSeconds = options.nowSeconds ?? (() => Math.floor(Date.now() / 1e3));
+  return {
+    source,
+    async head(signal) {
+      signal.throwIfAborted();
+      const now = nowSeconds();
+      if (!Number.isSafeInteger(now) || now < 0)
+        throw new Error("UTC interval clock is invalid");
+      return { position: completedUtcIntervalPosition(source, now) ?? -1 };
+    }
+  };
+}
+
+// src/runtime/httpsTransport.ts
+var OptionsZod = z.strictObject({
+  allowedEndpoints: z.array(z.url()).min(1).max(64),
+  endpointHeaders: z.array(z.strictObject({
+    endpoint: z.url(),
+    headers: z.strictObject({ "x-vercel-protection-bypass": z.string().min(1).max(4096).regex(/^[\x21-\x7E]+$/u) })
+  })).max(64).default([]),
+  maxResponseBytes: z.number().int().min(1).max(1048576).default(65536),
+  requestTimeoutMs: z.number().int().min(100).max(6e4).default(1e4)
+});
+var nonPublicIpv4 = new BlockList();
+for (const [address, prefix] of [
+  ["0.0.0.0", 8],
+  ["10.0.0.0", 8],
+  ["100.64.0.0", 10],
+  ["127.0.0.0", 8],
+  ["169.254.0.0", 16],
+  ["172.16.0.0", 12],
+  ["192.0.0.0", 24],
+  ["192.0.2.0", 24],
+  ["192.88.99.0", 24],
+  ["192.168.0.0", 16],
+  ["198.18.0.0", 15],
+  ["198.51.100.0", 24],
+  ["203.0.113.0", 24],
+  ["224.0.0.0", 4],
+  ["240.0.0.0", 4]
+])
+  nonPublicIpv4.addSubnet(address, prefix, "ipv4");
+var globalIpv6 = new BlockList();
+globalIpv6.addSubnet("2000::", 3, "ipv6");
+var nonPublicIpv6 = new BlockList();
+for (const [address, prefix] of [
+  ["2001::", 23],
+  ["2001:db8::", 32],
+  ["2002::", 16],
+  ["3fff::", 20]
+])
+  nonPublicIpv6.addSubnet(address, prefix, "ipv6");
+function isPublicPublisherAddress(address) {
+  if (isIP(address) === 4)
+    return !nonPublicIpv4.check(address, "ipv4");
+  if (isIP(address) !== 6)
+    return false;
+  return globalIpv6.check(address, "ipv6") && !nonPublicIpv6.check(address, "ipv6");
+}
+function createPublisherHttpsTransport(input) {
+  const parsed = OptionsZod.safeParse(input);
+  if (!parsed.success) throw new Error("Invalid publisher HTTPS transport configuration");
+  const options = parsed.data;
+  const allowed = new Set(options.allowedEndpoints.map((endpoint) => {
+    const url = new URL(endpoint);
+    if (url.href !== endpoint || url.protocol !== "https:" || url.port !== "" && url.port !== "443" || url.username !== "" || url.password !== "" || url.hash !== "")
+      throw new Error("Publisher destinations must be canonical public HTTPS URLs on port 443");
+    const literal = url.hostname.replaceAll(/^\[|\]$/gu, "");
+    if (isIP(literal) !== 0 && !isPublicPublisherAddress(literal))
+      throw new Error("Publisher destination is not public");
+    if (url.hostname === "localhost" || url.hostname.endsWith(".localhost") || url.hostname.endsWith(".local"))
+      throw new Error("Publisher destination is not public");
+    return endpoint;
+  }));
+  const assertAllowed = (endpoint) => {
+    if (!allowed.has(endpoint))
+      throw new Error("Publisher destination is not explicitly allowed");
+  };
+  const endpointHeaders = /* @__PURE__ */ new Map();
+  for (const entry of options.endpointHeaders) {
+    assertAllowed(entry.endpoint);
+    if (endpointHeaders.has(entry.endpoint)) throw new Error("Duplicate publisher endpoint header configuration");
+    endpointHeaders.set(entry.endpoint, entry.headers);
+  }
+  return {
+    assertAllowed,
+    async post(endpoint, body, signal, jwt) {
+      assertAllowed(endpoint);
+      signal.throwIfAborted();
+      const url = new URL(endpoint);
+      const scope = publisherAbortScope([signal], options.requestTimeoutMs);
+      const combined = scope.signal;
+      try {
+        const addresses = await boundedPublisherOperation(lookup(url.hostname.replaceAll(/^\[|\]$/gu, ""), { all: true, verbatim: true }), combined, options.requestTimeoutMs);
+        combined.throwIfAborted();
+        if (addresses.length === 0 || addresses.some((item) => !isPublicPublisherAddress(item.address)))
+          throw new Error("Publisher DNS answer includes a non-public address");
+        const selected = addresses[0];
+        if (selected === void 0)
+          throw new Error("Publisher DNS lookup was empty");
+        const encoded = Buffer3.from(JSON.stringify(body));
+        if (encoded.byteLength > 65536)
+          throw new Error("Publisher request body is too large");
+        return await new Promise((resolve, reject) => {
+          const call = request(url, {
+            agent: false,
+            headers: {
+              ...endpointHeaders.get(endpoint),
+              "content-length": encoded.byteLength,
+              "content-type": "application/json",
+              ...jwt === void 0 ? {} : { authorization: `Bearer ${jwt}` }
+            },
+            lookup(_hostname, lookupOptions, callback) {
+              if (lookupOptions.all)
+                callback(null, [{ address: selected.address, family: selected.family }]);
+              else
+                callback(null, selected.address, selected.family);
+            },
+            method: "POST",
+            rejectUnauthorized: true,
+            signal: combined
+          }, (response) => {
+            const status = response.statusCode ?? 500;
+            if (status >= 300 && status < 400) {
+              response.destroy();
+              reject(new Error("Publisher HTTPS redirects are forbidden"));
+              return;
+            }
+            let size = 0;
+            const chunks = [];
+            response.on("data", (chunk) => {
+              size += chunk.byteLength;
+              if (size > options.maxResponseBytes) {
+                response.destroy();
+                reject(new Error("Publisher HTTPS response is too large"));
+              } else
+                chunks.push(chunk);
+            });
+            response.on("error", () => reject(new Error("Publisher HTTPS response failed")));
+            response.on("end", () => {
+              try {
+                const responseBody = size === 0 ? null : JSON.parse(Buffer3.concat(chunks).toString("utf8"));
+                const retry = Number(response.headers["retry-after"]);
+                resolve({
+                  status,
+                  body: responseBody,
+                  ...Number.isFinite(retry) && retry > 0 ? { retryAfterMs: Math.min(retry * 1e3, 36e5) } : {}
+                });
+              } catch {
+                reject(new Error("Publisher HTTPS response is not JSON"));
+              }
+            });
+          });
+          call.on("error", () => reject(new Error("Publisher HTTPS request failed")));
+          call.end(encoded);
+        });
+      } finally {
+        scope.dispose();
+      }
+    }
+  };
+}
+
+// src/runtime/publisherRuntime.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
+import { createMemoryLocator, PeriodicActor } from "@ariestools/actor";
+import { creatable } from "@ariestools/sdk";
+import { WakeEnvelopeSchema, WakeEnvelopeZod as WakeEnvelopeZod2 } from "@xyo-network/event-kit-schemas";
+import { z as z2 } from "zod";
+
+// src/runtime/sourceSigner.ts
+import { randomBytes } from "node:crypto";
+import {
+  NormalizedAddressZod,
+  WakeEnvelopeZod,
+  WakeJwtSchema
+} from "@xyo-network/event-kit-schemas";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk";
+function createAccountSourceWakeSigner(options) {
+  const publisher = NormalizedAddressZod.parse(options.publisher);
+  if (String(options.account.address).replace(/^0x/u, "").toLowerCase() !== publisher)
+    throw new Error("Publisher signing account mismatch");
+  return {
+    async sign(input, audience) {
+      const event = WakeEnvelopeZod.parse(input);
+      const eventHash = await PayloadBuilder2.dataHash(event);
+      const now = options.nowSeconds?.() ?? Math.floor(Date.now() / 1e3);
+      if (!Number.isSafeInteger(now) || now < 0)
+        throw new Error("Publisher signing clock is invalid");
+      const { token: jwt } = await options.account.signJwt({
+        audience,
+        claims: { eventHash, jti: randomBytes(16).toString("hex") },
+        now,
+        schema: WakeJwtSchema,
+        ttl: 60
+      });
+      return {
+        event,
+        eventHash,
+        jwt,
+        publisher
+      };
+    }
+  };
+}
+
+// src/runtime/publisherRuntime.ts
+function activationReady(status) {
+  return (status?.keyLoaded ?? true) && (status?.pendingSubscriptions ?? 0) === 0;
+}
+function assertDeliveryState(record, subscription) {
+  if (!isDeepStrictEqual(record.subscription, subscription))
+    throw new Error("Subscription revision changed without a new identity");
+  if (!Number.isSafeInteger(record.cursor) || record.cursor < subscription.fromPosition - 1 || ![record.delivered, record.failures, record.nextAttemptMs].every((value) => Number.isSafeInteger(value) && value >= 0) || !["active", "blocked", "cancelled"].includes(record.state))
+    throw new Error("Persisted publisher delivery state is invalid");
+  if (record.pending !== void 0) {
+    const pending = WakeEnvelopeZod2.parse(record.pending);
+    if (pending.fromPosition !== record.cursor + 1 || pending.toPosition - pending.fromPosition + 1 > subscription.maxPositionsPerWake || pending.authorizationChainId !== subscription.authorizationChainId || pending.deploymentId !== subscription.deploymentId || pending.queueId !== subscription.queueId || pending.filterHash !== subscription.filterHash || !isDeepStrictEqual(pending.source, subscription.source))
+      throw new Error("Persisted publisher outbox binding is invalid");
+  }
+}
+function makeEvent(subscription, fromPosition, toPosition, now, wakeId = randomBytes2(16).toString("hex")) {
+  return WakeEnvelopeZod2.parse({
+    schema: WakeEnvelopeSchema,
+    authorizationChainId: subscription.authorizationChainId,
+    deploymentId: subscription.deploymentId,
+    filterHash: subscription.filterHash,
+    fromPosition,
+    issuedAt: now,
+    source: subscription.source,
+    toPosition,
+    wakeId,
+    ...subscription.queueId === void 0 ? {} : { queueId: subscription.queueId }
+  });
+}
+var PublisherRuntimeActor = class extends PeriodicActor {
+  async runPass(context) {
+    await this.params.tick(context.signal);
+  }
+};
+PublisherRuntimeActor = __decorateClass([
+  creatable()
+], PublisherRuntimeActor);
+var TimingZod = z2.object({
+  concurrency: z2.number().int().min(1).max(32).default(4),
+  intervalMs: z2.number().int().min(100).max(6e4).default(1e3),
+  maxSubscriptions: z2.number().int().min(1).max(1024).default(64),
+  requestTimeoutMs: z2.number().int().min(100).max(6e4).default(1e4)
+});
+var DeliveryResponseError = class extends Error {
+  retryAfterMs;
+  status;
+  constructor(status, retryAfterMs) {
+    super("Publisher admission failed");
+    this.status = status;
+    this.retryAfterMs = retryAfterMs;
+  }
+  get retryable() {
+    return this.status === 408 || this.status === 429 || this.status >= 500;
+  }
+};
+async function createPersistentEventPublisherRuntime(options) {
+  const timing = TimingZod.parse(options);
+  if (options.sources.length < 1 || options.sources.length > 16)
+    throw new Error("Publisher requires between one and sixteen bounded sources");
+  const clock = options.nowSeconds ?? (() => Math.floor(Date.now() / 1e3));
+  const signer = createAccountSourceWakeSigner({
+    account: options.account,
+    publisher: options.publisher,
+    nowSeconds: clock
+  });
+  const sourceReaders = new Map(options.sources.map((reader) => [publisherSourceKey(reader.source), reader]));
+  if (sourceReaders.size !== options.sources.length)
+    throw new Error("Duplicate publisher source identity");
+  const abort = new AbortController();
+  let running = false;
+  let ready = false;
+  let clockHealthy = true;
+  let passes = 0;
+  let lastError;
+  let sourcesHealthy = false;
+  let stop;
+  const state = options.state;
+  const timed = (promise, signal) => boundedPublisherOperation(promise, signal, timing.requestTimeoutMs);
+  function loadDelivery(subscription, now) {
+    const key = subscription.subscriptionHash;
+    let record = state.get("deliveries", key);
+    if (record === void 0) {
+      makeEvent(subscription, subscription.fromPosition, subscription.fromPosition, now, "0".repeat(32));
+      if (!Number.isSafeInteger(subscription.maxPositionsPerWake) || subscription.maxPositionsPerWake < 1 || subscription.maxPositionsPerWake > 4096) {
+        throw new Error("Invalid source range budget");
+      }
+      record = {
+        subscription,
+        cursor: subscription.fromPosition - 1,
+        delivered: 0,
+        failures: 0,
+        nextAttemptMs: 0,
+        state: "active"
+      };
+      state.set("deliveries", key, record);
+    }
+    assertDeliveryState(record, subscription);
+    return record;
+  }
+  function prepareDelivery(record, now, heads) {
+    if (record.pending !== void 0) return { ...record, pending: record.pending };
+    const subscription = record.subscription;
+    const head = heads.get(publisherSourceKey(subscription.source));
+    if (head === void 0 || head instanceof Error) throw new Error("Configured source is unavailable");
+    if (head.position <= record.cursor) return;
+    const fromPosition = record.cursor + 1;
+    const pending = makeEvent(subscription, fromPosition, Math.min(head.position, fromPosition + subscription.maxPositionsPerWake - 1), now);
+    const prepared = { ...record, pending };
+    state.transaction(() => {
+      const logicalKey = JSON.stringify([subscription.subscriptionHash, pending.fromPosition, pending.toPosition]);
+      if (!state.insert("delivery-events", logicalKey, pending)) throw new Error("Publisher logical range already exists outside its contiguous cursor");
+      state.set("deliveries", subscription.subscriptionHash, prepared);
+    });
+    return prepared;
+  }
+  async function stillActive(record, signal) {
+    if (await timed(options.discovery.isActive(record.subscription, signal), signal)) return true;
+    state.set("deliveries", record.subscription.subscriptionHash, {
+      ...record,
+      pending: void 0,
+      state: "cancelled"
+    });
+    return false;
+  }
+  async function sendDelivery(record, signal, now) {
+    const { pending, subscription } = record;
+    signal.throwIfAborted();
+    const signed = await signer.sign(pending, subscription.audience);
+    signal.throwIfAborted();
+    const attempt = state.get("delivery-attempts", pending.wakeId)?.count ?? 0;
+    state.set("delivery-attempts", pending.wakeId, {
+      count: attempt + 1,
+      startedAt: now,
+      status: "in-flight"
+    });
+    const response = await options.transport.post(subscription.endpoint, signed.event, signal, signed.jwt);
+    state.set("delivery-attempts", pending.wakeId, {
+      count: attempt + 1,
+      startedAt: now,
+      status: response.status
+    });
+    if (response.status !== 200 && response.status !== 202) throw new DeliveryResponseError(response.status, response.retryAfterMs);
+    const receipt = z2.object({ receiptId: z2.string().min(1), wakeId: z2.literal(pending.wakeId) }).safeParse(response.body);
+    if (!receipt.success) throw new Error("Publisher admission did not return a matching durable receipt");
+    signal.throwIfAborted();
+    state.transaction(() => {
+      state.set("delivery-receipts", pending.wakeId, { receiptId: receipt.data.receiptId, receivedAt: now });
+      state.set("deliveries", subscription.subscriptionHash, {
+        subscription,
+        cursor: pending.toPosition,
+        delivered: record.delivered + 1,
+        failures: 0,
+        nextAttemptMs: 0,
+        state: "active"
+      });
+    });
+  }
+  async function deliver(subscription, signal, now, heads) {
+    let record = loadDelivery(subscription, now);
+    if (record.state !== "active" || record.nextAttemptMs > now * 1e3) return;
+    try {
+      if (!await stillActive(record, signal)) return;
+      options.transport.assertAllowed(subscription.endpoint);
+      if (!sourceReaders.has(publisherSourceKey(subscription.source))) throw new Error("Subscription source is not configured");
+      const prepared = prepareDelivery(record, now, heads);
+      if (prepared === void 0) return;
+      record = prepared;
+      if (!await stillActive(record, signal)) return;
+      await sendDelivery(prepared, signal, now);
+    } catch (error) {
+      if (signal.aborted) return;
+      state.set("deliveries", subscription.subscriptionHash, {
+        ...record,
+        failures: record.failures + 1,
+        state: error instanceof DeliveryResponseError && !error.retryable ? "blocked" : "active",
+        nextAttemptMs: now * 1e3 + Math.min(36e5, error instanceof DeliveryResponseError && error.retryAfterMs !== void 0 ? error.retryAfterMs : Math.min(3e5, 1e3 * 2 ** Math.min(record.failures, 8))),
+        lastError: "delivery-failed"
+      });
+    }
+  }
+  async function readSources(signal) {
+    const heads = /* @__PURE__ */ new Map();
+    const results = await Promise.allSettled([...sourceReaders].map(async ([key, reader]) => {
+      const head = await timed(reader.head(signal), signal);
+      if (!Number.isSafeInteger(head.position) || head.position < -1)
+        throw new Error("Source head is invalid");
+      const previous = state.get("source-heads", key);
+      if (previous !== void 0 && (head.position < previous.position || head.position === previous.position && head.hash !== previous.hash)) {
+        throw new Error("Finalized source regressed or changed hash");
+      }
+      signal.throwIfAborted();
+      state.set("source-heads", key, head);
+      heads.set(key, head);
+    }));
+    sourcesHealthy = results.every((item) => item.status === "fulfilled");
+    for (const [index, result] of results.entries())
+      if (result.status === "rejected") {
+        const key = [...sourceReaders.keys()][index];
+        if (key !== void 0)
+          heads.set(key, new Error("Source read failed"));
+      }
+    return heads;
+  }
+  async function reconcileDeliveries(subscriptions, signal) {
+    if (subscriptions.length > timing.maxSubscriptions) throw new Error("Publisher subscription limit exceeded");
+    const active = new Set(subscriptions.map((subscription) => subscription.subscriptionHash));
+    if (active.size !== subscriptions.length) throw new Error("Duplicate subscription identity");
+    const unavailable = state.entries("deliveries").filter((item) => !active.has(item.key) && item.value.state !== "cancelled");
+    let available = true;
+    for (let offset = 0; offset < unavailable.length; offset += timing.concurrency) {
+      signal.throwIfAborted();
+      const results = await Promise.allSettled(unavailable.slice(offset, offset + timing.concurrency).map(async ({ key, value }) => {
+        const stillAuthorized = await timed(options.discovery.isActive(value.subscription, signal), signal);
+        if (!stillAuthorized) state.set("deliveries", key, {
+          ...value,
+          pending: void 0,
+          state: "cancelled"
+        });
+        return stillAuthorized;
+      }));
+      available = available && results.every((result) => result.status === "fulfilled" && !result.value);
+    }
+    return available;
+  }
+  async function tick(actorSignal) {
+    const scope = publisherAbortScope([abort.signal, actorSignal]);
+    const signal = scope.signal;
+    try {
+      signal.throwIfAborted();
+      const now = clock();
+      const prior = state.get("runtime", "highest-wall-clock") ?? 0;
+      clockHealthy = Number.isSafeInteger(now) && now >= prior;
+      if (!clockHealthy)
+        throw new Error("Publisher clock moved backwards");
+      state.set("runtime", "highest-wall-clock", now);
+      const subscriptions = await timed(options.discovery.discover(signal), signal);
+      const subscriptionsAvailable = await reconcileDeliveries(subscriptions, signal);
+      const heads = await readSources(signal);
+      for (let offset = 0; offset < subscriptions.length; offset += timing.concurrency) {
+        signal.throwIfAborted();
+        const outcomes = await Promise.allSettled(subscriptions.slice(offset, offset + timing.concurrency).map((subscription) => deliver(subscription, signal, now, heads)));
+        const failed = outcomes.find((result) => result.status === "rejected");
+        if (failed?.status === "rejected")
+          throw failed.reason;
+      }
+      if (options.discovery.acceptPending !== void 0)
+        await timed(options.discovery.acceptPending(signal), signal);
+      const discoveryStatus = options.discovery.status?.();
+      ready = subscriptionsAvailable && sourcesHealthy && activationReady(discoveryStatus);
+      lastError = subscriptionsAvailable ? void 0 : "publisher-subscription-unavailable";
+      passes += 1;
+    } catch (error) {
+      ready = false;
+      lastError = clockHealthy ? "publisher-pass-failed" : "publisher-clock-unhealthy";
+      if (!signal.aborted)
+        throw error;
+    } finally {
+      scope.dispose();
+    }
+  }
+  const actor = await PublisherRuntimeActor.create({
+    locator: createMemoryLocator({}),
+    intervalMs: timing.intervalMs,
+    firstRun: "immediate",
+    readiness: "immediate",
+    tick
+  });
+  return {
+    async start() {
+      if (stop !== void 0)
+        throw new Error("Publisher is stopped");
+      if (!running) {
+        await actor.start();
+        running = true;
+      }
+    },
+    async runOnce() {
+      if (stop !== void 0)
+        throw new Error("Publisher is stopped");
+      await actor.runOnce();
+    },
+    stop() {
+      return stop ??= (async () => {
+        abort.abort();
+        const failures = [];
+        try {
+          await actor.stop();
+        } catch (error) {
+          failures.push(error);
+        }
+        try {
+          await options.discovery.close?.();
+        } catch (error) {
+          failures.push(error);
+        }
+        for (const source of options.sources)
+          try {
+            await source.close?.();
+          } catch (error) {
+            failures.push(error);
+          }
+        running = false;
+        ready = false;
+        if (failures.length > 0)
+          throw new AggregateError(failures, "Publisher runtime shutdown failed");
+      })();
+    },
+    status() {
+      const deliveries = state.entries("deliveries").map((item) => item.value);
+      return {
+        running,
+        ready: running && ready,
+        clockHealthy,
+        degraded: !ready || deliveries.some((item) => item.state !== "cancelled" && item.failures > 0),
+        publisher: options.publisher,
+        activeSubscriptions: deliveries.filter((item) => item.state === "active").length,
+        pendingDeliveries: deliveries.filter((item) => item.pending !== void 0).length,
+        delivered: deliveries.reduce((sum, item) => sum + item.delivered, 0),
+        failures: deliveries.reduce((sum, item) => sum + item.failures, 0),
+        passes,
+        ...lastError === void 0 ? {} : { lastError },
+        ...options.discovery.status === void 0 ? {} : { handshake: options.discovery.status() },
+        sources: state.entries("source-heads").map((item) => ({ id: item.key, ...item.value })),
+        subscriptions: state.entries("deliveries").map((item) => ({
+          id: item.key,
+          cursor: item.value.cursor,
+          state: item.value.state,
+          pending: item.value.pending !== void 0,
+          failures: item.value.failures
+        }))
+      };
+    }
+  };
+}
+
+// src/runtime/restGateway.ts
+import { FetchJsonClient } from "@ariestools/sdk";
+import {
+  baseConfigFactoryLocator,
+  basicRestRunnerLocator,
+  basicRestViewerLocator,
+  creatableProvider,
+  releaseProviderFactoryLocator,
+  RestDataLakeRunner,
+  RestDataLakeViewer,
+  XyoGatewayMoniker,
+  XyoGatewayRunnerMoniker
+} from "@xyo-network/xl1-sdk";
+async function openPublisherRestGateway(options) {
+  const rest = {
+    finalized: { type: "rest", baseUrl: options.finalizedUrl },
+    chainState: { type: "rest", baseUrl: options.chainStateUrl },
+    index: { type: "rest", baseUrl: options.indexUrl ?? options.finalizedUrl }
+  };
+  const locator = options.account === void 0 ? await basicRestViewerLocator("event-kit-publisher-read", rest, void 0, { fetchFn: options.fetchFn, primeCaches: "off" }) : await basicRestRunnerLocator("event-kit-publisher-write", rest, void 0, {
+    fetchFn: options.fetchFn,
+    primeCaches: "off",
+    rpcUrl: options.rpcUrl,
+    signerAccount: options.account
+  });
+  try {
+    const gateway = options.account === void 0 ? await locator.getInstance(XyoGatewayMoniker) : await locator.getInstance(XyoGatewayRunnerMoniker);
+    let stopping;
+    return Object.freeze({ gateway, stop: () => stopping ??= releaseProviderFactoryLocator(locator) });
+  } catch (error) {
+    await releaseProviderFactoryLocator(locator);
+    throw error;
+  }
+}
+var BoundedRestDataLakeViewer = class extends RestDataLakeViewer {
+  get client() {
+    if (this.context.fetchFn === void 0)
+      throw new Error("Publisher datalake requires its bounded fetch transport");
+    return new FetchJsonClient({ fetcher: this.context.fetchFn });
+  }
+};
+BoundedRestDataLakeViewer = __decorateClass([
+  creatableProvider()
+], BoundedRestDataLakeViewer);
+var BoundedRestDataLakeRunner = class extends RestDataLakeRunner {
+  get client() {
+    if (this.context.fetchFn === void 0)
+      throw new Error("Publisher datalake requires its bounded fetch transport");
+    return new FetchJsonClient({ fetcher: this.context.fetchFn });
+  }
+};
+BoundedRestDataLakeRunner = __decorateClass([
+  creatableProvider()
+], BoundedRestDataLakeRunner);
+async function openPublisherDataLake(options) {
+  const locator = await baseConfigFactoryLocator({
+    connections: { "event-kit-lake": { type: "rest", baseUrl: options.url } },
+    providerBindings: { DataLakeViewer: { connection: "event-kit-lake" }, DataLakeRunner: { connection: "event-kit-lake" } }
+  });
+  locator.context.fetchFn = options.fetchFn;
+  locator.register(BoundedRestDataLakeViewer.factory(BoundedRestDataLakeViewer.dependencies));
+  if (options.writable)
+    locator.register(BoundedRestDataLakeRunner.factory(BoundedRestDataLakeRunner.dependencies));
+  locator.freeze();
+  try {
+    const reader = await locator.getInstance(BoundedRestDataLakeViewer.defaultMoniker);
+    const writer = options.writable ? await locator.getInstance(BoundedRestDataLakeRunner.defaultMoniker) : void 0;
+    return {
+      reader,
+      writer,
+      async close() {
+        await releaseProviderFactoryLocator(locator);
+      }
+    };
+  } catch (error) {
+    await releaseProviderFactoryLocator(locator);
+    throw error;
+  }
+}
+
+// src/runtime/sqliteHandshakeStores.ts
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
+import { endpointChallengeHash } from "@xyo-network/event-kit-protocol";
+import {
+  Base64Url32BytesZod as Base64Url32BytesZod2,
+  EndpointChallengeZod as EndpointChallengeZod2,
+  HandshakeIdZod as HandshakeIdZod2,
+  HashZod as HashZod2,
+  NormalizedAddressZod as NormalizedAddressZod3
+} from "@xyo-network/event-kit-schemas";
+import { z as z4 } from "zod";
+
+// src/handshakeMutationIntent.ts
+import {
+  canonicalJsonBytes,
+  handshakeObjectHash
+} from "@xyo-network/event-kit-protocol";
+import {
+  Base64Url32BytesZod,
+  ChainIdZod,
+  EncryptedWakeSubscriptionZod,
+  EndpointChallengeResponseZod as EndpointChallengeResponseZod2,
+  EndpointChallengeZod,
+  HandshakeIdZod,
+  HashZod,
+  NormalizedAddressZod as NormalizedAddressZod2,
+  PublisherEncryptionKeyRevocationZod,
+  PublisherEncryptionKeyZod,
+  PublisherServiceRevocationZod,
+  PublisherServiceZod,
+  WakeGrantObjectZod,
+  WakeGrantRevocationZod,
+  WakeSubscriptionAcceptanceZod,
+  WakeSubscriptionRevocationZod
+} from "@xyo-network/event-kit-schemas";
+import { z as z3 } from "zod";
+var HandshakeMutationIntentKinds = [
+  "publisher-encryption-key-retire",
+  "publisher-service-publish",
+  "publisher-service-retire",
+  "publisher-service-rotate-key",
+  "publisher-subscription-accept",
+  "subscriber-grant-revoke",
+  "subscriber-subscription-revoke",
+  "subscriber-subscription-subscribe"
+];
+var HandshakeMutationIntentKindZod = z3.enum(HandshakeMutationIntentKinds);
+var HandshakeMutationOperationIdZod = z3.union([HandshakeIdZod, HashZod]);
+var WakeSubscriptionPrivateKeyZod = z3.strictObject({
+  encryptionKey: HashZod,
+  keyId: HandshakeIdZod,
+  privateKey: Base64Url32BytesZod
+});
+var IntentBaseFields = {
+  chainId: ChainIdZod,
+  operationId: HandshakeMutationOperationIdZod,
+  publisher: NormalizedAddressZod2,
+  requestFingerprint: HashZod,
+  source: NormalizedAddressZod2,
+  version: z3.literal(1)
+};
+var PublisherServicePublishIntentZod = z3.strictObject({
+  ...IntentBaseFields,
+  kind: z3.literal("publisher-service-publish"),
+  operationId: HandshakeIdZod,
+  encryptionKey: PublisherEncryptionKeyZod,
+  privateKey: WakeSubscriptionPrivateKeyZod,
+  service: PublisherServiceZod
+});
+var PublisherServiceRotateKeyIntentZod = z3.strictObject({
+  ...IntentBaseFields,
+  kind: z3.literal("publisher-service-rotate-key"),
+  operationId: HandshakeIdZod,
+  encryptionKey: PublisherEncryptionKeyZod,
+  privateKey: WakeSubscriptionPrivateKeyZod,
+  selectedKey: HashZod,
+  selectedService: HashZod,
+  service: PublisherServiceZod
+});
+var SubscriberSubscriptionIntentZod = z3.strictObject({
+  ...IntentBaseFields,
+  kind: z3.literal("subscriber-subscription-subscribe"),
+  operationId: HandshakeIdZod,
+  encryptionKey: PublisherEncryptionKeyZod,
+  grant: WakeGrantObjectZod,
+  selectedKey: HashZod,
+  selectedService: HashZod,
+  service: PublisherServiceZod,
+  subscription: EncryptedWakeSubscriptionZod
+});
+var PublisherAcceptanceIntentZod = z3.strictObject({
+  ...IntentBaseFields,
+  acceptance: WakeSubscriptionAcceptanceZod,
+  challenge: EndpointChallengeZod,
+  kind: z3.literal("publisher-subscription-accept"),
+  operationId: HashZod,
+  response: EndpointChallengeResponseZod2
+});
+var PublisherServiceRetireIntentZod = z3.strictObject({
+  ...IntentBaseFields,
+  kind: z3.literal("publisher-service-retire"),
+  operationId: HashZod,
+  revocation: PublisherServiceRevocationZod
+});
+var PublisherEncryptionKeyRetireIntentZod = z3.strictObject({
+  ...IntentBaseFields,
+  kind: z3.literal("publisher-encryption-key-retire"),
+  operationId: HashZod,
+  revocation: PublisherEncryptionKeyRevocationZod
+});
+var SubscriberGrantRevokeIntentZod = z3.strictObject({
+  ...IntentBaseFields,
+  kind: z3.literal("subscriber-grant-revoke"),
+  operationId: HashZod,
+  revocation: WakeGrantRevocationZod
+});
+var SubscriberSubscriptionRevokeIntentZod = z3.strictObject({
+  ...IntentBaseFields,
+  kind: z3.literal("subscriber-subscription-revoke"),
+  operationId: HashZod,
+  revocation: WakeSubscriptionRevocationZod
+});
+var HandshakeMutationIntentZod = z3.discriminatedUnion("kind", [
+  PublisherEncryptionKeyRetireIntentZod,
+  PublisherServicePublishIntentZod,
+  PublisherServiceRetireIntentZod,
+  PublisherServiceRotateKeyIntentZod,
+  PublisherAcceptanceIntentZod,
+  SubscriberGrantRevokeIntentZod,
+  SubscriberSubscriptionRevokeIntentZod,
+  SubscriberSubscriptionIntentZod
+]);
+var HandshakeMutationIntentConflictError = class extends Error {
+  constructor(message = "Handshake mutation operation ID is already bound to different intent") {
+    super(message);
+    this.name = "HandshakeMutationIntentConflictError";
+  }
+};
+function parseHandshakeMutationIntentLookup(value) {
+  return Object.freeze({
+    chainId: ChainIdZod.parse(value.chainId),
+    kind: HandshakeMutationIntentKindZod.parse(value.kind),
+    operationId: HandshakeMutationOperationIdZod.parse(value.operationId),
+    publisher: NormalizedAddressZod2.parse(value.publisher),
+    source: NormalizedAddressZod2.parse(value.source)
+  });
+}
+async function parseHandshakeMutationIntent(value) {
+  const intent = HandshakeMutationIntentZod.parse(value);
+  await assertIntentIntegrity(intent);
+  return Object.freeze(intent);
+}
+function intentLookupKey(lookup2) {
+  const parsed = parseHandshakeMutationIntentLookup(lookup2);
+  return [parsed.chainId, parsed.publisher, parsed.source, parsed.kind, parsed.operationId].join("/");
+}
+function assertSameIntentBinding(left, right) {
+  const shared = left.version === right.version && left.chainId === right.chainId && left.kind === right.kind && left.operationId === right.operationId && left.publisher === right.publisher && left.source === right.source && left.requestFingerprint === right.requestFingerprint;
+  const bothRotate = left.kind === "publisher-service-rotate-key" && right.kind === "publisher-service-rotate-key";
+  const bothSubscribe = left.kind === "subscriber-subscription-subscribe" && right.kind === "subscriber-subscription-subscribe";
+  const selected = bothRotate || bothSubscribe ? left.selectedService === right.selectedService && left.selectedKey === right.selectedKey : !("selectedService" in left) && !("selectedService" in right);
+  if (!shared || !selected) throw new HandshakeMutationIntentConflictError();
+}
+async function assertIntentIntegrity(intent) {
+  if (intent.kind.startsWith("publisher-") && intent.source !== intent.publisher) {
+    throw new TypeError("Publisher mutation intent source must equal publisher");
+  }
+  if (intent.kind === "publisher-service-publish" || intent.kind === "publisher-service-rotate-key") {
+    await assertPublisherServiceIntent(intent);
+    return;
+  }
+  if (intent.kind === "subscriber-subscription-subscribe") {
+    await assertSubscriberSubscriptionIntent(intent);
+    return;
+  }
+  if (intent.kind === "publisher-subscription-accept") {
+    await assertPublisherAcceptanceIntent(intent);
+    return;
+  }
+  await assertRevocationIntent(intent);
+}
+async function assertPublisherServiceIntent(intent) {
+  const keyHash = await handshakeObjectHash(intent.encryptionKey);
+  if (intent.privateKey.encryptionKey !== keyHash || intent.privateKey.keyId !== intent.encryptionKey.keyId || intent.service.preferredEncryptionKey !== keyHash || intent.service.encryptionKeys.length !== 1 || intent.service.encryptionKeys[0] !== keyHash) {
+    throw new TypeError("Publisher service mutation intent has inconsistent encryption-key artifacts");
+  }
+  if (intent.kind === "publisher-service-publish") {
+    if (intent.service.revision !== 1 || intent.service.supersedes !== void 0) {
+      throw new TypeError("Publisher service root intent must contain a root service revision");
+    }
+  } else if (intent.service.supersedes !== intent.selectedService || intent.service.revision <= 1) {
+    throw new TypeError("Publisher service rotation intent does not extend its selected service");
+  }
+}
+async function assertSubscriberSubscriptionIntent(intent) {
+  const [keyHash, serviceHash, grantHash] = await Promise.all([
+    handshakeObjectHash(intent.encryptionKey),
+    handshakeObjectHash(intent.service),
+    handshakeObjectHash(intent.grant)
+  ]);
+  if (keyHash !== intent.selectedKey || serviceHash !== intent.selectedService || intent.service.preferredEncryptionKey !== keyHash || !intent.service.encryptionKeys.includes(keyHash) || intent.grant.publisher !== intent.publisher || intent.subscription.publisher !== intent.publisher || intent.subscription.service !== serviceHash || intent.subscription.encryptionKey !== keyHash || intent.subscription.keyId !== intent.encryptionKey.keyId || intent.subscription.grant !== grantHash) {
+    throw new TypeError("Subscriber subscription intent has inconsistent public artifacts");
+  }
+}
+async function assertPublisherAcceptanceIntent(intent) {
+  const [challengeHash, responseHash] = await Promise.all([
+    handshakeObjectHash(intent.challenge),
+    handshakeObjectHash(intent.response)
+  ]);
+  if (challengeHash !== intent.operationId || intent.challenge.publisher !== intent.publisher || intent.response.challenge !== challengeHash || intent.acceptance.challenge !== challengeHash || intent.acceptance.response !== responseHash || intent.acceptance.service !== intent.challenge.service || intent.acceptance.encryptionKey !== intent.challenge.encryptionKey || intent.acceptance.grant !== intent.challenge.grant || intent.acceptance.subscription !== intent.challenge.subscription) {
+    throw new TypeError("Publisher acceptance intent has inconsistent public artifacts");
+  }
+}
+async function assertRevocationIntent(intent) {
+  const target = intent.kind === "publisher-encryption-key-retire" ? intent.revocation.key : intent.kind === "publisher-service-retire" ? intent.revocation.service : intent.kind === "subscriber-grant-revoke" ? intent.revocation.grant : intent.revocation.subscription;
+  if (target !== intent.operationId) {
+    throw new TypeError("Handshake revocation intent has inconsistent target binding");
+  }
+}
+
+// src/runtime/sqliteHandshakeStores.ts
+var KeyZod = z4.strictObject({
+  encryptionKey: HashZod2,
+  keyId: HandshakeIdZod2,
+  privateKey: Base64Url32BytesZod2,
+  publisher: NormalizedAddressZod3
+});
+var phases = ["signed", "content-written", "content-verified", "broadcast", "included", "finalized"];
+function requireTime(value) {
+  if (!Number.isSafeInteger(value) || value < 0) throw new Error("Publisher clock is invalid");
+}
+function samePublicationIntent(left, right) {
+  return left.chainId === right.chainId && left.source === right.source && left.operationId === right.operationId && isDeepStrictEqual2(left.eventHashes, right.eventHashes) && isDeepStrictEqual2(left.attachmentHashes, right.attachmentHashes);
+}
+function publicationKey(intent) {
+  if (!/^[0-9a-f]{40}$/u.test(intent.chainId) || !/^[0-9a-f]{40}$/u.test(intent.source) || intent.operationId.length === 0 || intent.operationId.length > 256 || ![...intent.eventHashes, ...intent.attachmentHashes].every((hash) => HashZod2.safeParse(hash).success)) {
+    throw new Error("Invalid publication intent");
+  }
+  return JSON.stringify([intent.chainId, intent.source, intent.operationId]);
+}
+function createSqlitePublisherHandshakeStores(state) {
+  const replay = {
+    async load() {
+      return state.get("replay", "checkpoint");
+    },
+    async save(checkpoint) {
+      state.set("replay", "checkpoint", checkpoint);
+    }
+  };
+  const intents = {
+    async get(lookup2) {
+      const value = state.get("intents", intentLookupKey(lookup2));
+      return value === void 0 ? void 0 : await parseHandshakeMutationIntent(value);
+    },
+    async getOrCreate(raw) {
+      const proposed = await parseHandshakeMutationIntent(raw);
+      return state.transaction(() => {
+        const key = intentLookupKey(proposed);
+        const winner = state.get("intents", key);
+        if (winner !== void 0) {
+          assertSameIntentBinding(winner, proposed);
+          return { disposition: "resumed", intent: winner };
+        }
+        state.set("intents", key, proposed);
+        return { disposition: "created", intent: proposed };
+      });
+    }
+  };
+  const keys = {
+    async getPrivateKey(input) {
+      const key = `${NormalizedAddressZod3.parse(input.publisher)}:${HandshakeIdZod2.parse(input.keyId)}`;
+      const raw = state.get("encryption-keys", key);
+      if (raw === void 0) return;
+      const record = KeyZod.parse(raw);
+      if (record.encryptionKey !== HashZod2.parse(input.encryptionKey)) throw new Error("Encryption key identity mismatch");
+      const { publisher: _publisher, ...privateKey } = record;
+      return privateKey;
+    },
+    async putPrivateKey(input) {
+      const record = KeyZod.parse({ ...input.key, publisher: input.publisher });
+      return state.transaction(() => {
+        const key = `${record.publisher}:${record.keyId}`;
+        const prior = state.get("encryption-keys", key);
+        if (prior !== void 0) {
+          if (!isDeepStrictEqual2(prior, record)) throw new Error("Encryption key collision");
+          return "duplicate";
+        }
+        state.set("encryption-keys", key, record);
+        return "stored";
+      });
+    }
+  };
+  const current = (hash) => state.get("challenges", HashZod2.parse(hash));
+  const live = (record, now) => record.challenge.issuedAt <= now && now < record.challenge.expiresAt;
+  const challenges = {
+    async get(hash) {
+      return current(hash);
+    },
+    async issue(input) {
+      const challenge = EndpointChallengeZod2.parse(input.challenge);
+      const hash = HashZod2.parse(input.challengeHash);
+      if (await endpointChallengeHash(challenge) !== hash) return { kind: "collision" };
+      return state.transaction(() => {
+        const priorNonce = state.get("challenge-nonces", challenge.nonce);
+        if (priorNonce !== void 0 && priorNonce !== hash) return { kind: "collision" };
+        const prior = current(hash);
+        if (prior !== void 0) return isDeepStrictEqual2(prior.challenge, challenge) ? { kind: "duplicate", record: prior } : { kind: "collision" };
+        const record = {
+          challenge,
+          challengeHash: hash,
+          state: "issued"
+        };
+        state.set("challenge-nonces", challenge.nonce, hash);
+        state.set("challenges", hash, record);
+        return { kind: "issued", record };
+      });
+    },
+    async beginAttempt(input) {
+      requireTime(input.nowSeconds);
+      return state.transaction(() => {
+        const record = current(input.challengeHash);
+        if (record === void 0) return { kind: "missing" };
+        if (record.state === "verified") return { kind: "verified", record };
+        if (record.state === "attempted") return { kind: "already-attempted", record };
+        if (!live(record, input.nowSeconds)) return { kind: "expired", record };
+        const attempted = { ...record, state: "attempted" };
+        state.set("challenges", input.challengeHash, attempted);
+        return { kind: "started", record: attempted };
+      });
+    },
+    async completeVerified(input) {
+      requireTime(input.nowSeconds);
+      const responseHash = HashZod2.parse(input.responseHash);
+      return state.transaction(() => {
+        const record = current(input.challengeHash);
+        if (record === void 0) return { kind: "missing" };
+        if (record.state === "verified") return { kind: record.responseHash === responseHash ? "duplicate" : "collision", record };
+        if (record.state !== "attempted") return { kind: "not-attempted", record };
+        if (!live(record, input.nowSeconds)) return { kind: "expired", record };
+        const verified = {
+          ...record,
+          responseHash,
+          state: "verified"
+        };
+        state.set("challenges", input.challengeHash, verified);
+        return { kind: "verified", record: verified };
+      });
+    }
+  };
+  const journal = {
+    async load(intent) {
+      const key = publicationKey(intent);
+      const signed = state.get("publication:signed", key);
+      if (signed === void 0) return;
+      if (!samePublicationIntent(signed, intent)) throw new Error("Publication intent collision");
+      let latest = signed;
+      for (const phase of phases) {
+        const record = state.get(`publication:${phase}`, key);
+        if (record === void 0) continue;
+        if (record.phase !== phase || !samePublicationIntent(record, intent) || !isDeepStrictEqual2(record.evidence, signed.evidence)) {
+          throw new Error("Publication evidence collision");
+        }
+        latest = record;
+      }
+      return latest;
+    },
+    async save(record) {
+      const key = publicationKey(record);
+      HashZod2.parse(record.evidence.transactionHash);
+      if (!phases.includes(record.phase)) throw new Error("Unknown publication phase");
+      state.transaction(() => {
+        const signed = state.get("publication:signed", key);
+        if (signed === void 0 && record.phase !== "signed") throw new Error("Publication must bind signed evidence first");
+        if (signed !== void 0 && (!samePublicationIntent(signed, record) || !isDeepStrictEqual2(signed.evidence, record.evidence))) {
+          throw new Error("Publication intent or evidence collision");
+        }
+        const namespace = `publication:${record.phase}`;
+        const prior = state.get(namespace, key);
+        if (prior !== void 0 && !isDeepStrictEqual2(prior, record)) throw new Error("Publication phase collision");
+        if (prior === void 0) state.set(namespace, key, record);
+      });
+    }
+  };
+  return {
+    challenges,
+    intents,
+    journal,
+    keys,
+    replay
+  };
+}
+
+// src/runtime/sqlitePublisherState.ts
+import { randomBytes as randomBytes3 } from "node:crypto";
+import { constants } from "node:fs";
+import {
+  lstat,
+  mkdir,
+  open
+} from "node:fs/promises";
+import { hostname } from "node:os";
+import PATH from "node:path";
+
+// src/filesystemJson.ts
+function stringifyJson(value) {
+  return JSON.stringify(value, replaceJsonValue);
+}
+function replaceJsonValue(_key, candidate) {
+  return typeof candidate === "bigint" ? { $eventKitBigInt: candidate.toString() } : candidate;
+}
+
+// src/runtime/sqlitePublisherState.ts
+function decode(value) {
+  return JSON.parse(value, (_key, candidate) => {
+    if (typeof candidate === "object" && candidate !== null && Object.keys(candidate).length === 1 && "$eventKitBigInt" in candidate && typeof candidate.$eventKitBigInt === "string" && /^(?:0|[1-9][0-9]*)$/u.test(candidate.$eventKitBigInt))
+      return BigInt(candidate.$eventKitBigInt);
+    return candidate;
+  });
+}
+function processExists(pid) {
+  if (!Number.isSafeInteger(pid) || pid < 1)
+    throw new Error("Invalid publisher owner record");
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH")
+      return false;
+    return true;
+  }
+}
+async function openSqlitePublisherState(options) {
+  if (options.path === ":memory:" || options.identity.length === 0)
+    throw new Error("Persistent publisher needs a file and an identity");
+  const path = PATH.resolve(options.path);
+  const directory = PATH.dirname(path);
+  await mkdir(directory, { recursive: true, mode: 448 });
+  const metadata = await lstat(directory);
+  if (!metadata.isDirectory() || (metadata.mode & 63) !== 0)
+    throw new Error("Publisher state directory must be a real directory with 0700 permissions");
+  const file = await open(path, constants.O_CREAT | constants.O_RDWR | constants.O_NOFOLLOW, 384);
+  try {
+    const metadata2 = await file.stat();
+    if (!metadata2.isFile() || (metadata2.mode & 63) !== 0)
+      throw new Error("Publisher database permissions must be 0600");
+    await file.sync();
+  } finally {
+    await file.close();
+  }
+  const { DatabaseSync } = await import("node:sqlite");
+  const database = new DatabaseSync(path);
+  const token = randomBytes3(16).toString("hex");
+  let closed = false;
+  let inTransaction = false;
+  const transaction = (work) => {
+    if (closed)
+      throw new Error("Publisher state is closed");
+    if (inTransaction)
+      return work();
+    database.exec("BEGIN IMMEDIATE");
+    inTransaction = true;
+    try {
+      const result = work();
+      if (result instanceof Promise)
+        throw new Error("Publisher state transactions must be synchronous");
+      database.exec("COMMIT");
+      return result;
+    } catch (error) {
+      database.exec("ROLLBACK");
+      throw error;
+    } finally {
+      inTransaction = false;
+    }
+  };
+  try {
+    database.exec(`
+      PRAGMA journal_mode = WAL;
+      PRAGMA synchronous = FULL;
+      PRAGMA busy_timeout = 5000;
+      CREATE TABLE IF NOT EXISTS publisher_records (namespace TEXT NOT NULL, key TEXT NOT NULL, value TEXT NOT NULL, PRIMARY KEY(namespace, key));
+      CREATE TABLE IF NOT EXISTS publisher_owner (id INTEGER PRIMARY KEY CHECK(id = 1), host TEXT NOT NULL, pid INTEGER NOT NULL, token TEXT NOT NULL);
+    `);
+    transaction(() => {
+      const prior = database.prepare("SELECT host, pid, token FROM publisher_owner WHERE id = 1").get();
+      if (prior !== void 0 && (prior.host !== hostname() || processExists(prior.pid))) {
+        throw new Error("Publisher database already has an active owner; a shared or multi-host database is not supported");
+      }
+      const binding = database.prepare("SELECT value FROM publisher_records WHERE namespace = ? AND key = ?").get("metadata", "identity");
+      if (binding !== void 0 && decode(binding.value) !== options.identity)
+        throw new Error("Publisher database identity mismatch");
+      database.prepare("INSERT OR IGNORE INTO publisher_records(namespace,key,value) VALUES (?,?,?)").run("metadata", "identity", stringifyJson(options.identity));
+      database.prepare("INSERT OR REPLACE INTO publisher_owner(id,host,pid,token) VALUES (1,?,?,?)").run(hostname(), process.pid, token);
+    });
+  } catch (error) {
+    database.close();
+    throw error;
+  }
+  const read = database.prepare("SELECT value FROM publisher_records WHERE namespace = ? AND key = ?");
+  const list = database.prepare("SELECT key, value FROM publisher_records WHERE namespace = ? ORDER BY key");
+  const write = database.prepare("INSERT INTO publisher_records(namespace,key,value) VALUES (?,?,?) ON CONFLICT(namespace,key) DO UPDATE SET value = excluded.value");
+  const insert = database.prepare("INSERT OR IGNORE INTO publisher_records(namespace,key,value) VALUES (?,?,?)");
+  const remove = database.prepare("DELETE FROM publisher_records WHERE namespace = ? AND key = ?");
+  const assertOpen = () => {
+    if (closed)
+      throw new Error("Publisher state is closed");
+  };
+  return {
+    path,
+    get(namespace, key) {
+      assertOpen();
+      const row = read.get(namespace, key);
+      return row === void 0 ? void 0 : decode(row.value);
+    },
+    entries(namespace) {
+      assertOpen();
+      return list.all(namespace).map((row) => ({ key: row.key, value: decode(row.value) }));
+    },
+    set(namespace, key, value) {
+      assertOpen();
+      write.run(namespace, key, stringifyJson(value));
+    },
+    insert(namespace, key, value) {
+      assertOpen();
+      return insert.run(namespace, key, stringifyJson(value)).changes === 1;
+    },
+    remove(namespace, key) {
+      assertOpen();
+      remove.run(namespace, key);
+    },
+    transaction,
+    close() {
+      if (closed)
+        return;
+      transaction(() => {
+        database.prepare("DELETE FROM publisher_owner WHERE id = 1 AND token = ?").run(token);
+      });
+      database.close();
+      closed = true;
+    }
+  };
+}
+export {
+  boundedPublisherOperation,
+  createAccountSourceWakeSigner,
+  createBoundedPublisherEthersTransport,
+  createBoundedPublisherFetch,
+  createEthereumFinalizedPublisherSource,
+  createPersistentEventPublisherRuntime,
+  createPublisherHandshakeDiscovery,
+  createPublisherHttpsTransport,
+  createSqlitePublisherHandshakeStores,
+  createUtcIntervalPublisherSource,
+  createXl1PublisherSource,
+  isPublicPublisherAddress,
+  openPublisherDataLake,
+  openPublisherRestGateway,
+  openSqlitePublisherState,
+  publisherSourceKey
+};
+//# sourceMappingURL=runtime.mjs.map