@xyo-network/service-kit-xl1 0.2.1 → 0.3.0

package/dist/browser/index.mjs

@@ -1,3 +1,1184 @@
+// src/createFleetAuthority.ts
+import {
+  foldFleetControls,
+  resolveFleetPayload,
+  verifyFleetPayload
+} from "@xyo-network/service-kit-protocol";
+import {
+  AddressZod as AddressZod4,
+  FleetControlSchema,
+  FleetMemberSchema,
+  FleetPublicationScopeSchema,
+  FleetPublicationScopeZod,
+  FleetSchema,
+  FleetZod,
+  HashZod as HashZod5
+} from "@xyo-network/service-kit-schemas";
+import {
+  createXl1FinalizedPublicationEvidence
+} from "@xyo-network/xl1-sdk/protocol-sdk/finalized-publication";
+
+// src/fleetControl.ts
+var abortedDescriptor = Object.getOwnPropertyDescriptor(AbortSignal.prototype, "aborted");
+var abortedGetter = Reflect.get(abortedDescriptor ?? {}, "get");
+var nativeEvents = EventTarget.prototype;
+var addListener = nativeEvents.addEventListener;
+var removeListener = nativeEvents.removeEventListener;
+var apply = Reflect.apply;
+var now = performance.now.bind(performance);
+function captureSignal(value) {
+  if (value === void 0) return;
+  if (typeof abortedGetter !== "function") throw new TypeError("Native AbortSignal is required");
+  apply(abortedGetter, value, []);
+  return value;
+}
+function aborted(signal) {
+  if (typeof abortedGetter !== "function") throw new TypeError("Native AbortSignal is required");
+  return apply(abortedGetter, signal, []);
+}
+function listenAbort(signal, listener) {
+  if (signal === void 0) return () => {
+  };
+  apply(addListener, signal, ["abort", listener, { once: true }]);
+  return () => {
+    apply(removeListener, signal, ["abort", listener]);
+  };
+}
+var FleetAuthorityError = class extends Error {
+  code;
+  status;
+  constructor(status, code) {
+    super(code);
+    this.name = "FleetAuthorityError";
+    this.status = status;
+    this.code = code;
+  }
+};
+function operationControl(signal, timeoutMs, startedAt) {
+  const controller = new AbortController();
+  const deadline = startedAt + timeoutMs;
+  let terminal;
+  const stop = (status) => {
+    terminal ??= new FleetAuthorityError(status, status);
+    controller.abort();
+  };
+  const unlisten = listenAbort(signal, () => stop("cancelled"));
+  if (signal !== void 0 && aborted(signal)) stop("cancelled");
+  const timer = setTimeout(() => stop("deadline"), Math.max(1, Math.ceil(deadline - now())));
+  return {
+    signal: controller.signal,
+    assertActive() {
+      if (now() >= deadline) stop("deadline");
+      if (terminal !== void 0) throw terminal;
+    },
+    remainingMs: () => Math.max(1, Math.ceil(deadline - now())),
+    dispose() {
+      clearTimeout(timer);
+      unlisten();
+      controller.abort();
+    }
+  };
+}
+var fleetNow = now;
+
+// src/fleetHistory.ts
+function historicalPublisherCandidates(controls) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const fact of controls) {
+    const payload = fact.payload;
+    if (payload.operation !== "grant-publisher" || candidates.has(fact.root)) continue;
+    candidates.set(fact.root, Object.freeze({
+      controlRoot: fact.root,
+      controlBlock: fact.block,
+      fleetRoot: payload.fleetRoot,
+      memberRoot: payload.memberRoot,
+      scopeRoot: payload.scopeRoot,
+      publisherAddress: payload.publisherAddress,
+      ...payload.expiresAtBlock !== void 0 && { expiresAtBlock: payload.expiresAtBlock }
+    }));
+  }
+  return Object.freeze(candidates.values().toArray());
+}
+function historicalPublisherResult(result, controls, fleetRoot) {
+  const context2 = {
+    anchor: result.anchor,
+    assurance: result.assurance,
+    chainId: result.chainId,
+    genesisRoot: result.genesisRoot,
+    historyScope: result.historyScope,
+    network: result.network,
+    owner: result.owner,
+    selection: "historical-ever-granted-discovery-only",
+    ...result.resources !== void 0 && { resources: result.resources },
+    ...fleetRoot !== void 0 && { fleetRoot }
+  };
+  return result.status === "complete" ? Object.freeze({
+    ...context2,
+    ...result.scopeCompleteness !== void 0 && { scopeCompleteness: result.scopeCompleteness },
+    status: "complete",
+    correspondence: result.correspondence,
+    coveredRange: result.coveredRange,
+    history: result.history,
+    candidates: historicalPublisherCandidates(controls)
+  }) : Object.freeze({
+    ...context2,
+    status: result.status,
+    code: result.code
+  });
+}
+
+// src/fleetMeter.ts
+var encoder = new TextEncoder();
+function spend(budget, bytes) {
+  budget.bytes += bytes;
+  if (budget.bytes > budget.maximum) throw new RangeError("Declaration response exceeds its reserved allowance");
+}
+function text(budget, value) {
+  if (value.length > budget.maximum - budget.bytes) throw new RangeError("Declaration text exceeds its reserved allowance");
+  spend(budget, encoder.encode(JSON.stringify(value)).byteLength);
+}
+function compositeSnapshot(value, budget, depth) {
+  const array = Array.isArray(value);
+  if (Object.getPrototypeOf(value) !== (array ? Array.prototype : Object.prototype)) throw new TypeError("Declaration response requires plain JSON");
+  if (array && value.length > budget.limits.maxNodes - budget.nodes) throw new RangeError("Declaration response exceeds node bounds");
+  const keys = Reflect.ownKeys(value);
+  const expected = array ? Array.from({ length: value.length }, (_, index) => String(index)) : keys;
+  if (array && (keys.length !== value.length + 1 || keys.at(-1) !== "length")) throw new TypeError("Declaration arrays require dense own slots");
+  if (expected.length > budget.limits.maxNodes - budget.nodes) throw new RangeError("Declaration response exceeds node bounds");
+  spend(budget, 2);
+  const entries = expected.map((key, index) => {
+    if (typeof key !== "string" || key === "__proto__") throw new TypeError("Declaration keys require plain strings");
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor?.enumerable !== true || !("value" in descriptor)) throw new TypeError("Declaration accessors are unsupported");
+    if (index > 0) spend(budget, 1);
+    if (!array) {
+      text(budget, key);
+      spend(budget, 1);
+    }
+    return [key, jsonSnapshot(descriptor.value, budget, depth + 1)];
+  });
+  return Object.freeze(array ? entries.map(([, item]) => item) : Object.fromEntries(entries));
+}
+function jsonSnapshot(value, budget, depth = 0) {
+  if (++budget.nodes > budget.limits.maxNodes || depth > budget.limits.maxDepth) throw new RangeError("Declaration response exceeds structure bounds");
+  if (value === null || typeof value === "boolean" || typeof value === "number") {
+    if (typeof value === "number" && !Number.isFinite(value)) throw new TypeError("Declaration response requires finite JSON");
+    spend(budget, JSON.stringify(value).length);
+    return value;
+  }
+  if (typeof value === "string") {
+    text(budget, value);
+    return value;
+  }
+  if (typeof value !== "object" || budget.ancestors.has(value)) throw new TypeError("Declaration response requires acyclic own-data JSON");
+  budget.ancestors.add(value);
+  try {
+    return compositeSnapshot(value, budget, depth);
+  } finally {
+    budget.ancestors.delete(value);
+  }
+}
+function logicalJsonSnapshot(value, maximum, limits) {
+  const budget = {
+    bytes: 0,
+    nodes: 0,
+    maximum,
+    limits,
+    ancestors: /* @__PURE__ */ new WeakSet()
+  };
+  const snapshot = jsonSnapshot(value, budget);
+  return { value: snapshot, bytes: budget.bytes };
+}
+var FleetMeter = class {
+  #ceiling;
+  #closed = false;
+  #declarations = 0;
+  #limits;
+  #native = 0;
+  #reserved = 0;
+  constructor(ceiling, limits) {
+    this.#ceiling = ceiling;
+    this.#limits = limits;
+  }
+  close() {
+    this.#closed = true;
+  }
+  native(bytes) {
+    if (bytes === void 0 || !Number.isSafeInteger(bytes) || bytes < 0) throw new FleetAuthorityError("conflict", "native-resources");
+    this.#native += bytes;
+    if (this.#native + this.#declarations + this.#reserved > this.#ceiling) throw new FleetAuthorityError("resource-limit", "aggregate-bytes");
+  }
+  async read(get, roots, options) {
+    const allowance = Math.min(options?.maxBodyBytes ?? this.#limits.maxBodyBytes, this.remaining());
+    this.#reserved += allowance;
+    const response = await get(roots, {
+      ...options,
+      signal: options?.signal ?? new AbortController().signal,
+      maxBodyBytes: allowance
+    });
+    if (this.#closed || options?.signal !== void 0 && aborted(options.signal)) throw new FleetAuthorityError("incomplete", "declaration-late");
+    if (!Array.isArray(response) || response.length > this.#limits.maxCandidatesPerSeed) throw new FleetAuthorityError("resource-limit", "declaration-response");
+    const budget = {
+      bytes: 0,
+      nodes: 0,
+      maximum: allowance,
+      limits: this.#limits,
+      ancestors: /* @__PURE__ */ new WeakSet()
+    };
+    const snapshot = jsonSnapshot(response, budget);
+    this.#reserved -= allowance;
+    this.#declarations += budget.bytes;
+    return snapshot;
+  }
+  remaining() {
+    const remaining = this.#ceiling - this.#native - this.#declarations - this.#reserved;
+    if (this.#closed || remaining <= 0) throw new FleetAuthorityError("resource-limit", "aggregate-bytes");
+    return remaining;
+  }
+  resources() {
+    const decodedBytes = this.#native + this.#declarations;
+    return Object.freeze({
+      decodedBytes,
+      chargedBytes: decodedBytes + this.#reserved,
+      nativeDecodedBytes: this.#native,
+      declarationDecodedBytes: this.#declarations,
+      declarationReservedBytes: this.#reserved
+    });
+  }
+};
+function chargeNativeResources(meter, resources) {
+  meter?.native(resources?.decodedBytes);
+}
+
+// src/fleetHistoryCache.ts
+function snapshotFleetVerifiedHistory(input) {
+  if (input === void 0) return;
+  if (input === null || typeof input !== "object" || Object.getPrototypeOf(input) !== Object.prototype || Reflect.ownKeys(input).length !== 2) throw new TypeError("Select strict verified owner-history bounds");
+  const values = Object.fromEntries(["maxBytes", "maxOwners"].map((key) => {
+    const slot = Object.getOwnPropertyDescriptor(input, key);
+    if (slot?.enumerable !== true || !("value" in slot) || typeof slot.value !== "number" || !Number.isSafeInteger(slot.value) || slot.value <= 0) throw new TypeError("Select positive own-data history bounds");
+    return [key, slot.value];
+  }));
+  if (values.maxOwners > 16 || values.maxBytes > 128 * 1024 * 1024) throw new RangeError("Verified history storage exceeds its bounded profile");
+  return Object.freeze(values);
+}
+var encoder2 = new TextEncoder();
+var decoder = new TextDecoder("utf-8", { fatal: true });
+var VerifiedFleetHistory = class {
+  #bytes = 0;
+  #entries = /* @__PURE__ */ new Map();
+  #limits;
+  #maxDepth;
+  constructor(limits, maxDepth) {
+    this.#limits = limits;
+    this.#maxDepth = maxDepth;
+  }
+  get(owner) {
+    const entry = this.#entries.get(owner);
+    if (entry === void 0) return;
+    this.#entries.delete(owner);
+    this.#entries.set(owner, entry);
+    const decoded = JSON.parse(decoder.decode(entry.data));
+    return logicalJsonSnapshot(decoded, this.#limits.maxBytes, { maxDepth: this.#maxDepth, maxNodes: this.#limits.maxBytes }).value;
+  }
+  publish(input) {
+    const prior = this.#entries.get(input.owner);
+    if (prior !== void 0) {
+      if (prior.anchor.blockNumber > input.anchor.blockNumber) return;
+      if (prior.anchor.blockNumber === input.anchor.blockNumber && prior.anchor.blockRoot !== input.anchor.blockRoot) throw new FleetAuthorityError("conflict", "history-anchor");
+    }
+    let snapshot;
+    try {
+      snapshot = logicalJsonSnapshot(input, this.#limits.maxBytes, { maxDepth: this.#maxDepth, maxNodes: this.#limits.maxBytes });
+    } catch {
+      throw new FleetAuthorityError("resource-limit", "history-bytes");
+    }
+    while (this.#bytes + snapshot.bytes > this.#limits.maxBytes || this.#entries.size >= this.#limits.maxOwners) {
+      const oldest = this.#entries.keys().next().value;
+      if (oldest === void 0) throw new FleetAuthorityError("resource-limit", "history-bytes");
+      this.#bytes -= this.#entries.get(oldest).data.byteLength;
+      this.#entries.delete(oldest);
+    }
+    const data = encoder2.encode(JSON.stringify(snapshot.value));
+    if (data.byteLength !== snapshot.bytes) throw new FleetAuthorityError("conflict", "history-size");
+    const replacing = this.#entries.get(input.owner);
+    if (replacing !== void 0) this.#bytes -= replacing.data.byteLength;
+    this.#entries.set(input.owner, { anchor: input.anchor, data });
+    this.#bytes += data.byteLength;
+  }
+};
+
+// src/fleetScope.ts
+import { HashZod as HashZod3 } from "@xyo-network/service-kit-schemas";
+
+// src/fleetForeign.ts
+import { AddressZod, HashZod } from "@xyo-network/service-kit-schemas";
+
+// src/fleetProfile.ts
+import {
+  snapshotFinalizedForeignTransactions,
+  snapshotFinalizedForkLineage,
+  snapshotFinalizedVerifiedPrefix
+} from "@xyo-network/xl1-sdk/protocol-sdk/finalized-publication";
+
+// src/fleetQuerySelection.ts
+import { snapshotFinalizedQuerySelection } from "@xyo-network/xl1-sdk/protocol-sdk/finalized-publication";
+function snapshotFleetQuerySelection(input) {
+  const selection = snapshotFinalizedQuerySelection(input);
+  if (selection !== input) throw new TypeError("Native query selection snapshot must preserve the exact policy");
+  return selection;
+}
+
+// src/fleetSelectedPayloadSource.ts
+import { snapshotFinalizedSelectedPayloadSource } from "@xyo-network/xl1-sdk/protocol-sdk/finalized-publication";
+function snapshotFleetSelectedPayloadSource(input, maxSourceUrlBytes) {
+  const captured = snapshotFinalizedSelectedPayloadSource(input, maxSourceUrlBytes);
+  if (input !== void 0 && captured === void 0) throw new TypeError("Selected payload source snapshot must preserve the requested selection");
+  return captured;
+}
+
+// src/fleetProfile.ts
+function ownRecord(input, required, optional = []) {
+  if (input === null || typeof input !== "object" || Object.getPrototypeOf(input) !== Object.prototype) throw new TypeError("Use a strict own-data profile/request");
+  const keys = Reflect.ownKeys(input);
+  if (keys.some((key) => typeof key !== "string" || ![...required, ...optional].includes(key)) || required.some((key) => !keys.includes(key))) throw new TypeError("Unexpected or missing profile/request fields");
+  return Object.fromEntries(keys.map((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    if (descriptor?.enumerable !== true || !("value" in descriptor)) throw new TypeError("Profile/request accessors are unsupported");
+    return [key, descriptor.value];
+  }));
+}
+function finiteProfile(input, keys, largeBytes = false) {
+  const values = ownRecord(input, keys);
+  if (Object.entries(values).some(([key, value]) => typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0 || value > 2147483647 && !(largeBytes && key === "maxAggregateBytes"))) throw new RangeError("Every finite positive bound is required");
+  return Object.freeze(values);
+}
+function pinProfile(input) {
+  const profile = ownRecord(input, ["evidence", "foldLimits", "limits", "resolutionLimits", "seeds"], ["verifiedHistory"]);
+  const evidence = ownRecord(profile.evidence, ["assurance", "chainId", "genesisRoot", "limits", "network", "source"], ["forkLineage", "verifiedPrefix", "foreignTransactions", "querySelection"]);
+  const source = ownRecord(evidence.source, ["bodyBaseUrl", "finalizedBaseUrl", "headUrl"], ["fetch", "blockFrames", "selectedPayloadSource"]);
+  const forkLineage = snapshotFinalizedForkLineage(evidence.forkLineage, evidence.chainId);
+  const blockFrames = source.blockFrames === void 0 ? void 0 : pinBlockFrames(source.blockFrames);
+  const verifiedPrefix = pinVerifiedPrefix(evidence.verifiedPrefix);
+  const foreignTransactions = snapshotFinalizedForeignTransactions(evidence.foreignTransactions);
+  if (foreignTransactions !== void 0 && (forkLineage === void 0 || blockFrames === void 0 || verifiedPrefix === void 0)) {
+    throw new TypeError("Foreign transaction exclusion requires explicit fork, frame and verified-prefix profiles");
+  }
+  if (verifiedPrefix !== void 0 && (forkLineage === void 0 || blockFrames === void 0)) throw new TypeError("Verified native prefix requires explicit fork and original-block frame profiles");
+  const querySelection = snapshotFleetQuerySelection(evidence.querySelection);
+  const verifiedHistory = snapshotFleetVerifiedHistory(profile.verifiedHistory);
+  if (verifiedHistory !== void 0 && verifiedPrefix === void 0) throw new TypeError("Verified owner history requires native verified-prefix support");
+  const evidenceLimits = finiteProfile(evidence.limits, [
+    "maxAggregateBytes",
+    "maxBlocks",
+    "maxBodies",
+    "maxConcurrentReads",
+    "maxDecodedDepth",
+    "maxDecodedNodes",
+    "maxLineageBlocks",
+    "maxResponseBytes",
+    "maxRoots",
+    "maxSourceUrlBytes",
+    "perCallTimeoutMs",
+    "totalTimeoutMs"
+  ], verifiedPrefix !== void 0);
+  const selectedPayloadSource = snapshotFleetSelectedPayloadSource(source.selectedPayloadSource, evidenceLimits.maxSourceUrlBytes);
+  const fixedEvidence = Object.freeze({
+    ...evidence,
+    limits: evidenceLimits,
+    ...forkLineage !== void 0 && { forkLineage },
+    ...verifiedPrefix !== void 0 && { verifiedPrefix },
+    ...foreignTransactions !== void 0 && { foreignTransactions },
+    ...querySelection !== void 0 && { querySelection },
+    source: Object.freeze({
+      ...source,
+      ...blockFrames !== void 0 && { blockFrames },
+      ...selectedPayloadSource !== void 0 && { selectedPayloadSource }
+    })
+  });
+  const limits = finiteProfile(profile.limits, [
+    "maxBlocks",
+    "maxConcurrentCalls",
+    "maxConcurrentReads",
+    "maxFleets",
+    "maxOccurrences",
+    "maxPages",
+    "maxRootReads",
+    "totalTimeoutMs"
+  ]);
+  const foldLimits = finiteProfile(profile.foldLimits, ["maxBodyBytes", "maxControls", "maxDeclarations", "maxDepth", "maxGrants", "maxMembers", "maxNodes"]);
+  const resolutionLimits = finiteProfile(profile.resolutionLimits, [
+    "attemptTimeoutMs",
+    "maxBodyBytes",
+    "maxCandidatesPerSeed",
+    "maxDepth",
+    "maxNodes",
+    "maxSeeds",
+    "totalTimeoutMs"
+  ]);
+  return {
+    evidence: fixedEvidence,
+    limits,
+    foldLimits,
+    resolutionLimits,
+    verifiedHistory,
+    seeds: profile.seeds
+  };
+}
+function pinBlockFrames(input) {
+  const frames = ownRecord(input, ["indexBaseUrl", "maxStep"]);
+  if (typeof frames.indexBaseUrl !== "string" || frames.indexBaseUrl.length === 0 || typeof frames.maxStep !== "number" || !Number.isSafeInteger(frames.maxStep) || frames.maxStep < 0 || frames.maxStep > 3) throw new TypeError("Select a bounded original-block frame source");
+  return Object.freeze({ indexBaseUrl: frames.indexBaseUrl, maxStep: frames.maxStep });
+}
+function pinVerifiedPrefix(input) {
+  if (input === void 0) return snapshotFinalizedVerifiedPrefix(input);
+  const fields = ownRecord(input, ["maxEntries", "maxBytes"], ["shareKey"]);
+  const captured = snapshotFinalizedVerifiedPrefix(fields);
+  if (captured === void 0 || captured.maxEntries !== fields.maxEntries || captured.maxBytes !== fields.maxBytes || Reflect.get(captured, "shareKey") !== fields.shareKey) throw new TypeError("Native verified-prefix snapshot must preserve its exact selection");
+  return captured;
+}
+
+// src/fleetForeign.ts
+function field(input, key) {
+  if (input === null || typeof input !== "object") throw new FleetAuthorityError("conflict", "scan-foreign-header");
+  const slot = Object.getOwnPropertyDescriptor(input, key);
+  if (slot?.enumerable !== true || !("value" in slot)) throw new FleetAuthorityError("conflict", "scan-foreign-header");
+  return slot.value;
+}
+function position(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function validateSlots(header) {
+  const hashes = field(header.transaction, "payload_hashes");
+  const schemas = field(header.transaction, "payload_schemas");
+  if (!Array.isArray(hashes) || !Array.isArray(schemas) || !Array.isArray(header.payloads) || hashes.length !== schemas.length || hashes.length !== header.payloads.length) throw new FleetAuthorityError("conflict", "scan-foreign-slots");
+  for (let index = 0; index < hashes.length; index++) {
+    const hash = field(hashes, String(index));
+    const schema = field(schemas, String(index));
+    const slot = ownRecord(field(header.payloads, String(index)), ["payloadOrdinal", "payloadRoot", "schema", "selected"]);
+    if (typeof schema !== "string" || schema.length === 0 || !HashZod.safeParse(hash).success || slot.payloadOrdinal !== index || slot.payloadRoot !== hash || slot.schema !== schema || slot.selected !== false) throw new FleetAuthorityError("conflict", "scan-foreign-slots");
+  }
+}
+function validateDomain(header, profile) {
+  const ancestors = profile.evidence.forkLineage?.map((edge) => edge.parentChainId) ?? [];
+  if (header.network !== profile.evidence.network || header.genesisRoot !== profile.evidence.genesisRoot || header.carryingChainId !== profile.evidence.chainId || header.chainId === profile.evidence.chainId || !ancestors.includes(header.chainId) || header.reason !== "verified-ancestor-domain-not-authority" || field(header.transaction, "chain") !== header.chainId || field(header.transaction, "from") !== header.signer || !AddressZod.safeParse(header.signer).success || !HashZod.safeParse(header.blockRoot).success || !HashZod.safeParse(header.transactionRoot).success) throw new FleetAuthorityError("conflict", "scan-foreign-domain");
+}
+function validateHeader(input, page, profile, from, to) {
+  const header = ownRecord(input, [
+    "network",
+    "chainId",
+    "genesisRoot",
+    "blockNumber",
+    "blockRoot",
+    "transactionRoot",
+    "transactionIndex",
+    "transactionPayloadOrdinal",
+    "signer",
+    "transaction",
+    "payloads",
+    "carryingChainId",
+    "reason"
+  ]);
+  validateDomain(header, profile);
+  if (!position(header.blockNumber) || header.blockNumber < from || header.blockNumber > to || !position(header.transactionIndex) || !position(header.transactionPayloadOrdinal) || header.transactionPayloadOrdinal < header.transactionIndex) throw new FleetAuthorityError("conflict", "scan-foreign-position");
+  if (page.blockClocks.every((clock) => !(clock.blockNumber === header.blockNumber && clock.blockRoot === header.blockRoot && clock.chainId === header.carryingChainId)) || page.headers.some((ordinary) => ordinary.blockNumber === header.blockNumber && ordinary.transactionIndex === header.transactionIndex)) {
+    throw new FleetAuthorityError("conflict", "scan-foreign-correspondence");
+  }
+  validateSlots(header);
+  return {
+    block: header.blockNumber,
+    index: header.transactionIndex,
+    ordinal: header.transactionPayloadOrdinal
+  };
+}
+function validateForeignHeaders(page, profile, from, to) {
+  const result = page;
+  if (profile.evidence.foreignTransactions === void 0) {
+    if (result.foreignTransactionHeaders !== void 0) throw new FleetAuthorityError("conflict", "scan-foreign-profile");
+    return 0;
+  }
+  if (!Array.isArray(result.foreignTransactionHeaders) || result.foreignTransactionHeaders.length > profile.evidence.limits.maxRoots) throw new FleetAuthorityError("conflict", "scan-foreign-headers");
+  let previous;
+  for (let index = 0; index < result.foreignTransactionHeaders.length; index++) {
+    const header = validateHeader(field(result.foreignTransactionHeaders, String(index)), page, profile, from, to);
+    if (previous !== void 0 && (header.block < previous.block || header.block === previous.block && (header.index <= previous.index || header.ordinal <= previous.ordinal))) throw new FleetAuthorityError("conflict", "scan-foreign-order");
+    previous = header;
+  }
+  return result.foreignTransactionHeaders.length;
+}
+
+// src/fleetQuery.ts
+import { AddressZod as AddressZod2, HashZod as HashZod2 } from "@xyo-network/service-kit-schemas";
+var grade = "verified-block-committed-query-selection";
+var encoder3 = new TextEncoder();
+function fail(code = "scan-query-exclusion") {
+  throw new FleetAuthorityError("conflict", code);
+}
+function spend2(budget, nodes, bytes = 0) {
+  budget.nodes += nodes;
+  budget.bytes += bytes;
+  if (budget.nodes > budget.profile.evidence.limits.maxDecodedNodes || budget.bytes > budget.profile.evidence.limits.maxAggregateBytes) {
+    throw new FleetAuthorityError("resource-limit", "scan-query-metadata");
+  }
+}
+function field2(input, key) {
+  const slot = input !== null && typeof input === "object" ? Object.getOwnPropertyDescriptor(input, key) : void 0;
+  return slot?.enumerable === true && "value" in slot ? slot.value : fail();
+}
+function position2(input) {
+  return typeof input === "number" && Number.isSafeInteger(input) && input >= 0;
+}
+function dense(input, maximum, budget) {
+  if (!Array.isArray(input) || input.length > maximum || Reflect.ownKeys(input).length !== input.length + 1) return fail();
+  spend2(budget, input.length + 1);
+  for (let i = 0; i < input.length; i++) field2(input, String(i));
+  return input;
+}
+function strings(input, budget, address = false) {
+  const values = dense(input, budget.profile.evidence.limits.maxRoots, budget);
+  for (const value of values) {
+    if (typeof value !== "string" || value.length === 0 || value.length > budget.profile.evidence.limits.maxResponseBytes || address && !AddressZod2.safeParse(value).success) return fail();
+    spend2(budget, 0, encoder3.encode(value).byteLength);
+  }
+  return values;
+}
+function scopeMatches(input, expected, budget) {
+  const keys = ["authorizers", "chainIds", "schemas"].filter((key) => expected[key] !== void 0);
+  const snapshot = ownRecord(input, keys);
+  for (const key of keys) {
+    const selected = snapshot[key];
+    if (!Array.isArray(selected) || selected.length !== expected[key].length) fail("scan-query-request");
+    const values = strings(selected, budget, key !== "schemas");
+    if (values.some((value, index) => value !== expected[key][index])) fail("scan-query-request");
+  }
+}
+function chainAt(profile, block) {
+  let chain = profile.evidence.chainId;
+  const lineage = profile.evidence.forkLineage ?? [];
+  for (const edge of lineage) {
+    if (block > edge.forkedAtBlockNumber) break;
+    chain = edge.parentChainId;
+  }
+  return chain;
+}
+function occupiedPositions(page, budget) {
+  const occupied = /* @__PURE__ */ new Set();
+  for (const rows of [page.headers, page.occurrences, page.foreignTransactionHeaders ?? []]) {
+    for (const row of dense(rows, budget.profile.evidence.limits.maxRoots, budget)) {
+      const block = field2(row, "blockNumber");
+      const index = field2(row, "transactionIndex");
+      const ordinal = field2(row, "transactionPayloadOrdinal");
+      if (!position2(block) || !position2(index) || !position2(ordinal)) fail();
+      occupied.add(`${block}:index:${index}`);
+      occupied.add(`${block}:ordinal:${ordinal}`);
+    }
+  }
+  return occupied;
+}
+function clockRows(page, budget) {
+  const clocks = /* @__PURE__ */ new Map();
+  for (const row of dense(page.blockClocks, budget.profile.evidence.limits.maxBlocks, budget)) {
+    const block = field2(row, "blockNumber");
+    if (!position2(block) || clocks.has(block)) fail("scan-query-clock");
+    clocks.set(block, row);
+  }
+  return clocks;
+}
+function validateClock(row, clocks, profile) {
+  const clock = clocks.get(row.blockNumber);
+  if (clock === void 0 || field2(clock, "network") !== profile.evidence.network || field2(clock, "genesisRoot") !== profile.evidence.genesisRoot || field2(clock, "blockRoot") !== row.blockRoot || field2(clock, "chainId") !== row.carryingChainId) fail("scan-query-clock");
+  const time = field2(clock, "time");
+  if (field2(time, "status") === "authenticated" && (field2(time, "payloadOrdinal") === row.transactionPayloadOrdinal || field2(time, "payloadRoot") === row.transactionRoot)) fail("scan-query-time");
+}
+function validatePosition(row, profile, from, to) {
+  if (!position2(row.blockNumber) || row.blockNumber < from || row.blockNumber > to || !position2(row.transactionIndex) || !position2(row.transactionPayloadOrdinal) || row.transactionPayloadOrdinal < row.transactionIndex || row.carryingChainId !== chainAt(profile, row.blockNumber) || !AddressZod2.safeParse(row.declaredChainId).success || !AddressZod2.safeParse(row.declaredFrom).success || !HashZod2.safeParse(row.blockRoot).success || !HashZod2.safeParse(row.transactionRoot).success) fail();
+}
+function validateRecord(input, expected, profile, from, to, clocks, occupied, budget) {
+  const row = ownRecord(input, [
+    "blockNumber",
+    "blockRoot",
+    "carryingChainId",
+    "transactionIndex",
+    "transactionPayloadOrdinal",
+    "transactionRoot",
+    "declaredChainId",
+    "declaredFrom",
+    "declaredAddresses",
+    "declaredPayloadSchemas",
+    "reason",
+    "requestSnapshot"
+  ]);
+  spend2(budget, 12);
+  validatePosition(row, profile, from, to);
+  const addresses = strings(row.declaredAddresses, budget, true);
+  const schemas = strings(row.declaredPayloadSchemas, budget);
+  if (addresses.length === 0 || new Set(addresses).size !== addresses.length) fail();
+  scopeMatches(row.requestSnapshot, expected, budget);
+  const claimed = /* @__PURE__ */ new Set([row.declaredFrom, ...addresses]);
+  const noAuthorizer = expected.authorizers?.every((value) => !claimed.has(value)) === true;
+  const noSchema = expected.schemas?.every((value) => !schemas.includes(value)) === true;
+  const reason = noAuthorizer ? "no-requested-authorizer" : noSchema ? "no-requested-schema" : void 0;
+  if (reason === void 0 || row.reason !== reason) fail("scan-query-reason");
+  const indexKey = `${row.blockNumber}:index:${row.transactionIndex}`;
+  const ordinalKey = `${row.blockNumber}:ordinal:${row.transactionPayloadOrdinal}`;
+  if (occupied.has(indexKey) || occupied.has(ordinalKey)) fail("scan-query-overlap");
+  occupied.add(indexKey);
+  occupied.add(ordinalKey);
+  if (pageExcluded(profile, row.blockNumber, from, to)) fail("scan-query-excluded-chain");
+  validateClock(row, clocks, profile);
+  return {
+    block: row.blockNumber,
+    index: row.transactionIndex,
+    ordinal: row.transactionPayloadOrdinal
+  };
+}
+function pageExcluded(profile, block, from, to) {
+  return profile.evidence.verifiedPrefix !== void 0 && profile.evidence.forkLineage?.some((edge) => block >= from && block <= to && block <= edge.forkedAtBlockNumber) === true;
+}
+function validateQueryExclusions(page, profile, from, to, expectedScope) {
+  const result = page;
+  if (profile.evidence.querySelection === void 0) {
+    if (result.blockCommittedQueryExclusions !== void 0 || result.scopeCompleteness === grade) fail("scan-query-profile");
+    return;
+  }
+  try {
+    if (expectedScope === void 0 || expectedScope.headersOnly !== void 0 || expectedScope.authorizers === void 0 && expectedScope.schemas === void 0 || [expectedScope.authorizers, expectedScope.chainIds, expectedScope.schemas].some((values) => values?.length === 0) || result.scopeCompleteness !== grade) fail("scan-query-grade");
+    const budget = {
+      nodes: 0,
+      bytes: 0,
+      profile
+    };
+    scopeMatches(page.scope, expectedScope, budget);
+    const rows = dense(result.blockCommittedQueryExclusions, profile.evidence.limits.maxRoots, budget);
+    const occupied = occupiedPositions(page, budget);
+    const clocks = clockRows(page, budget);
+    let previous;
+    for (const row of rows) {
+      const current = validateRecord(row, expectedScope, profile, from, to, clocks, occupied, budget);
+      if (previous !== void 0 && (current.block < previous.block || current.block === previous.block && (current.index <= previous.index || current.ordinal <= previous.ordinal))) fail("scan-query-order");
+      previous = current;
+    }
+    return grade;
+  } catch (error) {
+    if (error instanceof FleetAuthorityError) throw error;
+    return fail();
+  }
+}
+
+// src/fleetScope.ts
+function validateRange(input, expected, profile) {
+  const range = ownRecord(input, ["chainId", "fromBlockNumber", "fromBlockRoot", "toBlockNumber", "toBlockRoot"]);
+  const {
+    edge,
+    first,
+    last
+  } = expected;
+  if (range.chainId !== edge.parentChainId || range.chainId === profile.evidence.chainId || range.fromBlockNumber !== first || range.toBlockNumber !== last || !HashZod3.safeParse(range.fromBlockRoot).success || !HashZod3.safeParse(range.toBlockRoot).success || first === 0 && range.fromBlockRoot !== profile.evidence.genesisRoot || last === edge.forkedAtBlockNumber && range.toBlockRoot !== edge.forkedAtBlockRoot || first === last && range.fromBlockRoot !== range.toBlockRoot) throw new FleetAuthorityError("conflict", "scan-exclusions");
+}
+function validateGrade(actual, query, foreign) {
+  if (query !== void 0) return;
+  if (actual !== "verified-native-header-selection-with-domain-exclusions" && foreign > 0) throw new FleetAuthorityError("conflict", "scan-foreign-grade");
+  const legacy = ["verified-native-header-selection", "verified-native-header-selection-with-chain-exclusions", "verified-native-header-selection-with-domain-exclusions"];
+  if (!legacy.includes(actual)) throw new FleetAuthorityError("conflict", "scan-scope-mode");
+}
+function validateScopeMode(page, profile, from, to, expectedScope) {
+  const query = validateQueryExclusions(page, profile, from, to, expectedScope);
+  const foreign = validateForeignHeaders(page, profile, from, to);
+  const result = page;
+  validateGrade(result.scopeCompleteness, query, foreign);
+  if (result.scopeCompleteness === "verified-native-header-selection" || query !== void 0 && (profile.evidence.forkLineage === void 0 || profile.evidence.verifiedPrefix === void 0)) {
+    if (result.excludedChainRanges !== void 0 && result.excludedChainRanges.length > 0) throw new FleetAuthorityError("conflict", "scan-exclusions");
+    return query;
+  }
+  const lineage = profile.evidence.forkLineage;
+  if (lineage === void 0 || profile.evidence.verifiedPrefix === void 0 || !Array.isArray(result.excludedChainRanges)) throw new FleetAuthorityError("conflict", "scan-scope-mode");
+  const expected = lineage.map((edge, index) => ({
+    edge,
+    first: Math.max(from, (lineage[index + 1]?.forkedAtBlockNumber ?? -1) + 1),
+    last: Math.min(to, edge.forkedAtBlockNumber)
+  })).filter(({ first, last }) => first <= last).toReversed();
+  if (query === void 0 && (result.scopeCompleteness === "verified-native-header-selection-with-domain-exclusions" ? foreign : expected.length) === 0 || result.excludedChainRanges.length !== expected.length) throw new FleetAuthorityError("conflict", "scan-exclusion-coverage");
+  for (const [index, range] of result.excludedChainRanges.entries()) validateRange(range, expected[index], profile);
+  return query;
+}
+
+// src/fleetPage.ts
+function nativeFailure(page) {
+  const statuses = ["cancelled", "deadline", "conflict", "unsupported", "resource-limit"];
+  const status = statuses.includes(page.status) ? page.status : "incomplete";
+  return new FleetAuthorityError(status, `native-${page.issues[0]?.code ?? page.status}`);
+}
+function validateForkPage(page, profile, request) {
+  const clock = page.anchorClock;
+  if (page.scope.chainIds?.length !== 1 || page.scope.chainIds[0] !== profile.evidence.chainId || clock?.chainId !== profile.evidence.chainId || clock.network !== profile.evidence.network || clock.genesisRoot !== profile.evidence.genesisRoot || clock.blockNumber !== request.anchor.blockNumber || clock.blockRoot !== request.anchor.blockRoot) throw new FleetAuthorityError("conflict", "scan-current-chain");
+}
+function validateFleetPage(page, profile, request, from, to, scope) {
+  const actual = [
+    page.network,
+    page.chainId,
+    page.genesisRoot,
+    page.anchor.blockNumber,
+    page.anchor.blockRoot,
+    page.assurance,
+    page.requestedRange.fromBlockNumber,
+    page.requestedRange.toBlockNumber
+  ];
+  const expected = [
+    profile.evidence.network,
+    profile.evidence.chainId,
+    profile.evidence.genesisRoot,
+    request.anchor.blockNumber,
+    request.anchor.blockRoot,
+    "source-trusted-finalized-replay",
+    from,
+    to
+  ];
+  if (actual.some((value, index) => value !== expected[index])) throw new FleetAuthorityError("conflict", "scan-binding");
+  if (profile.evidence.querySelection !== void 0 && page.status !== "complete") throw nativeFailure(page);
+  const basis = validateScopeMode(page, profile, from, to, scope);
+  if (page.scope.authorizers?.length !== 1 || page.scope.authorizers[0] !== request.owner || page.scope.schemas?.length !== scope.schemas.length || page.scope.schemas.some((family, index) => family !== scope.schemas[index])) throw new FleetAuthorityError("conflict", "scan-scope");
+  if (page.status !== "complete") throw nativeFailure(page);
+  if (profile.evidence.forkLineage !== void 0) validateForkPage(page, profile, request);
+  if (page.coveredRange?.fromBlockNumber !== from || page.coveredRange.toBlockNumber !== to || page.continuation !== void 0 || page.issues.length > 0) {
+    throw new FleetAuthorityError("incomplete", "scan-coverage");
+  }
+  return basis;
+}
+
+// src/fleetProjection.ts
+function nextPublisherProjection(result) {
+  const { publicationBlock: projectionBlock, ...original } = result;
+  const context2 = {
+    ...original,
+    projection: "pending-N+1",
+    projectionBlock
+  };
+  if (result.status === "authorized" || result.status === "absent") {
+    return Object.freeze({
+      ...context2,
+      status: result.status === "authorized" ? "projected-granted" : "projected-absent",
+      coveredRange: Object.freeze({ fromBlockNumber: 0, toBlockNumber: result.anchor.blockNumber })
+    });
+  }
+  return Object.freeze(context2);
+}
+
+// src/fleetReaders.ts
+function pinReaders(seeds, profile) {
+  if (!Array.isArray(seeds) || seeds.length === 0 || seeds.length > profile.resolutionLimits.maxSeeds) throw new RangeError("Explicit bounded root readers required");
+  const ids = /* @__PURE__ */ new Set();
+  return Object.freeze(Array.from({ length: seeds.length }, (_, index) => {
+    const slot = Object.getOwnPropertyDescriptor(seeds, String(index));
+    if (slot?.enumerable !== true || !("value" in slot)) throw new TypeError("Readers require dense own data slots");
+    const seed = ownRecord(slot.value, ["id", "reader"]);
+    if (typeof seed.id !== "string" || seed.id.length === 0 || seed.id.length > 128 || seed.id.trim() !== seed.id || ids.has(seed.id)) throw new TypeError("Readers require unique bounded IDs");
+    ids.add(seed.id);
+    const reader = ownRecord(seed.reader, ["get"]);
+    if (typeof reader.get !== "function") throw new TypeError("Readers require an own get method");
+    const get = reader.get.bind(seed.reader);
+    return Object.freeze({ id: seed.id, reader: Object.freeze({ get }) });
+  }));
+}
+function capacityReaders(seeds, state, maximum, capacity, meter) {
+  return Object.freeze(seeds.map((seed) => Object.freeze({
+    id: seed.id,
+    reader: Object.freeze({
+      get: async (...args) => {
+        if (state.active >= maximum) {
+          capacity.limited = true;
+          throw new FleetAuthorityError("resource-limit", "reader-capacity");
+        }
+        state.active++;
+        try {
+          return await (meter === void 0 ? seed.reader.get(...args) : meter.read(seed.reader.get.bind(seed.reader), ...args));
+        } finally {
+          state.active--;
+        }
+      }
+    })
+  })));
+}
+
+// src/fleetRequests.ts
+import { AddressZod as AddressZod3, HashZod as HashZod4 } from "@xyo-network/service-kit-schemas";
+function pinRequest(input, next = false) {
+  const values = ownRecord(input, ["anchor", "owner", "publicationBlock"], ["fleetRoot", "signal", "maxAggregateBytes"]);
+  const anchor = ownRecord(values.anchor, ["blockNumber", "blockRoot"]);
+  HashZod4.parse(anchor.blockRoot);
+  AddressZod3.parse(values.owner);
+  if (values.maxAggregateBytes !== void 0 && (typeof values.maxAggregateBytes !== "number" || !Number.isSafeInteger(values.maxAggregateBytes) || values.maxAggregateBytes <= 0)) throw new RangeError("Select a finite positive aggregate request ceiling");
+  if (values.fleetRoot !== void 0) HashZod4.parse(values.fleetRoot);
+  if (!Number.isSafeInteger(anchor.blockNumber) || anchor.blockNumber < 0 || anchor.blockNumber >= Number.MAX_SAFE_INTEGER || typeof values.publicationBlock !== "number" || !Number.isSafeInteger(values.publicationBlock) || values.publicationBlock < 0 || (next ? values.publicationBlock !== anchor.blockNumber + 1 : values.publicationBlock > anchor.blockNumber)) throw new RangeError("Select an exact publication height within the anchor");
+  return Object.freeze({
+    ...values,
+    anchor: Object.freeze(anchor),
+    signal: captureSignal(values.signal)
+  });
+}
+
+// src/createFleetAuthority.ts
+var b4Families = Object.freeze([FleetSchema, FleetMemberSchema, FleetPublicationScopeSchema, FleetControlSchema]);
+function context(profile, request) {
+  return Object.freeze({
+    assurance: "source-trusted-finalized-replay",
+    historyScope: "verified-native-owner-and-B4-families",
+    network: profile.evidence.network,
+    chainId: profile.evidence.chainId,
+    genesisRoot: profile.evidence.genesisRoot,
+    anchor: request.anchor,
+    owner: request.owner,
+    publicationBlock: request.publicationBlock
+  });
+}
+function positionAfter(left, right) {
+  return left.blockNumber > right.blockNumber || left.blockNumber === right.blockNumber && (left.transactionIndex > right.transactionIndex || left.transactionIndex === right.transactionIndex && left.payloadOrdinal > right.payloadOrdinal);
+}
+function scanCeiling(meter, maximum) {
+  return meter === void 0 ? {} : { maxAggregateBytes: Math.min(maximum, meter.remaining()) };
+}
+function createFleetAuthority(input) {
+  const profile = pinProfile(input);
+  const evidence = createXl1FinalizedPublicationEvidence(profile.evidence);
+  const readState = { active: 0 };
+  const seeds = pinReaders(profile.seeds, profile);
+  let activeCalls = 0;
+  const historyDepth = Math.min(2147483647, Math.max(profile.evidence.limits.maxDecodedDepth, profile.resolutionLimits.maxDepth) + 8);
+  const history = profile.verifiedHistory === void 0 ? void 0 : new VerifiedFleetHistory(profile.verifiedHistory, historyDepth);
+  async function resolved(root, family, work) {
+    work.control.assertActive();
+    const cached = work.roots.get(root);
+    if (cached !== void 0) {
+      if (cached.schema !== family) throw new FleetAuthorityError("unsupported", "declaration-family");
+      return cached;
+    }
+    if (work.roots.size >= profile.limits.maxRootReads) throw new FleetAuthorityError("resource-limit", "root-reads");
+    const result = await resolveFleetPayload(root, family, {
+      seeds: work.seeds,
+      signal: work.control.signal,
+      limits: { ...profile.resolutionLimits, totalTimeoutMs: Math.min(profile.resolutionLimits.totalTimeoutMs, work.control.remainingMs()) }
+    });
+    work.control.assertActive();
+    if (work.capacity.limited) throw new FleetAuthorityError("resource-limit", "reader-capacity");
+    if (result.status !== "verified") {
+      if (result.status === "aborted") throw new FleetAuthorityError("cancelled", "root-cancelled");
+      if (result.reason === "resource-limit") throw new FleetAuthorityError("resource-limit", "root-resource-limit");
+      if (result.reason === "deadline") throw new FleetAuthorityError("deadline", "root-deadline");
+      if (result.attempts.some((attempt) => attempt.status === "unsupported")) throw new FleetAuthorityError("unsupported", "root-definition");
+      throw new FleetAuthorityError("incomplete", "root-unavailable");
+    }
+    work.roots.set(root, result.payload);
+    if (family !== FleetControlSchema) work.declarations.set(root, Object.freeze({ root, payload: result.payload }));
+    return result.payload;
+  }
+  async function scan(request, work, fromBlockNumber = 0) {
+    const { control, meter } = work;
+    if (request.anchor.blockNumber + 1 > profile.limits.maxBlocks) throw new FleetAuthorityError("resource-limit", "history-blocks");
+    const occurrences = [];
+    for (let from = fromBlockNumber; from <= request.anchor.blockNumber; ) {
+      control.assertActive();
+      if (++work.pages.count > profile.limits.maxPages) throw new FleetAuthorityError("resource-limit", "scan-pages");
+      const to = Math.min(request.anchor.blockNumber, from + profile.evidence.limits.maxBlocks - 1);
+      const scope = Object.freeze({
+        authorizers: Object.freeze([request.owner]),
+        schemas: b4Families,
+        ...profile.evidence.forkLineage !== void 0 && { chainIds: Object.freeze([profile.evidence.chainId]) }
+      });
+      const page = await evidence.scanScoped({
+        anchor: request.anchor,
+        fromBlockNumber: from,
+        toBlockNumber: to,
+        signal: control.signal,
+        ...scanCeiling(meter, profile.evidence.limits.maxAggregateBytes),
+        scope
+      });
+      chargeNativeResources(meter, page.resources);
+      control.assertActive();
+      const basis = validateFleetPage(page, profile, request, from, to, scope);
+      if (basis !== void 0) work.queryBasis.scopeCompleteness = basis;
+      for (const fact of page.occurrences) {
+        const previous = occurrences.at(-1);
+        if (fact.network !== profile.evidence.network || fact.chainId !== profile.evidence.chainId || fact.genesisRoot !== profile.evidence.genesisRoot || fact.signer !== request.owner || !b4Families.includes(fact.schema) || fact.blockNumber < from || fact.blockNumber > to || previous !== void 0 && !positionAfter(fact, previous)) throw new FleetAuthorityError("conflict", "occurrence-binding-order");
+        if (occurrences.length >= profile.limits.maxOccurrences) throw new FleetAuthorityError("resource-limit", "occurrences");
+        occurrences.push(fact);
+      }
+      from = to + 1;
+    }
+    return occurrences;
+  }
+  async function original(fact, family, control) {
+    const checked = await verifyFleetPayload(fact.payloadRoot, family, fact.body, profile.foldLimits);
+    control.assertActive();
+    if (checked.status !== "verified") throw new FleetAuthorityError(checked.status === "unsupported" ? "unsupported" : "incomplete", "owner-definition");
+    return checked.payload;
+  }
+  async function discoverFleet(fact, request, work, roots) {
+    if (fact.schema !== FleetSchema || request.fleetRoot !== void 0) return;
+    const checked = await verifyFleetPayload(fact.payloadRoot, FleetSchema, fact.body, profile.foldLimits);
+    work.control.assertActive();
+    if (checked.status !== "verified") {
+      if (fact.signer === request.owner) throw new FleetAuthorityError(checked.status === "unsupported" ? "unsupported" : "incomplete", "owner-declaration");
+      return;
+    }
+    if (FleetZod.parse(checked.payload).owner === request.owner) roots.add(fact.payloadRoot);
+  }
+  async function collect(request, work, occurrences) {
+    const roots = new Set(request.fleetRoot === void 0 ? [] : [request.fleetRoot]);
+    const controls = [];
+    for (const fact of occurrences) {
+      work.control.assertActive();
+      if (fact.blockNumber > request.publicationBlock) continue;
+      await discoverFleet(fact, request, work, roots);
+      if (fact.schema !== FleetControlSchema || fact.signer !== request.owner || fact.blockNumber === request.publicationBlock) continue;
+      const payload = await original(fact, FleetControlSchema, work.control);
+      if (request.fleetRoot !== void 0 && payload.fleetRoot !== request.fleetRoot) continue;
+      const fleet = FleetZod.parse(await resolved(payload.fleetRoot, FleetSchema, work));
+      if (fleet.owner !== request.owner) continue;
+      roots.add(payload.fleetRoot);
+      await resolved(fact.payloadRoot, FleetControlSchema, work);
+      controls.push(Object.freeze({
+        root: fact.payloadRoot,
+        payload,
+        authorizer: fact.signer,
+        block: fact.blockNumber,
+        chainId: fact.chainId,
+        transactionIndex: fact.transactionIndex,
+        payloadIndex: fact.payloadOrdinal
+      }));
+      if ("memberRoot" in payload) await resolved(payload.memberRoot, FleetMemberSchema, work);
+      if ("scopeRoot" in payload) await resolved(payload.scopeRoot, FleetPublicationScopeSchema, work);
+      if (roots.size > profile.limits.maxFleets) throw new FleetAuthorityError("resource-limit", "fleets");
+    }
+    if (roots.size > profile.limits.maxFleets) throw new FleetAuthorityError("resource-limit", "fleets");
+    return { roots, controls };
+  }
+  async function foldWork(request, work, occurrences) {
+    const { roots, controls } = await collect(request, work, occurrences);
+    const views = [];
+    for (const root of roots) {
+      await resolved(root, FleetSchema, work);
+      const selected = controls.filter((fact) => fact.payload.fleetRoot === root);
+      const needed = /* @__PURE__ */ new Set([root]);
+      for (const fact of selected) {
+        if ("memberRoot" in fact.payload) needed.add(fact.payload.memberRoot);
+        if ("scopeRoot" in fact.payload) needed.add(fact.payload.scopeRoot);
+      }
+      const folded = foldFleetControls({
+        owner: request.owner,
+        fleetRoot: root,
+        chainId: profile.evidence.chainId,
+        genesisRoot: profile.evidence.genesisRoot,
+        publicationBlock: request.publicationBlock,
+        controls: selected,
+        declarations: [...needed].map((key) => {
+          const declaration = work.declarations.get(key);
+          if (declaration === void 0) throw new FleetAuthorityError("incomplete", "missing-declaration");
+          return declaration;
+        }),
+        limits: profile.foldLimits,
+        signal: work.control.signal
+      });
+      work.control.assertActive();
+      if (folded.status !== "folded") {
+        const status = folded.status === "aborted" ? "cancelled" : folded.reason === "resource-limit" ? "resource-limit" : folded.status;
+        throw new FleetAuthorityError(status, `fold-${folded.reason}`);
+      }
+      views.push(Object.freeze({
+        ...folded,
+        status: "complete",
+        assurance: "source-trusted-finalized-replay"
+      }));
+    }
+    const basis = work.queryBasis.scopeCompleteness;
+    if (profile.evidence.querySelection === void 0 !== (basis === void 0)) throw new FleetAuthorityError("conflict", "history-query-basis");
+    const result = Object.freeze({
+      ...basis !== void 0 && { scopeCompleteness: basis },
+      ...context(profile, request),
+      status: "complete",
+      correspondence: "native-sdk-verified",
+      history: "complete-genesis-to-anchor",
+      coveredRange: Object.freeze({ fromBlockNumber: 0, toBlockNumber: request.anchor.blockNumber }),
+      views: Object.freeze(views)
+    });
+    return { result, controls };
+  }
+  function restore(entry, work) {
+    const expected = profile.evidence.querySelection === void 0 ? void 0 : "verified-block-committed-query-selection";
+    if (entry.scopeCompleteness !== expected) throw new FleetAuthorityError("conflict", "history-query-policy");
+    if (entry.scopeCompleteness !== void 0) work.queryBasis.scopeCompleteness = entry.scopeCompleteness;
+    for (const [root, payload] of entry.roots) {
+      if (!work.roots.has(root) && work.roots.size >= profile.limits.maxRootReads) throw new FleetAuthorityError("resource-limit", "root-reads");
+      work.roots.set(root, payload);
+      if (payload.schema !== FleetControlSchema) work.declarations.set(root, Object.freeze({ root, payload }));
+    }
+  }
+  async function replayWork(request, work) {
+    const prior = history?.get(request.owner);
+    let occurrences;
+    if (prior === void 0) occurrences = await scan(request, work);
+    else {
+      restore(prior, work);
+      const sameHeight = request.anchor.blockNumber === prior.anchor.blockNumber;
+      if (sameHeight && request.anchor.blockRoot !== prior.anchor.blockRoot) throw new FleetAuthorityError("conflict", "history-anchor");
+      if (sameHeight) occurrences = prior.occurrences;
+      else if (request.anchor.blockNumber < prior.anchor.blockNumber) {
+        await scan(request, work, request.anchor.blockNumber);
+        occurrences = prior.occurrences.filter((fact) => fact.blockNumber <= request.anchor.blockNumber);
+      } else {
+        await scan({ ...request, anchor: prior.anchor }, work, prior.anchor.blockNumber);
+        occurrences = [...prior.occurrences, ...await scan(request, work, prior.anchor.blockNumber + 1)];
+      }
+    }
+    if (occurrences.length > profile.limits.maxOccurrences) throw new FleetAuthorityError("resource-limit", "occurrences");
+    if (history !== void 0 && (prior === void 0 || request.anchor.blockNumber > prior.anchor.blockNumber)) {
+      const completeRequest = {
+        ...request,
+        fleetRoot: void 0,
+        publicationBlock: request.anchor.blockNumber + 1
+      };
+      const complete = await foldWork(completeRequest, work, occurrences);
+      work.control.assertActive();
+      history.publish({
+        owner: request.owner,
+        anchor: request.anchor,
+        occurrences,
+        roots: work.roots.entries().toArray(),
+        ...complete.result.scopeCompleteness !== void 0 && { scopeCompleteness: complete.result.scopeCompleteness }
+      });
+      if (request.fleetRoot === void 0 && request.publicationBlock === completeRequest.publicationBlock) return complete;
+    }
+    return await foldWork(request, work, occurrences);
+  }
+  async function enumerateWork(request, work) {
+    const replay = await replayWork(request, work);
+    return replay.result;
+  }
+  async function execute(request, startedAt, operation) {
+    const control = operationControl(request.signal, profile.limits.totalTimeoutMs, startedAt);
+    let admitted = false;
+    let meter;
+    try {
+      const bound = BigInt(profile.limits.maxPages) * BigInt(profile.evidence.limits.maxAggregateBytes) + BigInt(profile.limits.maxRootReads) * BigInt(profile.resolutionLimits.maxSeeds) * BigInt(profile.resolutionLimits.maxBodyBytes);
+      if (request.maxAggregateBytes !== void 0 || profile.evidence.verifiedPrefix !== void 0) {
+        meter = new FleetMeter(request.maxAggregateBytes ?? Number(bound > BigInt(Number.MAX_SAFE_INTEGER) ? BigInt(Number.MAX_SAFE_INTEGER) : bound), profile.resolutionLimits);
+      }
+      if (request.maxAggregateBytes !== void 0 && BigInt(request.maxAggregateBytes) > bound) throw new FleetAuthorityError("resource-limit", "aggregate-ceiling");
+      control.assertActive();
+      if (activeCalls >= profile.limits.maxConcurrentCalls) throw new FleetAuthorityError("resource-limit", "composition-capacity");
+      activeCalls++;
+      admitted = true;
+      const capacity = { limited: false };
+      const result = await operation({
+        control,
+        ...meter !== void 0 && { meter },
+        roots: /* @__PURE__ */ new Map(),
+        pages: { count: 0 },
+        queryBasis: {},
+        declarations: /* @__PURE__ */ new Map(),
+        capacity,
+        seeds: capacityReaders(seeds, readState, profile.limits.maxConcurrentReads, capacity, meter)
+      });
+      return meter === void 0 ? result : Object.freeze({ ...result, resources: meter.resources() });
+    } catch (error) {
+      const failure = error instanceof FleetAuthorityError ? error : new FleetAuthorityError("incomplete", "composition-source");
+      return Object.freeze({
+        ...context(profile, request),
+        status: failure.status,
+        code: failure.code,
+        ...meter !== void 0 && { resources: meter.resources() }
+      });
+    } finally {
+      if (admitted) activeCalls--;
+      meter?.close();
+      control.dispose();
+    }
+  }
+  async function publisherWork(request, scopeRoot, publisherAddress, work) {
+    const retained = history?.get(request.owner);
+    if (retained !== void 0) restore(retained, work);
+    const scope = FleetPublicationScopeZod.parse(await resolved(scopeRoot, FleetPublicationScopeSchema, work));
+    const result = await enumerateWork({ ...request, fleetRoot: scope.fleetRoot }, work);
+    const basis = result.scopeCompleteness === void 0 ? {} : { scopeCompleteness: result.scopeCompleteness };
+    const view = result.views[0];
+    const matches = view?.fleetActive ? view.grants.filter((grant2) => grant2.scopeRoot === scopeRoot && grant2.publisherAddress === publisherAddress) : [];
+    if (matches.length > 1) throw new FleetAuthorityError("conflict", "publisher-ambiguity");
+    const grant = matches[0];
+    return grant === void 0 ? Object.freeze({
+      ...context(profile, request),
+      ...basis,
+      status: "absent",
+      correspondence: "native-sdk-verified",
+      history: "complete-genesis-to-anchor",
+      scopeRoot,
+      publisherAddress
+    }) : Object.freeze({
+      ...context(profile, request),
+      ...basis,
+      status: "authorized",
+      correspondence: "native-sdk-verified",
+      history: "complete-genesis-to-anchor",
+      fleetRoot: scope.fleetRoot,
+      memberRoot: grant.memberRoot,
+      controlRoot: grant.controlRoot,
+      scopeRoot,
+      publisherAddress
+    });
+  }
+  return Object.freeze({
+    async enumerate(inputRequest) {
+      const startedAt = fleetNow();
+      const request = pinRequest(inputRequest);
+      return await execute(request, startedAt, (work) => enumerateWork(request, work));
+    },
+    async enumerateHistoricalPublishers(inputRequest) {
+      const startedAt = fleetNow();
+      const values = ownRecord(inputRequest, ["anchor", "owner"], ["fleetRoot", "signal", "maxAggregateBytes"]);
+      const anchor = ownRecord(values.anchor, ["blockNumber", "blockRoot"]);
+      const request = pinRequest({
+        ...values,
+        anchor,
+        publicationBlock: anchor.blockNumber + 1
+      }, true);
+      let controls = [];
+      const result = await execute(request, startedAt, async (work) => {
+        const replay = await replayWork(request, work);
+        controls = replay.controls;
+        return replay.result;
+      });
+      return historicalPublisherResult(result, controls, request.fleetRoot);
+    },
+    async resolvePublisher(inputRequest) {
+      const startedAt = fleetNow();
+      const values = ownRecord(inputRequest, ["anchor", "owner", "publicationBlock", "publisherAddress", "scopeRoot"], ["signal", "maxAggregateBytes"]);
+      const publisherAddress = AddressZod4.parse(values.publisherAddress);
+      const scopeRoot = HashZod5.parse(values.scopeRoot);
+      const request = pinRequest({
+        anchor: values.anchor,
+        owner: values.owner,
+        publicationBlock: values.publicationBlock,
+        ...values.signal !== void 0 && { signal: values.signal },
+        ...values.maxAggregateBytes !== void 0 && { maxAggregateBytes: values.maxAggregateBytes }
+      });
+      return await execute(request, startedAt, (work) => publisherWork(request, scopeRoot, publisherAddress, work));
+    },
+    async projectNextPublisher(inputRequest) {
+      const startedAt = fleetNow();
+      const values = ownRecord(inputRequest, ["anchor", "owner", "publisherAddress", "scopeRoot"], ["signal", "maxAggregateBytes"]);
+      const anchor = ownRecord(values.anchor, ["blockNumber", "blockRoot"]);
+      const publisherAddress = AddressZod4.parse(values.publisherAddress);
+      const scopeRoot = HashZod5.parse(values.scopeRoot);
+      const request = pinRequest({
+        anchor,
+        owner: values.owner,
+        publicationBlock: anchor.blockNumber + 1,
+        ...values.signal !== void 0 && { signal: values.signal },
+        ...values.maxAggregateBytes !== void 0 && { maxAggregateBytes: values.maxAggregateBytes }
+      }, true);
+      const result = await execute(request, startedAt, (work) => publisherWork(request, scopeRoot, publisherAddress, work));
+      return nextPublisherProjection(result);
+    }
+  });
+}
+
 // src/createXl1DataLakeSeed.ts
 import { createRestDataLakeViewer } from "@xyo-network/xl1-sdk/providers";
 
@@ -52,18 +1233,18 @@ function endpointPolicy(value) {
   return value;
 }
 function parsedEndpoint(value, policyValue) {
-  const text = endpointText(value);
+  const text2 = endpointText(value);
   const policy = endpointPolicy(policyValue);
   let parsed;
   try {
-    parsed = new URL(text);
+    parsed = new URL(text2);
   } catch {
     throw new TypeError("endpoint must be an unambiguous absolute HTTP(S) URL");
   }
   if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.hostname === "" || parsed.username !== "" || parsed.password !== "") {
     throw new TypeError("endpoint must be an unambiguous absolute HTTP(S) URL");
   }
-  const inputWithoutTrailingSlashes = text.replace(/\/+$/u, "");
+  const inputWithoutTrailingSlashes = text2.replace(/\/+$/u, "");
   const parsedWithoutTrailingSlashes = parsed.href.replace(/\/+$/u, "");
   if (parsedWithoutTrailingSlashes !== inputWithoutTrailingSlashes) {
     throw new TypeError("endpoint must not require URL normalization");
@@ -134,6 +1315,10 @@ async function createXl1DataLakeSeed(options) {
   });
 }
 export {
-  createXl1DataLakeSeed
+  createFleetAuthority,
+  createXl1DataLakeSeed,
+  snapshotFleetQuerySelection,
+  snapshotFleetSelectedPayloadSource,
+  snapshotFleetVerifiedHistory
 };
 //# sourceMappingURL=index.mjs.map