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

package/dist/browser/index.mjs

@@ -5,14 +5,14 @@ import {
   verifyFleetPayload
 } from "@xyo-network/service-kit-protocol";
 import {
-  AddressZod,
+  AddressZod as AddressZod4,
   FleetControlSchema,
   FleetMemberSchema,
   FleetPublicationScopeSchema,
   FleetPublicationScopeZod,
   FleetSchema,
   FleetZod,
-  HashZod
+  HashZod as HashZod5
 } from "@xyo-network/service-kit-schemas";
 import {
   createXl1FinalizedPublicationEvidence
@@ -81,26 +81,263 @@ function operationControl(signal, timeoutMs, startedAt) {
 }
 var fleetNow = now;
 
-// src/fleetProjection.ts
-function nextPublisherProjection(result) {
-  const { publicationBlock: projectionBlock, ...original } = result;
+// 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 = {
-    ...original,
-    projection: "pending-N+1",
-    projectionBlock
+    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 }
   };
-  if (result.status === "authorized" || result.status === "absent") {
+  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({
-      ...context2,
-      status: result.status === "authorized" ? "projected-granted" : "projected-absent",
-      coveredRange: Object.freeze({ fromBlockNumber: 0, toBlockNumber: result.anchor.blockNumber })
+      decodedBytes,
+      chargedBytes: decodedBytes + this.#reserved,
+      nativeDecodedBytes: this.#native,
+      declarationDecodedBytes: this.#declarations,
+      declarationReservedBytes: this.#reserved
     });
   }
-  return Object.freeze(context2);
+};
+function chargeNativeResources(meter, resources) {
+  meter?.native(resources?.decodedBytes);
 }
 
-// src/createFleetAuthority.ts
-var b4Families = Object.freeze([FleetSchema, FleetMemberSchema, FleetPublicationScopeSchema, FleetControlSchema]);
+// 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);
@@ -111,15 +348,26 @@ function ownRecord(input, required, optional = []) {
     return [key, descriptor.value];
   }));
 }
-function finiteProfile(input, keys) {
+function finiteProfile(input, keys, largeBytes = false) {
   const values = ownRecord(input, keys);
-  if (Object.values(values).some((value) => typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0 || value > 2147483647)) throw new RangeError("Every finite positive bound is required");
+  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"]);
-  const evidence = ownRecord(profile.evidence, ["assurance", "chainId", "genesisRoot", "limits", "network", "source"]);
-  const source = ownRecord(evidence.source, ["bodyBaseUrl", "finalizedBaseUrl", "headUrl"], ["fetch"]);
+  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",
@@ -133,11 +381,20 @@ function pinProfile(input) {
     "maxSourceUrlBytes",
     "perCallTimeoutMs",
     "totalTimeoutMs"
-  ]);
+  ], verifiedPrefix !== void 0);
+  const selectedPayloadSource = snapshotFleetSelectedPayloadSource(source.selectedPayloadSource, evidenceLimits.maxSourceUrlBytes);
   const fixedEvidence = Object.freeze({
     ...evidence,
     limits: evidenceLimits,
-    source: Object.freeze(source)
+    ...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",
@@ -164,22 +421,349 @@ function pinProfile(input) {
     limits,
     foldLimits,
     resolutionLimits,
+    verifiedHistory,
     seeds: profile.seeds
   };
 }
-function pinRequest(input, next = false) {
-  const values = ownRecord(input, ["anchor", "owner", "publicationBlock"], ["fleetRoot", "signal"]);
-  const anchor = ownRecord(values.anchor, ["blockNumber", "blockRoot"]);
-  HashZod.parse(anchor.blockRoot);
-  AddressZod.parse(values.owner);
-  if (values.fleetRoot !== void 0) HashZod.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)
-  });
+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();
@@ -195,7 +779,7 @@ function pinReaders(seeds, profile) {
     return Object.freeze({ id: seed.id, reader: Object.freeze({ get }) });
   }));
 }
-function capacityReaders(seeds, state, maximum, capacity) {
+function capacityReaders(seeds, state, maximum, capacity, meter) {
   return Object.freeze(seeds.map((seed) => Object.freeze({
     id: seed.id,
     reader: Object.freeze({
@@ -206,7 +790,7 @@ function capacityReaders(seeds, state, maximum, capacity) {
         }
         state.active++;
         try {
-          return await seed.reader.get(...args);
+          return await (meter === void 0 ? seed.reader.get(...args) : meter.read(seed.reader.get.bind(seed.reader), ...args));
         } finally {
           state.active--;
         }
@@ -214,6 +798,26 @@ function capacityReaders(seeds, state, maximum, capacity) {
     })
   })));
 }
+
+// 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",
@@ -229,38 +833,8 @@ function context(profile, request) {
 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 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 validatePage(page, profile, request, from, to) {
-  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 (page.scopeCompleteness !== "verified-native-header-selection" || page.scope.authorizers?.length !== 1 || page.scope.authorizers[0] !== request.owner || page.scope.schemas?.length !== b4Families.length || page.scope.schemas.some((family, index) => family !== b4Families[index])) throw new FleetAuthorityError("conflict", "scan-scope");
-  if (page.status !== "complete") throw nativeFailure(page);
-  if (page.coveredRange?.fromBlockNumber !== from || page.coveredRange.toBlockNumber !== to || page.continuation !== void 0 || page.issues.length > 0) {
-    throw new FleetAuthorityError("incomplete", "scan-coverage");
-  }
+function scanCeiling(meter, maximum) {
+  return meter === void 0 ? {} : { maxAggregateBytes: Math.min(maximum, meter.remaining()) };
 }
 function createFleetAuthority(input) {
   const profile = pinProfile(input);
@@ -268,6 +842,8 @@ function createFleetAuthority(input) {
   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);
@@ -294,23 +870,31 @@ function createFleetAuthority(input) {
     if (family !== FleetControlSchema) work.declarations.set(root, Object.freeze({ root, payload: result.payload }));
     return result.payload;
   }
-  async function scan(request, control) {
+  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 = [];
-    let pages = 0;
-    for (let from = 0; from <= request.anchor.blockNumber; ) {
+    for (let from = fromBlockNumber; from <= request.anchor.blockNumber; ) {
       control.assertActive();
-      if (++pages > profile.limits.maxPages) throw new FleetAuthorityError("resource-limit", "scan-pages");
+      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,
-        scope: { authorizers: [request.owner], schemas: b4Families }
+        ...scanCeiling(meter, profile.evidence.limits.maxAggregateBytes),
+        scope
       });
+      chargeNativeResources(meter, page.resources);
       control.assertActive();
-      validatePage(page, profile, request, from, to);
+      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");
@@ -367,8 +951,7 @@ function createFleetAuthority(input) {
     if (roots.size > profile.limits.maxFleets) throw new FleetAuthorityError("resource-limit", "fleets");
     return { roots, controls };
   }
-  async function enumerateWork(request, work) {
-    const occurrences = await scan(request, work.control);
+  async function foldWork(request, work, occurrences) {
     const { roots, controls } = await collect(request, work, occurrences);
     const views = [];
     for (const root of roots) {
@@ -405,7 +988,10 @@ function createFleetAuthority(input) {
         assurance: "source-trusted-finalized-replay"
       }));
     }
-    return Object.freeze({
+    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",
@@ -413,44 +999,112 @@ function createFleetAuthority(input) {
       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 };
-      return await operation({
+      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)
+        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
+        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",
@@ -458,6 +1112,7 @@ function createFleetAuthority(input) {
       publisherAddress
     }) : Object.freeze({
       ...context(profile, request),
+      ...basis,
       status: "authorized",
       correspondence: "native-sdk-verified",
       history: "complete-genesis-to-anchor",
@@ -474,30 +1129,49 @@ function createFleetAuthority(input) {
       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"]);
-      const publisherAddress = AddressZod.parse(values.publisherAddress);
-      const scopeRoot = HashZod.parse(values.scopeRoot);
+      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.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"]);
+      const values = ownRecord(inputRequest, ["anchor", "owner", "publisherAddress", "scopeRoot"], ["signal", "maxAggregateBytes"]);
       const anchor = ownRecord(values.anchor, ["blockNumber", "blockRoot"]);
-      const publisherAddress = AddressZod.parse(values.publisherAddress);
-      const scopeRoot = HashZod.parse(values.scopeRoot);
+      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.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);
@@ -559,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");
@@ -642,6 +1316,9 @@ async function createXl1DataLakeSeed(options) {
 }
 export {
   createFleetAuthority,
-  createXl1DataLakeSeed
+  createXl1DataLakeSeed,
+  snapshotFleetQuerySelection,
+  snapshotFleetSelectedPayloadSource,
+  snapshotFleetVerifiedHistory
 };
 //# sourceMappingURL=index.mjs.map