footprintjs 10.5.0 → 10.6.0

package/dist/esm/lib/memory/frameTypes.d.ts

@@ -95,6 +95,8 @@ export type StageSnapshot = {
     stageReads?: Record<string, unknown>;
     /** Native source-read totals across all attempts, only with an owned source book. No values or names. */
     readSourceCounts?: SourceReadCounts;
+    /** Number of native stage-function entries, independent of read retention and ownership-list budgets. */
+    readSourceInvocations?: number;
     logs: Record<string, unknown>;
     errors: Record<string, unknown>;
     metrics: Record<string, unknown>;

package/dist/esm/lib/memory/frameTypes.js

@@ -13,4 +13,4 @@
  * `commitStops`, `tagStops` and `keysReadFromExecutionTree` take one.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frameTypes.js","sourceRoot":"","sources":["../../../../src/lib/memory/frameTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG","sourcesContent":["/**\n * frameTypes.ts — the types of the engine's frame (L4): what one stage inside a run reports.\n *\n * Its snapshot (`StageSnapshot`, one node of the execution tree), its flow messages\n * (`FlowMessage`, `FlowControlType`) and the two retention dials that shape what the snapshot\n * keeps (`ReadTrackingMode`, `WriteTrackingMode`, over `capture/`'s `RetentionPolicy`). They lived\n * in the record's `types.ts` until C6; the record names nothing outside itself now\n * (`RECORD_FILES`, scripts/layering.config.cjs), so they sit beside the frame that writes them.\n *\n * A retried stage's node also carries its attempts (`attempts`, `attemptSummary` — the attempt leaf's types, L0).\n *\n * A `StageSnapshot` is an `ExecutionTree` (`types.ts`), the shape the record's readers walk:\n * `commitStops`, `tagStops` and `keysReadFromExecutionTree` take one.\n */\n\nimport type { Attention } from 'foottrace';\n\nimport type { AttemptRecord, AttemptSummary, LateWrite } from '../attempt/types.js';\nimport type { RetentionPolicy } from '../capture/policies.js';\nimport type { SourceReadCounts } from '../capture/sourceReadCounts.js';\n\n// ── Flow Control Narrative ─────────────────────────────────────────────────\n\n/** Types of control flow decisions captured by the execution engine. */\nexport type FlowControlType = 'next' | 'branch' | 'children' | 'selected' | 'subflow' | 'loop';\n\n/** A single flow control narrative entry. */\nexport interface FlowMessage {\n  type: FlowControlType;\n  description: string;\n  targetStage?: string | string[];\n  rationale?: string;\n  count?: number;\n  iteration?: number;\n  timestamp?: number;\n}\n\n// ── Read / Write Tracking (#14, #13c-A) ────────────────────────────────────\n//\n// The policy family and marker shapes are owned by `capture/` (shared with\n// the deferred-observer capture tier).\n\n/**\n * Policy for how tracked reads are recorded into `StageSnapshot.stageReads`.\n *\n * - `'full'` (default) — every tracked read `structuredClone`s the value into\n *   the stage's read view. Byte-identical to the historical behavior; this is\n *   what snapshot consumers (lens, agentfootprint) see today.\n * - `'summary'` — reads record a cheap {@link ReadSummaryMarker} (type + size\n *   proxy + short preview) instead of the cloned value. O(1)-ish per read —\n *   no value clone, no serialization of large objects.\n * - `'off'` — reads are not recorded at all; `stageReads` is absent from the\n *   snapshot. Zero per-read cost. Values are still readable, and the\n *   `ScopeRecorder.onRead` event still fires (it passes the live reference and\n *   never cloned) — so narrative output is identical in every mode. The policy\n *   scopes ONLY the snapshot's `stageReads` payload.\n *\n * Set via `new FlowChartExecutor(chart, { readTracking })` or\n * `executor.setReadTracking(mode)` (before `run()`).\n *\n * Alias of the shared {@link RetentionPolicy} family (#13c-A) — kept as the\n * shipped public name for the read dial.\n */\nexport type ReadTrackingMode = RetentionPolicy;\n\n/**\n * Policy for how tracked writes are recorded into `StageSnapshot.stageWrites`\n * (#13c-A) — the sibling of {@link ReadTrackingMode}.\n *\n * - `'full'` (default) — every tracked write `structuredClone`s the value into\n *   the stage's write view. Byte-identical to the historical behavior.\n * - `'summary'` — writes record a cheap {@link WriteSummaryMarker} instead of\n *   the cloned value.\n * - `'off'` — writes are not recorded at all; `stageWrites` is absent from the\n *   snapshot. The writes themselves still commit to shared state and still\n *   appear in the commit log — only the per-stage snapshot bookkeeping (and\n *   therefore the commit observer's mutations payload) is affected. (The\n *   commit log's own value encoding has its own lossless dial —\n *   {@link CommitValuesMode}, #13c-B.)\n *\n * Set via `new FlowChartExecutor(chart, { writeTracking })` or\n * `executor.setWriteTracking(mode)` (before `run()`). See\n * `FlowChartExecutorOptions.writeTracking` for the full observable-consequence\n * contract (onCommit payload, redaction precedence, what is OUT of scope).\n */\nexport type WriteTrackingMode = RetentionPolicy;\n\n// ── Stage Snapshot ─────────────────────────────────────────────────────────\n\n/** Serialisable representation of a stage's state (for debugging / visualisation). */\nexport type StageSnapshot = {\n  id: string;\n  /** Unique per-execution-step identifier. Format: [subflowPath/]stageId#executionIndex */\n  runtimeStageId?: string;\n  name?: string;\n  /** Human-readable description of what this stage does (from builder). */\n  description?: string;\n  /** Subflow identifier — present when this stage is a subflow entry point. */\n  subflowId?: string;\n  isDecider?: boolean;\n  isFork?: boolean;\n  /** User-level writes made by this stage (pre-namespace keys → values).\n   *  Shape depends on {@link WriteTrackingMode}: cloned values under `'full'`\n   *  (default), {@link WriteSummaryMarker}s under `'summary'`, absent under\n   *  `'off'`. Redacted writes show `'[REDACTED]'` regardless of mode. */\n  stageWrites?: Record<string, unknown>;\n  /** User-level reads made by this stage (pre-namespace keys → values at read\n   *  time). Shape depends on {@link ReadTrackingMode}: cloned values under\n   *  `'full'` (default), {@link ReadSummaryMarker}s under `'summary'`, absent\n   *  under `'off'`. */\n  stageReads?: Record<string, unknown>;\n  /** Native source-read totals across all attempts, only with an owned source book. No values or names. */\n  readSourceCounts?: SourceReadCounts;\n  logs: Record<string, unknown>;\n  errors: Record<string, unknown>;\n  metrics: Record<string, unknown>;\n  evals: Record<string, unknown>;\n  flowMessages?: FlowMessage[];\n  /**\n   * Every attempt of this execution, in order — when it started, how long it took, how it ended, and the\n   * retry-or-stop decision that followed (`AttemptRecord`): the stage's own under its retry policy, a `timeoutMs`\n   * or a run deadline (10.1, `kind: 'stage'`), and those of the calls it made through `scope.$call` and the\n   * outside attempts it reported through `observed()` (P2, `kind: 'call'` / `'observed'`, the first 1000 —\n   * `StageContext · MAX_CALL_RECORDS`). Absent when there are none. The commit log never carries attempts: a\n   * retried stage is still ONE bundle.\n   */\n  attempts?: readonly AttemptRecord[];\n  /**\n   * Call and observed attempt records this execution made past the first 1000 — counted, not kept (each still\n   * fired `onAttempt`). Absent when none were dropped.\n   */\n  attemptsDropped?: number;\n  /**\n   * The series at a glance — counts per outcome, and how it ended. Stamped when the series ends: absent while it\n   * is still running (a snapshot taken mid-stage) and without a policy.\n   */\n  attemptSummary?: AttemptSummary;\n  /**\n   * Writes (and emits) an attempt tried AFTER it had ended — timed out, aborted or failed — in the order they came\n   * (P1b). Each was dropped at the scope, so none reached the stage's buffer, its commit or a recorder; this is\n   * the record that they were tried — the first 100 (`MAX_LATE_WRITES`). An abandoned function can keep running\n   * after the run ended, so the list can grow after a snapshot was taken. Names only, never values. Absent when\n   * there were none.\n   */\n  lateWrites?: readonly LateWrite[];\n  /**\n   * Fixed-reason marks collected as this execution runs. Absent when no fact needs attention.\n   * Attempt evidence uses canonical Foottrace attempt IDs. Summary-only and stage-error proof resolves within THIS node\n   * through attemptSummary, errors:stageExecutionError or attemptsDropped. Quality marks are read-time recorder work.\n   * Marks retain no error text, values, targets or idempotency keys; omitted proof is disclosed as not-collected.\n   */\n  attention?: readonly Attention[];\n  next?: StageSnapshot;\n  children?: StageSnapshot[];\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frameTypes.js","sourceRoot":"","sources":["../../../../src/lib/memory/frameTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG","sourcesContent":["/**\n * frameTypes.ts — the types of the engine's frame (L4): what one stage inside a run reports.\n *\n * Its snapshot (`StageSnapshot`, one node of the execution tree), its flow messages\n * (`FlowMessage`, `FlowControlType`) and the two retention dials that shape what the snapshot\n * keeps (`ReadTrackingMode`, `WriteTrackingMode`, over `capture/`'s `RetentionPolicy`). They lived\n * in the record's `types.ts` until C6; the record names nothing outside itself now\n * (`RECORD_FILES`, scripts/layering.config.cjs), so they sit beside the frame that writes them.\n *\n * A retried stage's node also carries its attempts (`attempts`, `attemptSummary` — the attempt leaf's types, L0).\n *\n * A `StageSnapshot` is an `ExecutionTree` (`types.ts`), the shape the record's readers walk:\n * `commitStops`, `tagStops` and `keysReadFromExecutionTree` take one.\n */\n\nimport type { Attention } from 'foottrace';\n\nimport type { AttemptRecord, AttemptSummary, LateWrite } from '../attempt/types.js';\nimport type { RetentionPolicy } from '../capture/policies.js';\nimport type { SourceReadCounts } from '../capture/sourceReadCounts.js';\n\n// ── Flow Control Narrative ─────────────────────────────────────────────────\n\n/** Types of control flow decisions captured by the execution engine. */\nexport type FlowControlType = 'next' | 'branch' | 'children' | 'selected' | 'subflow' | 'loop';\n\n/** A single flow control narrative entry. */\nexport interface FlowMessage {\n  type: FlowControlType;\n  description: string;\n  targetStage?: string | string[];\n  rationale?: string;\n  count?: number;\n  iteration?: number;\n  timestamp?: number;\n}\n\n// ── Read / Write Tracking (#14, #13c-A) ────────────────────────────────────\n//\n// The policy family and marker shapes are owned by `capture/` (shared with\n// the deferred-observer capture tier).\n\n/**\n * Policy for how tracked reads are recorded into `StageSnapshot.stageReads`.\n *\n * - `'full'` (default) — every tracked read `structuredClone`s the value into\n *   the stage's read view. Byte-identical to the historical behavior; this is\n *   what snapshot consumers (lens, agentfootprint) see today.\n * - `'summary'` — reads record a cheap {@link ReadSummaryMarker} (type + size\n *   proxy + short preview) instead of the cloned value. O(1)-ish per read —\n *   no value clone, no serialization of large objects.\n * - `'off'` — reads are not recorded at all; `stageReads` is absent from the\n *   snapshot. Zero per-read cost. Values are still readable, and the\n *   `ScopeRecorder.onRead` event still fires (it passes the live reference and\n *   never cloned) — so narrative output is identical in every mode. The policy\n *   scopes ONLY the snapshot's `stageReads` payload.\n *\n * Set via `new FlowChartExecutor(chart, { readTracking })` or\n * `executor.setReadTracking(mode)` (before `run()`).\n *\n * Alias of the shared {@link RetentionPolicy} family (#13c-A) — kept as the\n * shipped public name for the read dial.\n */\nexport type ReadTrackingMode = RetentionPolicy;\n\n/**\n * Policy for how tracked writes are recorded into `StageSnapshot.stageWrites`\n * (#13c-A) — the sibling of {@link ReadTrackingMode}.\n *\n * - `'full'` (default) — every tracked write `structuredClone`s the value into\n *   the stage's write view. Byte-identical to the historical behavior.\n * - `'summary'` — writes record a cheap {@link WriteSummaryMarker} instead of\n *   the cloned value.\n * - `'off'` — writes are not recorded at all; `stageWrites` is absent from the\n *   snapshot. The writes themselves still commit to shared state and still\n *   appear in the commit log — only the per-stage snapshot bookkeeping (and\n *   therefore the commit observer's mutations payload) is affected. (The\n *   commit log's own value encoding has its own lossless dial —\n *   {@link CommitValuesMode}, #13c-B.)\n *\n * Set via `new FlowChartExecutor(chart, { writeTracking })` or\n * `executor.setWriteTracking(mode)` (before `run()`). See\n * `FlowChartExecutorOptions.writeTracking` for the full observable-consequence\n * contract (onCommit payload, redaction precedence, what is OUT of scope).\n */\nexport type WriteTrackingMode = RetentionPolicy;\n\n// ── Stage Snapshot ─────────────────────────────────────────────────────────\n\n/** Serialisable representation of a stage's state (for debugging / visualisation). */\nexport type StageSnapshot = {\n  id: string;\n  /** Unique per-execution-step identifier. Format: [subflowPath/]stageId#executionIndex */\n  runtimeStageId?: string;\n  name?: string;\n  /** Human-readable description of what this stage does (from builder). */\n  description?: string;\n  /** Subflow identifier — present when this stage is a subflow entry point. */\n  subflowId?: string;\n  isDecider?: boolean;\n  isFork?: boolean;\n  /** User-level writes made by this stage (pre-namespace keys → values).\n   *  Shape depends on {@link WriteTrackingMode}: cloned values under `'full'`\n   *  (default), {@link WriteSummaryMarker}s under `'summary'`, absent under\n   *  `'off'`. Redacted writes show `'[REDACTED]'` regardless of mode. */\n  stageWrites?: Record<string, unknown>;\n  /** User-level reads made by this stage (pre-namespace keys → values at read\n   *  time). Shape depends on {@link ReadTrackingMode}: cloned values under\n   *  `'full'` (default), {@link ReadSummaryMarker}s under `'summary'`, absent\n   *  under `'off'`. */\n  stageReads?: Record<string, unknown>;\n  /** Native source-read totals across all attempts, only with an owned source book. No values or names. */\n  readSourceCounts?: SourceReadCounts;\n  /** Number of native stage-function entries, independent of read retention and ownership-list budgets. */\n  readSourceInvocations?: number;\n  logs: Record<string, unknown>;\n  errors: Record<string, unknown>;\n  metrics: Record<string, unknown>;\n  evals: Record<string, unknown>;\n  flowMessages?: FlowMessage[];\n  /**\n   * Every attempt of this execution, in order — when it started, how long it took, how it ended, and the\n   * retry-or-stop decision that followed (`AttemptRecord`): the stage's own under its retry policy, a `timeoutMs`\n   * or a run deadline (10.1, `kind: 'stage'`), and those of the calls it made through `scope.$call` and the\n   * outside attempts it reported through `observed()` (P2, `kind: 'call'` / `'observed'`, the first 1000 —\n   * `StageContext · MAX_CALL_RECORDS`). Absent when there are none. The commit log never carries attempts: a\n   * retried stage is still ONE bundle.\n   */\n  attempts?: readonly AttemptRecord[];\n  /**\n   * Call and observed attempt records this execution made past the first 1000 — counted, not kept (each still\n   * fired `onAttempt`). Absent when none were dropped.\n   */\n  attemptsDropped?: number;\n  /**\n   * The series at a glance — counts per outcome, and how it ended. Stamped when the series ends: absent while it\n   * is still running (a snapshot taken mid-stage) and without a policy.\n   */\n  attemptSummary?: AttemptSummary;\n  /**\n   * Writes (and emits) an attempt tried AFTER it had ended — timed out, aborted or failed — in the order they came\n   * (P1b). Each was dropped at the scope, so none reached the stage's buffer, its commit or a recorder; this is\n   * the record that they were tried — the first 100 (`MAX_LATE_WRITES`). An abandoned function can keep running\n   * after the run ended, so the list can grow after a snapshot was taken. Names only, never values. Absent when\n   * there were none.\n   */\n  lateWrites?: readonly LateWrite[];\n  /**\n   * Fixed-reason marks collected as this execution runs. Absent when no fact needs attention.\n   * Attempt evidence uses canonical Foottrace attempt IDs. Summary-only and stage-error proof resolves within THIS node\n   * through attemptSummary, errors:stageExecutionError or attemptsDropped. Quality marks are read-time recorder work.\n   * Marks retain no error text, values, targets or idempotency keys; omitted proof is disclosed as not-collected.\n   */\n  attention?: readonly Attention[];\n  next?: StageSnapshot;\n  children?: StageSnapshot[];\n};\n"]}

package/dist/esm/lib/sinks/indexedAdmission.d.ts

@@ -0,0 +1,14 @@
+import type { IndexedLimits, IndexedRecordFileOptions, IndexedRecordFileReason } from './indexedTypes.js';
+export declare class IndexedRefusal extends Error {
+    readonly reason: IndexedRecordFileReason;
+    constructor(reason: IndexedRecordFileReason);
+}
+/** An index key, not a source-ID or record codec. Canonical record admission remains in Foottrace. */
+export declare function indexedAddress(value: unknown): string;
+export declare function indexedLimits(options: IndexedRecordFileOptions): IndexedLimits;
+export declare function refused(error: unknown): {
+    readonly status: 'unknown';
+    readonly reason: IndexedRecordFileReason;
+};
+/** Filesystem errors and rejected bytes are never interpolated into a served reason. */
+export declare function checkSignal(signal: AbortSignal): void;

package/dist/esm/lib/sinks/indexedAdmission.js

@@ -0,0 +1,77 @@
+import { ownData } from '../capture/noteShape.js';
+export class IndexedRefusal extends Error {
+    reason;
+    constructor(reason) {
+        super('indexed record file: evidence unavailable');
+        this.reason = reason;
+    }
+}
+/** An index key, not a source-ID or record codec. Canonical record admission remains in Foottrace. */
+export function indexedAddress(value) {
+    const run = ownData(value, 'logRunId');
+    const path = ownData(value, 'drillPath');
+    if (typeof run !== 'string' || !run.length || run.length > 2048 || !Array.isArray(path))
+        throw new IndexedRefusal('invalid-data');
+    const length = Object.getOwnPropertyDescriptor(path, 'length')?.value;
+    if (Object.getPrototypeOf(path) !== Array.prototype || !Number.isSafeInteger(length) || length > 64)
+        throw new IndexedRefusal('invalid-data');
+    const segments = [];
+    for (let index = 0; index < length; index++) {
+        const segment = Object.getOwnPropertyDescriptor(path, String(index))?.value;
+        if (typeof segment !== 'string' || !segment.length || segment.length > 2048)
+            throw new IndexedRefusal('invalid-data');
+        segments.push(segment);
+    }
+    return JSON.stringify([run, segments]);
+}
+function limit(options, name, fallback, maximum) {
+    const configured = ownData(options, name);
+    const value = configured === undefined ? fallback : configured;
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1 || value > maximum)
+        throw new TypeError('openIndexedRecordFile: invalid host limits');
+    return value;
+}
+export function indexedLimits(options) {
+    if (!options || Object.getPrototypeOf(options) !== Object.prototype)
+        throw new TypeError('openIndexedRecordFile: explicit host authorization required');
+    for (const key of Reflect.ownKeys(options)) {
+        const descriptor = Object.getOwnPropertyDescriptor(options, key);
+        if (!descriptor || !Object.prototype.hasOwnProperty.call(descriptor, 'value'))
+            throw new TypeError('openIndexedRecordFile: options must be plain data');
+        if (typeof key !== 'string' ||
+            !['allowedScopes', 'maxBytes', 'maxEntryBytes', 'maxEntries', 'maxScopeBytes', 'timeoutMs', 'signal'].includes(key))
+            throw new TypeError('openIndexedRecordFile: unsupported host option');
+    }
+    const scopes = ownData(options, 'allowedScopes');
+    if (!Array.isArray(scopes) || Object.getPrototypeOf(scopes) !== Array.prototype || scopes.length > 256)
+        throw new TypeError('openIndexedRecordFile: explicit host authorization required');
+    const allowed = new Set();
+    try {
+        for (let index = 0; index < scopes.length; index++)
+            allowed.add(indexedAddress(Object.getOwnPropertyDescriptor(scopes, String(index))?.value));
+    }
+    catch {
+        throw new TypeError('openIndexedRecordFile: invalid authorized scope');
+    }
+    const signal = ownData(options, 'signal');
+    if (signal !== undefined && !(signal instanceof AbortSignal))
+        throw new TypeError('openIndexedRecordFile: invalid cancellation signal');
+    return {
+        allowed,
+        maxBytes: limit(options, 'maxBytes', 64 * 1024 * 1024, 256 * 1024 * 1024),
+        maxEntryBytes: limit(options, 'maxEntryBytes', 8 * 1024 * 1024, 8 * 1024 * 1024),
+        maxEntries: limit(options, 'maxEntries', 16384, 65536),
+        maxScopeBytes: limit(options, 'maxScopeBytes', 8 * 1024 * 1024, 64 * 1024 * 1024),
+        timeoutMs: limit(options, 'timeoutMs', 10000, 30000),
+        ...(signal && { signal }),
+    };
+}
+export function refused(error) {
+    return { status: 'unknown', reason: error instanceof IndexedRefusal ? error.reason : 'unavailable' };
+}
+/** Filesystem errors and rejected bytes are never interpolated into a served reason. */
+export function checkSignal(signal) {
+    if (signal.aborted)
+        throw new IndexedRefusal('cancelled');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"indexedAdmission.js","sourceRoot":"","sources":["../../../../src/lib/sinks/indexedAdmission.ts"],"names":[],"mappings":"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","sourcesContent":["import { ownData } from '../capture/noteShape.js';\nimport type { IndexedLimits, IndexedRecordFileOptions, IndexedRecordFileReason } from './indexedTypes.js';\n\nexport class IndexedRefusal extends Error {\n  constructor(readonly reason: IndexedRecordFileReason) {\n    super('indexed record file: evidence unavailable');\n  }\n}\n\n/** An index key, not a source-ID or record codec. Canonical record admission remains in Foottrace. */\nexport function indexedAddress(value: unknown): string {\n  const run = ownData(value, 'logRunId');\n  const path = ownData(value, 'drillPath');\n  if (typeof run !== 'string' || !run.length || run.length > 2048 || !Array.isArray(path))\n    throw new IndexedRefusal('invalid-data');\n  const length = Object.getOwnPropertyDescriptor(path, 'length')?.value;\n  if (Object.getPrototypeOf(path) !== Array.prototype || !Number.isSafeInteger(length) || length > 64)\n    throw new IndexedRefusal('invalid-data');\n  const segments: string[] = [];\n  for (let index = 0; index < length; index++) {\n    const segment = Object.getOwnPropertyDescriptor(path, String(index))?.value;\n    if (typeof segment !== 'string' || !segment.length || segment.length > 2048)\n      throw new IndexedRefusal('invalid-data');\n    segments.push(segment);\n  }\n  return JSON.stringify([run, segments]);\n}\n\nfunction limit(options: unknown, name: string, fallback: number, maximum: number): number {\n  const configured = ownData(options, name);\n  const value = configured === undefined ? fallback : configured;\n  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1 || value > maximum)\n    throw new TypeError('openIndexedRecordFile: invalid host limits');\n  return value;\n}\n\nexport function indexedLimits(options: IndexedRecordFileOptions): IndexedLimits {\n  if (!options || Object.getPrototypeOf(options) !== Object.prototype)\n    throw new TypeError('openIndexedRecordFile: explicit host authorization required');\n  for (const key of Reflect.ownKeys(options)) {\n    const descriptor = Object.getOwnPropertyDescriptor(options, key);\n    if (!descriptor || !Object.prototype.hasOwnProperty.call(descriptor, 'value'))\n      throw new TypeError('openIndexedRecordFile: options must be plain data');\n    if (\n      typeof key !== 'string' ||\n      !['allowedScopes', 'maxBytes', 'maxEntryBytes', 'maxEntries', 'maxScopeBytes', 'timeoutMs', 'signal'].includes(\n        key,\n      )\n    )\n      throw new TypeError('openIndexedRecordFile: unsupported host option');\n  }\n  const scopes = ownData(options, 'allowedScopes');\n  if (!Array.isArray(scopes) || Object.getPrototypeOf(scopes) !== Array.prototype || scopes.length > 256)\n    throw new TypeError('openIndexedRecordFile: explicit host authorization required');\n  const allowed = new Set<string>();\n  try {\n    for (let index = 0; index < scopes.length; index++)\n      allowed.add(indexedAddress(Object.getOwnPropertyDescriptor(scopes, String(index))?.value));\n  } catch {\n    throw new TypeError('openIndexedRecordFile: invalid authorized scope');\n  }\n  const signal = ownData(options, 'signal') as AbortSignal | undefined;\n  if (signal !== undefined && !(signal instanceof AbortSignal))\n    throw new TypeError('openIndexedRecordFile: invalid cancellation signal');\n  return {\n    allowed,\n    maxBytes: limit(options, 'maxBytes', 64 * 1024 * 1024, 256 * 1024 * 1024),\n    maxEntryBytes: limit(options, 'maxEntryBytes', 8 * 1024 * 1024, 8 * 1024 * 1024),\n    maxEntries: limit(options, 'maxEntries', 16384, 65536),\n    maxScopeBytes: limit(options, 'maxScopeBytes', 8 * 1024 * 1024, 64 * 1024 * 1024),\n    timeoutMs: limit(options, 'timeoutMs', 10000, 30000),\n    ...(signal && { signal }),\n  };\n}\n\nexport function refused(error: unknown): { readonly status: 'unknown'; readonly reason: IndexedRecordFileReason } {\n  return { status: 'unknown', reason: error instanceof IndexedRefusal ? error.reason : 'unavailable' };\n}\n\n/** Filesystem errors and rejected bytes are never interpolated into a served reason. */\nexport function checkSignal(signal: AbortSignal): void {\n  if (signal.aborted) throw new IndexedRefusal('cancelled');\n}\n"]}

package/dist/esm/lib/sinks/indexedIO.d.ts

@@ -0,0 +1,14 @@
+import type { IndexedRecordUnknown } from './indexedTypes.js';
+/** The path is a host capability, never a path constructed from a stored run or requested node. */
+export declare function openIndexedDescriptor(path: string): number;
+export declare function fileIdentity(fd: number): {
+    readonly key: string;
+    readonly size: number;
+};
+export declare function assertIdentity(fd: number, key: string): void;
+export declare function digest(bytes: Uint8Array): string;
+/** Positional bytes only; exact short-read accounting is retained even when a later check refuses them. */
+export declare function readBytes(fd: number, offset: number, bytes: number, signal: AbortSignal, count: (bytes: number) => void, submitted?: () => void): Promise<Uint8Array>;
+export declare function closeDescriptor(fd: number): Promise<void>;
+/** A timeout bounds the wait, never frees an unfinished operation's file/slot. */
+export declare function boundedIndexedWork<T>(work: (signal: AbortSignal) => Promise<T>, timeoutMs: number, signal: AbortSignal | undefined, settled: () => void): Promise<T | IndexedRecordUnknown>;

package/dist/esm/lib/sinks/indexedIO.js

@@ -0,0 +1,96 @@
+import { createHash } from 'node:crypto';
+import { close, constants, fstatSync, openSync, read } from 'node:fs';
+import { getuid } from 'node:process';
+import { checkSignal, IndexedRefusal } from './indexedAdmission.js';
+/** The path is a host capability, never a path constructed from a stored run or requested node. */
+export function openIndexedDescriptor(path) {
+    if (typeof path !== 'string' || !path.length)
+        throw new TypeError('openIndexedRecordFile: invalid path');
+    return openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+}
+export function fileIdentity(fd) {
+    const stat = fstatSync(fd);
+    const uid = typeof getuid === 'function' ? getuid() : undefined;
+    if (!stat.isFile() ||
+        stat.nlink !== 1 ||
+        (uid !== undefined && (stat.uid !== uid || (stat.mode & 0o022) !== 0)) ||
+        !Number.isSafeInteger(stat.size) ||
+        stat.size < 0)
+        throw new IndexedRefusal('unavailable');
+    return { key: JSON.stringify([stat.dev, stat.ino, stat.size, stat.mtimeMs, stat.ctimeMs]), size: stat.size };
+}
+export function assertIdentity(fd, key) {
+    if (fileIdentity(fd).key !== key)
+        throw new IndexedRefusal('stale');
+}
+export function digest(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+/** Positional bytes only; exact short-read accounting is retained even when a later check refuses them. */
+export async function readBytes(fd, offset, bytes, signal, count, submitted) {
+    const buffer = new Uint8Array(bytes);
+    let filled = 0;
+    while (filled < bytes) {
+        checkSignal(signal);
+        const length = await new Promise((resolve, reject) => {
+            submitted?.();
+            read(fd, buffer, filled, bytes - filled, offset + filled, (error, amount) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(amount);
+            });
+        });
+        count(length);
+        if (!length)
+            throw new IndexedRefusal('stale');
+        filled += length;
+    }
+    checkSignal(signal);
+    return buffer;
+}
+export function closeDescriptor(fd) {
+    return new Promise((resolve) => close(fd, () => resolve()));
+}
+/** A timeout bounds the wait, never frees an unfinished operation's file/slot. */
+export async function boundedIndexedWork(work, timeoutMs, signal, settled) {
+    if (signal?.aborted) {
+        settled();
+        return { status: 'unknown', reason: 'cancelled' };
+    }
+    const controller = new AbortController();
+    const deadline = performance.now() + timeoutMs;
+    let interrupt = () => undefined;
+    const interrupted = new Promise((resolve) => (interrupt = resolve));
+    const cancel = () => {
+        controller.abort();
+        interrupt({ status: 'unknown', reason: 'cancelled' });
+    };
+    signal?.addEventListener('abort', cancel, { once: true });
+    const timer = setTimeout(() => {
+        controller.abort();
+        interrupt({ status: 'unknown', reason: 'timeout' });
+    }, timeoutMs);
+    const running = Promise.resolve()
+        .then(() => work(controller.signal))
+        .then((value) => {
+        if (performance.now() < deadline)
+            return value;
+        controller.abort();
+        return { status: 'unknown', reason: 'timeout' };
+    }, (error) => {
+        if (performance.now() < deadline)
+            throw error;
+        controller.abort();
+        return { status: 'unknown', reason: 'timeout' };
+    });
+    running.then(settled, settled);
+    try {
+        return await Promise.race([running, interrupted]);
+    }
+    finally {
+        clearTimeout(timer);
+        signal?.removeEventListener('abort', cancel);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"indexedIO.js","sourceRoot":"","sources":["../../../../src/lib/sinks/indexedIO.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from 'node:crypto';\nimport { close, constants, fstatSync, openSync, read } from 'node:fs';\nimport { getuid } from 'node:process';\n\nimport { checkSignal, IndexedRefusal } from './indexedAdmission.js';\nimport type { IndexedRecordUnknown } from './indexedTypes.js';\n\n/** The path is a host capability, never a path constructed from a stored run or requested node. */\nexport function openIndexedDescriptor(path: string): number {\n  if (typeof path !== 'string' || !path.length) throw new TypeError('openIndexedRecordFile: invalid path');\n  return openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));\n}\n\nexport function fileIdentity(fd: number): { readonly key: string; readonly size: number } {\n  const stat = fstatSync(fd);\n  const uid = typeof getuid === 'function' ? getuid() : undefined;\n  if (\n    !stat.isFile() ||\n    stat.nlink !== 1 ||\n    (uid !== undefined && (stat.uid !== uid || (stat.mode & 0o022) !== 0)) ||\n    !Number.isSafeInteger(stat.size) ||\n    stat.size < 0\n  )\n    throw new IndexedRefusal('unavailable');\n  return { key: JSON.stringify([stat.dev, stat.ino, stat.size, stat.mtimeMs, stat.ctimeMs]), size: stat.size };\n}\n\nexport function assertIdentity(fd: number, key: string): void {\n  if (fileIdentity(fd).key !== key) throw new IndexedRefusal('stale');\n}\n\nexport function digest(bytes: Uint8Array): string {\n  return createHash('sha256').update(bytes).digest('hex');\n}\n\n/** Positional bytes only; exact short-read accounting is retained even when a later check refuses them. */\nexport async function readBytes(\n  fd: number,\n  offset: number,\n  bytes: number,\n  signal: AbortSignal,\n  count: (bytes: number) => void,\n  submitted?: () => void,\n): Promise<Uint8Array> {\n  const buffer = new Uint8Array(bytes);\n  let filled = 0;\n  while (filled < bytes) {\n    checkSignal(signal);\n    const length = await new Promise<number>((resolve, reject) => {\n      submitted?.();\n      read(fd, buffer, filled, bytes - filled, offset + filled, (error, amount) => {\n        if (error) reject(error);\n        else resolve(amount);\n      });\n    });\n    count(length);\n    if (!length) throw new IndexedRefusal('stale');\n    filled += length;\n  }\n  checkSignal(signal);\n  return buffer;\n}\n\nexport function closeDescriptor(fd: number): Promise<void> {\n  return new Promise((resolve) => close(fd, () => resolve()));\n}\n\n/** A timeout bounds the wait, never frees an unfinished operation's file/slot. */\nexport async function boundedIndexedWork<T>(\n  work: (signal: AbortSignal) => Promise<T>,\n  timeoutMs: number,\n  signal: AbortSignal | undefined,\n  settled: () => void,\n): Promise<T | IndexedRecordUnknown> {\n  if (signal?.aborted) {\n    settled();\n    return { status: 'unknown', reason: 'cancelled' };\n  }\n  const controller = new AbortController();\n  const deadline = performance.now() + timeoutMs;\n  let interrupt: (reason: IndexedRecordUnknown) => void = () => undefined;\n  const interrupted = new Promise<IndexedRecordUnknown>((resolve) => (interrupt = resolve));\n  const cancel = () => {\n    controller.abort();\n    interrupt({ status: 'unknown', reason: 'cancelled' });\n  };\n  signal?.addEventListener('abort', cancel, { once: true });\n  const timer = setTimeout(() => {\n    controller.abort();\n    interrupt({ status: 'unknown', reason: 'timeout' });\n  }, timeoutMs);\n  const running = Promise.resolve()\n    .then(() => work(controller.signal))\n    .then(\n      (value) => {\n        if (performance.now() < deadline) return value;\n        controller.abort();\n        return { status: 'unknown', reason: 'timeout' } as const;\n      },\n      (error: unknown) => {\n        if (performance.now() < deadline) throw error;\n        controller.abort();\n        return { status: 'unknown', reason: 'timeout' } as const;\n      },\n    );\n  running.then(settled, settled);\n  try {\n    return await Promise.race([running, interrupted]);\n  } finally {\n    clearTimeout(timer);\n    signal?.removeEventListener('abort', cancel);\n  }\n}\n"]}

package/dist/esm/lib/sinks/indexedRecordFile.d.ts

@@ -0,0 +1,3 @@
+import type { IndexedRecordFileOptions, IndexedRecordFileResult } from './indexedTypes.js';
+/** Explicit bounded whole-file preparation, followed by authorized positional scope reads from that immutable file. */
+export declare function openIndexedRecordFile(path: string, options: IndexedRecordFileOptions): Promise<IndexedRecordFileResult>;

package/dist/esm/lib/sinks/indexedRecordFile.js

@@ -0,0 +1,120 @@
+import { ownData } from '../capture/noteShape.js';
+import { checkSignal, indexedAddress, indexedLimits, IndexedRefusal, refused } from './indexedAdmission.js';
+import { assertIdentity, boundedIndexedWork, closeDescriptor, digest, fileIdentity, openIndexedDescriptor, readBytes, } from './indexedIO.js';
+import { scanIndexedFile } from './indexedScan.js';
+/** Explicit bounded whole-file preparation, followed by authorized positional scope reads from that immutable file. */
+export async function openIndexedRecordFile(path, options) {
+    const limits = indexedLimits(options);
+    if (limits.signal?.aborted)
+        return { status: 'unknown', reason: 'cancelled' };
+    let fd;
+    try {
+        fd = openIndexedDescriptor(path);
+    }
+    catch {
+        return { status: 'unknown', reason: 'unavailable' };
+    }
+    const stats = { preparationBytes: 0, scopeBytes: 0, readCalls: 0 };
+    let prepared = false;
+    let abandoned = false;
+    let running = false;
+    let closePromise;
+    const release = () => (closePromise ??= closeDescriptor(fd));
+    try {
+        const identity = fileIdentity(fd);
+        running = true;
+        const result = await boundedIndexedWork((signal) => scanIndexedFile(fd, identity, limits, signal, (bytes) => (stats.preparationBytes += bytes)), limits.timeoutMs, limits.signal, () => {
+            running = false;
+            if (abandoned)
+                release();
+        });
+        if (!(result instanceof Map))
+            return result;
+        prepared = true;
+        return { status: 'ready', reader: indexedReader(fd, identity.key, result, limits, stats) };
+    }
+    catch (error) {
+        return refused(error);
+    }
+    finally {
+        if (!prepared) {
+            abandoned = true;
+            if (!running)
+                await release();
+        }
+    }
+}
+function indexedReader(fd, identity, index, limits, stats) {
+    let closed = false;
+    let active = false;
+    let finishClose;
+    let closePromise;
+    const release = () => {
+        if (closed && !active)
+            closeDescriptor(fd).then(() => finishClose?.());
+    };
+    return Object.freeze({
+        get stats() {
+            return Object.freeze({ ...stats });
+        },
+        async readScope(address, context) {
+            try {
+                if (context !== undefined &&
+                    (!context ||
+                        Object.getPrototypeOf(context) !== Object.prototype ||
+                        (Object.getOwnPropertyDescriptor(context, 'signal') !== undefined &&
+                            !Object.prototype.hasOwnProperty.call(Object.getOwnPropertyDescriptor(context, 'signal'), 'value'))))
+                    throw new IndexedRefusal('invalid-data');
+                const signal = context === undefined ? undefined : ownData(context, 'signal');
+                if (signal !== undefined && !(signal instanceof AbortSignal))
+                    throw new IndexedRefusal('invalid-data');
+                if (signal?.aborted)
+                    throw new IndexedRefusal('cancelled');
+                if (closed)
+                    throw new IndexedRefusal('closed');
+                const key = indexedAddress(address);
+                if (!limits.allowed.has(key))
+                    throw new IndexedRefusal('not-permitted');
+                if (active)
+                    throw new IndexedRefusal('busy');
+                assertIdentity(fd, identity);
+                const ranges = index.get(key);
+                if (!ranges)
+                    throw new IndexedRefusal('no-match');
+                active = true;
+                return await boundedIndexedWork((inner) => loadIndexedScope(fd, identity, key, ranges, inner, (bytes) => (stats.scopeBytes += bytes), () => stats.readCalls++), limits.timeoutMs, signal, () => {
+                    active = false;
+                    release();
+                });
+            }
+            catch (error) {
+                return refused(error);
+            }
+        },
+        close() {
+            if (!closePromise) {
+                closed = true;
+                closePromise = new Promise((resolve) => (finishClose = resolve));
+                release();
+            }
+            return closePromise;
+        },
+    });
+}
+async function loadIndexedScope(fd, identity, key, ranges, signal, count, submitted) {
+    const entries = [];
+    for (const range of ranges) {
+        checkSignal(signal);
+        const bytes = await readBytes(fd, range.offset, range.bytes, signal, count, submitted);
+        if (digest(bytes) !== range.digest)
+            throw new IndexedRefusal('stale');
+        const entry = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+        if (indexedAddress(ownData(entry, 'address')) !== key)
+            throw new IndexedRefusal('invalid-data');
+        entries.push(entry);
+    }
+    assertIdentity(fd, identity);
+    checkSignal(signal);
+    return { status: 'loaded', entries, bytesRead: ranges.reduce((total, range) => total + range.bytes, 0) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"indexedRecordFile.js","sourceRoot":"","sources":["../../../../src/lib/sinks/indexedRecordFile.ts"],"names":[],"mappings":"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","sourcesContent":["import type { LogAddress } from 'foottrace';\n\nimport { ownData } from '../capture/noteShape.js';\nimport { checkSignal, indexedAddress, indexedLimits, IndexedRefusal, refused } from './indexedAdmission.js';\nimport {\n  assertIdentity,\n  boundedIndexedWork,\n  closeDescriptor,\n  digest,\n  fileIdentity,\n  openIndexedDescriptor,\n  readBytes,\n} from './indexedIO.js';\nimport { scanIndexedFile } from './indexedScan.js';\nimport type {\n  IndexedLimits,\n  IndexedRange,\n  IndexedRecordFile,\n  IndexedRecordFileOptions,\n  IndexedRecordFileResult,\n  IndexedRecordScope,\n  IndexedRecordUnknown,\n} from './indexedTypes.js';\n\n/** Explicit bounded whole-file preparation, followed by authorized positional scope reads from that immutable file. */\nexport async function openIndexedRecordFile(\n  path: string,\n  options: IndexedRecordFileOptions,\n): Promise<IndexedRecordFileResult> {\n  const limits = indexedLimits(options);\n  if (limits.signal?.aborted) return { status: 'unknown', reason: 'cancelled' };\n  let fd: number;\n  try {\n    fd = openIndexedDescriptor(path);\n  } catch {\n    return { status: 'unknown', reason: 'unavailable' };\n  }\n  const stats = { preparationBytes: 0, scopeBytes: 0, readCalls: 0 };\n  let prepared = false;\n  let abandoned = false;\n  let running = false;\n  let closePromise: Promise<void> | undefined;\n  const release = () => (closePromise ??= closeDescriptor(fd));\n  try {\n    const identity = fileIdentity(fd);\n    running = true;\n    const result = await boundedIndexedWork(\n      (signal) => scanIndexedFile(fd, identity, limits, signal, (bytes) => (stats.preparationBytes += bytes)),\n      limits.timeoutMs,\n      limits.signal,\n      () => {\n        running = false;\n        if (abandoned) release();\n      },\n    );\n    if (!(result instanceof Map)) return result;\n    prepared = true;\n    return { status: 'ready', reader: indexedReader(fd, identity.key, result, limits, stats) };\n  } catch (error) {\n    return refused(error);\n  } finally {\n    if (!prepared) {\n      abandoned = true;\n      if (!running) await release();\n    }\n  }\n}\n\nfunction indexedReader(\n  fd: number,\n  identity: string,\n  index: ReadonlyMap<string, readonly IndexedRange[]>,\n  limits: IndexedLimits,\n  stats: { preparationBytes: number; scopeBytes: number; readCalls: number },\n): IndexedRecordFile {\n  let closed = false;\n  let active = false;\n  let finishClose: (() => void) | undefined;\n  let closePromise: Promise<void> | undefined;\n  const release = () => {\n    if (closed && !active) closeDescriptor(fd).then(() => finishClose?.());\n  };\n  return Object.freeze({\n    get stats() {\n      return Object.freeze({ ...stats });\n    },\n    async readScope(address: LogAddress, context?: { readonly signal?: AbortSignal }) {\n      try {\n        if (\n          context !== undefined &&\n          (!context ||\n            Object.getPrototypeOf(context) !== Object.prototype ||\n            (Object.getOwnPropertyDescriptor(context, 'signal') !== undefined &&\n              !Object.prototype.hasOwnProperty.call(Object.getOwnPropertyDescriptor(context, 'signal'), 'value')))\n        )\n          throw new IndexedRefusal('invalid-data');\n        const signal = context === undefined ? undefined : (ownData(context, 'signal') as AbortSignal | undefined);\n        if (signal !== undefined && !(signal instanceof AbortSignal)) throw new IndexedRefusal('invalid-data');\n        if (signal?.aborted) throw new IndexedRefusal('cancelled');\n        if (closed) throw new IndexedRefusal('closed');\n        const key = indexedAddress(address);\n        if (!limits.allowed.has(key)) throw new IndexedRefusal('not-permitted');\n        if (active) throw new IndexedRefusal('busy');\n        assertIdentity(fd, identity);\n        const ranges = index.get(key);\n        if (!ranges) throw new IndexedRefusal('no-match');\n        active = true;\n        return await boundedIndexedWork(\n          (inner) =>\n            loadIndexedScope(\n              fd,\n              identity,\n              key,\n              ranges,\n              inner,\n              (bytes) => (stats.scopeBytes += bytes),\n              () => stats.readCalls++,\n            ),\n          limits.timeoutMs,\n          signal,\n          () => {\n            active = false;\n            release();\n          },\n        );\n      } catch (error) {\n        return refused(error);\n      }\n    },\n    close() {\n      if (!closePromise) {\n        closed = true;\n        closePromise = new Promise<void>((resolve) => (finishClose = resolve));\n        release();\n      }\n      return closePromise;\n    },\n  });\n}\n\nasync function loadIndexedScope(\n  fd: number,\n  identity: string,\n  key: string,\n  ranges: readonly IndexedRange[],\n  signal: AbortSignal,\n  count: (bytes: number) => void,\n  submitted: () => void,\n): Promise<IndexedRecordScope | IndexedRecordUnknown> {\n  const entries: unknown[] = [];\n  for (const range of ranges) {\n    checkSignal(signal);\n    const bytes = await readBytes(fd, range.offset, range.bytes, signal, count, submitted);\n    if (digest(bytes) !== range.digest) throw new IndexedRefusal('stale');\n    const entry: unknown = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));\n    if (indexedAddress(ownData(entry, 'address')) !== key) throw new IndexedRefusal('invalid-data');\n    entries.push(entry);\n  }\n  assertIdentity(fd, identity);\n  checkSignal(signal);\n  return { status: 'loaded', entries, bytesRead: ranges.reduce((total, range) => total + range.bytes, 0) };\n}\n"]}

package/dist/esm/lib/sinks/indexedScan.d.ts

@@ -0,0 +1,6 @@
+import type { IndexedLimits, IndexedRange } from './indexedTypes.js';
+/** One whole-file preparation pass. Only authorized range metadata is retained, never the archive's values. */
+export declare function scanIndexedFile(fd: number, identity: {
+    readonly key: string;
+    readonly size: number;
+}, limits: IndexedLimits, signal: AbortSignal, count: (bytes: number) => void): Promise<Map<string, readonly IndexedRange[]>>;

package/dist/esm/lib/sinks/indexedScan.js

@@ -0,0 +1,73 @@
+import { ownData } from '../capture/noteShape.js';
+import { checkSignal, indexedAddress, IndexedRefusal } from './indexedAdmission.js';
+import { assertIdentity, digest, readBytes } from './indexedIO.js';
+/** One whole-file preparation pass. Only authorized range metadata is retained, never the archive's values. */
+export async function scanIndexedFile(fd, identity, limits, signal, count) {
+    if (identity.size > limits.maxBytes)
+        throw new IndexedRefusal('too-large');
+    const index = new Map();
+    const totals = new Map();
+    let entries = 0;
+    let lineStart = 0;
+    let pieces = [];
+    let lineBytes = 0;
+    const append = (piece) => {
+        lineBytes += piece.length;
+        if (lineBytes > limits.maxEntryBytes)
+            throw new IndexedRefusal('too-large');
+        if (piece.length)
+            pieces.push(piece);
+    };
+    const decoder = new TextDecoder('utf-8', { fatal: true });
+    for (let position = 0; position < identity.size;) {
+        checkSignal(signal);
+        const chunk = await readBytes(fd, position, Math.min(65536, identity.size - position), signal, count);
+        position += chunk.length;
+        let start = 0;
+        for (let end = 0; end < chunk.length; end++) {
+            if (chunk[end] !== 10)
+                continue;
+            append(chunk.subarray(start, end + 1));
+            // Assemble once at the delimiter, rather than repeatedly copying a growing partial line.
+            const bytes = new Uint8Array(lineBytes);
+            let filled = 0;
+            for (const piece of pieces) {
+                bytes.set(piece, filled);
+                filled += piece.length;
+            }
+            const text = decoder.decode(bytes);
+            if (text.trim()) {
+                if (++entries > limits.maxEntries)
+                    throw new IndexedRefusal('too-large');
+                let row;
+                try {
+                    row = JSON.parse(text);
+                }
+                catch {
+                    throw new IndexedRefusal('invalid-data');
+                }
+                const scope = indexedAddress(ownData(row, 'address'));
+                if (limits.allowed.has(scope)) {
+                    const total = (totals.get(scope) ?? 0) + bytes.length;
+                    if (total > limits.maxScopeBytes)
+                        throw new IndexedRefusal('too-large');
+                    totals.set(scope, total);
+                    const ranges = index.get(scope) ?? [];
+                    ranges.push({ offset: lineStart, bytes: bytes.length, digest: digest(bytes) });
+                    index.set(scope, ranges);
+                }
+            }
+            lineStart += bytes.length;
+            pieces = [];
+            lineBytes = 0;
+            start = end + 1;
+        }
+        append(chunk.subarray(start));
+    }
+    if (lineBytes)
+        throw new IndexedRefusal('invalid-data'); // a torn tail never becomes an absent event
+    assertIdentity(fd, identity.key);
+    checkSignal(signal);
+    return index;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"indexedScan.js","sourceRoot":"","sources":["../../../../src/lib/sinks/indexedScan.ts"],"names":[],"mappings":"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","sourcesContent":["import { ownData } from '../capture/noteShape.js';\nimport { checkSignal, indexedAddress, IndexedRefusal } from './indexedAdmission.js';\nimport { assertIdentity, digest, readBytes } from './indexedIO.js';\nimport type { IndexedLimits, IndexedRange } from './indexedTypes.js';\n\n/** One whole-file preparation pass. Only authorized range metadata is retained, never the archive's values. */\nexport async function scanIndexedFile(\n  fd: number,\n  identity: { readonly key: string; readonly size: number },\n  limits: IndexedLimits,\n  signal: AbortSignal,\n  count: (bytes: number) => void,\n): Promise<Map<string, readonly IndexedRange[]>> {\n  if (identity.size > limits.maxBytes) throw new IndexedRefusal('too-large');\n  const index = new Map<string, IndexedRange[]>();\n  const totals = new Map<string, number>();\n  let entries = 0;\n  let lineStart = 0;\n  let pieces: Uint8Array[] = [];\n  let lineBytes = 0;\n  const append = (piece: Uint8Array) => {\n    lineBytes += piece.length;\n    if (lineBytes > limits.maxEntryBytes) throw new IndexedRefusal('too-large');\n    if (piece.length) pieces.push(piece);\n  };\n  const decoder = new TextDecoder('utf-8', { fatal: true });\n  for (let position = 0; position < identity.size; ) {\n    checkSignal(signal);\n    const chunk = await readBytes(fd, position, Math.min(65536, identity.size - position), signal, count);\n    position += chunk.length;\n    let start = 0;\n    for (let end = 0; end < chunk.length; end++) {\n      if (chunk[end] !== 10) continue;\n      append(chunk.subarray(start, end + 1));\n      // Assemble once at the delimiter, rather than repeatedly copying a growing partial line.\n      const bytes = new Uint8Array(lineBytes);\n      let filled = 0;\n      for (const piece of pieces) {\n        bytes.set(piece, filled);\n        filled += piece.length;\n      }\n      const text = decoder.decode(bytes);\n      if (text.trim()) {\n        if (++entries > limits.maxEntries) throw new IndexedRefusal('too-large');\n        let row: unknown;\n        try {\n          row = JSON.parse(text);\n        } catch {\n          throw new IndexedRefusal('invalid-data');\n        }\n        const scope = indexedAddress(ownData(row, 'address'));\n        if (limits.allowed.has(scope)) {\n          const total = (totals.get(scope) ?? 0) + bytes.length;\n          if (total > limits.maxScopeBytes) throw new IndexedRefusal('too-large');\n          totals.set(scope, total);\n          const ranges = index.get(scope) ?? [];\n          ranges.push({ offset: lineStart, bytes: bytes.length, digest: digest(bytes) });\n          index.set(scope, ranges);\n        }\n      }\n      lineStart += bytes.length;\n      pieces = [];\n      lineBytes = 0;\n      start = end + 1;\n    }\n    append(chunk.subarray(start));\n  }\n  if (lineBytes) throw new IndexedRefusal('invalid-data'); // a torn tail never becomes an absent event\n  assertIdentity(fd, identity.key);\n  checkSignal(signal);\n  return index;\n}\n"]}

package/dist/esm/lib/sinks/indexedTypes.d.ts

@@ -0,0 +1,60 @@
+import type { LogAddress } from 'foottrace';
+/** Host authorization is fixed before any stored entry is read. It is never inferred from the index. */
+export interface IndexedRecordFileOptions {
+    readonly allowedScopes: readonly LogAddress[];
+    /** Preparation scans at most this many file bytes. Default 64 MiB, maximum 256 MiB. */
+    readonly maxBytes?: number;
+    /** Maximum encoded JSON line. Default 8 MiB, maximum 8 MiB. */
+    readonly maxEntryBytes?: number;
+    /** Maximum entries indexed across the file. Default 16,384, maximum 65,536. */
+    readonly maxEntries?: number;
+    /** Maximum bytes read by one selected-scope request. Default 8 MiB, maximum 64 MiB. */
+    readonly maxScopeBytes?: number;
+    /** Bounds each preparation/read wait; unfinished filesystem work retains its slot. Default 10s, maximum 30s. */
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
+export type IndexedRecordFileReason = 'cancelled' | 'timeout' | 'unavailable' | 'invalid-data' | 'too-large' | 'not-permitted' | 'no-match' | 'stale' | 'busy' | 'closed';
+export interface IndexedRecordUnknown {
+    readonly status: 'unknown';
+    readonly reason: IndexedRecordFileReason;
+}
+export interface IndexedRecordScope {
+    readonly status: 'loaded';
+    /** Raw untrusted entries for public readStoredRecord/readStoredCapture; loading grants no completeness. */
+    readonly entries: readonly unknown[];
+    readonly bytesRead: number;
+}
+/** One immutable-file selection capability. No path, descriptor, mutable index or discovered run catalog is served. */
+export interface IndexedRecordFile {
+    /** Returned-byte counters and actual scope-read submissions (including failed and pending requests). */
+    readonly stats: {
+        readonly preparationBytes: number;
+        readonly scopeBytes: number;
+        readonly readCalls: number;
+    };
+    readScope(address: LogAddress, context?: {
+        readonly signal?: AbortSignal;
+    }): Promise<IndexedRecordScope | IndexedRecordUnknown>;
+    /** Stop new work immediately, release the descriptor after in-flight work settles. Idempotent. */
+    close(): Promise<void>;
+}
+export type IndexedRecordFileResult = {
+    readonly status: 'ready';
+    readonly reader: IndexedRecordFile;
+} | IndexedRecordUnknown;
+/** @internal Only the preparation pass produces ranges; they never cross the public boundary. */
+export interface IndexedRange {
+    readonly offset: number;
+    readonly bytes: number;
+    readonly digest: string;
+}
+export interface IndexedLimits {
+    readonly allowed: ReadonlySet<string>;
+    readonly maxBytes: number;
+    readonly maxEntryBytes: number;
+    readonly maxEntries: number;
+    readonly maxScopeBytes: number;
+    readonly timeoutMs: number;
+    readonly signal?: AbortSignal;
+}