@fgv/ts-agent-memory 5.1.0-46 → 5.1.0-48

package/lib/packlets/observe/memoryObservationStore.js

@@ -116,6 +116,12 @@ class MemoryObservationStore {
         if (criteria.outcome !== undefined && record.outcome !== criteria.outcome) {
             return false;
         }
+        // A record carrying no embed outcome never matches an `embed` criterion —
+        // "the question did not apply here" is not the same answer as any of the
+        // four, and matching it would put unwired writes in a coverage-gap report.
+        if (criteria.embed !== undefined && record.embed !== criteria.embed) {
+            return false;
+        }
         return true;
     }
 }

package/lib/packlets/observe/memoryObservationStore.js.map

@@ -1 +1 @@
-{"version":3,"file":"memoryObservationStore.js","sourceRoot":"","sources":["../../../src/packlets/observe/memoryObservationStore.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2026 Erik Fortune\n * SPDX-License-Identifier: MIT\n */\n\nimport { Collections, Result, fail, succeed } from '@fgv/ts-utils';\nimport { IMemoryObservationQuery, IMemoryObservationRecord, IMemoryObserver } from './observer';\n\n/**\n * Construction options for {@link MemoryObservationStore.create}.\n * @public\n */\nexport interface IMemoryObservationStoreCreateParams {\n  /**\n   * Maximum number of observation records retained before the oldest is\n   * overwritten. Defaults to `1000`. Must be a positive integer if supplied.\n   */\n  readonly maxRecords?: number;\n}\n\n/**\n * The default in-memory observation store: an {@link IMemoryObserver} that\n * retains the records it observes in a bounded ring and answers schema-aware\n * {@link MemoryObservationStore.query | queries} over them.\n *\n * @remarks\n * **Privacy posture — this store is most-permissive by design.** It retains\n * every field of every record verbatim, including any `provenance` and\n * `querySnapshot`. The library bakes in **no** redaction, retention, or\n * field-stripping policy — that is deployment policy, not library policy. A\n * deployment that must redact wraps this store with its own\n * {@link IMemoryObserver} that transforms records before forwarding, or\n * substitutes a different observer entirely. Size is the only bounded\n * dimension, via `maxRecords`.\n *\n * The store composes `RetainingRingBuffer` from `@fgv/ts-utils` (it does not\n * hand-roll a ring) and implements {@link IMemoryObserver} directly — `observe`\n * (the hook) and `query` (the read surface) live on the same class. Wire it via\n * {@link IFileTreeMemoryStoreCreateParams.observers}. `seq` and `timestamp` are\n * assigned by the firing authority (the store) before `observe`, so this store\n * never mints them.\n * @public\n */\nexport class MemoryObservationStore implements IMemoryObserver {\n  /**\n   * The bounded ring of observed records. The firing authority assigns each\n   * record's `seq`, so the ring's monotonic-`seq` cursor contract is satisfied\n   * by that authority's per-instance counter.\n   * @internal\n   */\n  private readonly _buffer: Collections.RetainingRingBuffer<IMemoryObservationRecord>;\n\n  /**\n   * @param buffer - The pre-constructed backing ring buffer.\n   * @internal\n   */\n  private constructor(buffer: Collections.RetainingRingBuffer<IMemoryObservationRecord>) {\n    this._buffer = buffer;\n  }\n\n  /**\n   * The highest `seq` observed so far. Hold this value and pass it as\n   * `sinceSeq` to {@link MemoryObservationStore.query | query} to page only\n   * records observed afterward. Stable across ring eviction and\n   * {@link MemoryObservationStore.clear | clear}.\n   */\n  public get lastSeq(): number {\n    return this._buffer.lastSeq;\n  }\n\n  /**\n   * The number of records currently retained.\n   */\n  public get size(): number {\n    return this._buffer.size;\n  }\n\n  /**\n   * Family-convention factory.\n   * @param params - {@link IMemoryObservationStoreCreateParams | Construction options}.\n   * @returns On success, a new store. Fails if `maxRecords` is supplied and is\n   * not a positive integer.\n   */\n  public static create(params?: IMemoryObservationStoreCreateParams): Result<MemoryObservationStore> {\n    const maxRecords: number | undefined = params?.maxRecords;\n    if (maxRecords !== undefined && (!Number.isInteger(maxRecords) || maxRecords < 1)) {\n      return fail(`MemoryObservationStore: maxRecords must be a positive integer (got ${maxRecords})`);\n    }\n    return succeed(\n      new MemoryObservationStore(\n        new Collections.RetainingRingBuffer<IMemoryObservationRecord>({ maxRecords })\n      )\n    );\n  }\n\n  /**\n   * {@inheritDoc IMemoryObserver.observe}\n   */\n  public observe(record: IMemoryObservationRecord): Promise<Result<unknown>> {\n    this._buffer.push(record);\n    return Promise.resolve(succeed(record));\n  }\n\n  /**\n   * Returns retained records, oldest-first, narrowed by the supplied criteria.\n   * @param criteria - {@link IMemoryObservationQuery | AND-combined filter criteria}.\n   * @returns The matching records, oldest-first.\n   */\n  public query(criteria?: IMemoryObservationQuery): ReadonlyArray<IMemoryObservationRecord> {\n    return this._buffer.query({\n      sinceSeq: criteria?.sinceSeq,\n      limit: criteria?.limit,\n      filter:\n        criteria === undefined ? undefined : (record) => MemoryObservationStore._matches(record, criteria)\n    });\n  }\n\n  /**\n   * Clears all retained records. Does NOT reset\n   * {@link MemoryObservationStore.lastSeq | lastSeq}, so a held `sinceSeq`\n   * cursor never re-sees a sequence number.\n   */\n  public clear(): void {\n    this._buffer.clear();\n  }\n\n  /**\n   * Tests a record against the non-`seq`/`limit` criteria (those are applied by\n   * the ring buffer itself).\n   * @internal\n   */\n  private static _matches(record: IMemoryObservationRecord, criteria: IMemoryObservationQuery): boolean {\n    if (criteria.since !== undefined && record.timestamp < criteria.since) {\n      return false;\n    }\n    if (criteria.until !== undefined && record.timestamp > criteria.until) {\n      return false;\n    }\n    if (criteria.scope !== undefined && record.scope !== criteria.scope) {\n      return false;\n    }\n    if (criteria.kind !== undefined && record.kind !== criteria.kind) {\n      return false;\n    }\n    if (criteria.phase !== undefined && record.phase !== criteria.phase) {\n      return false;\n    }\n    if (criteria.outcome !== undefined && record.outcome !== criteria.outcome) {\n      return false;\n    }\n    return true;\n  }\n}\n"]}
+{"version":3,"file":"memoryObservationStore.js","sourceRoot":"","sources":["../../../src/packlets/observe/memoryObservationStore.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2026 Erik Fortune\n * SPDX-License-Identifier: MIT\n */\n\nimport { Collections, Result, fail, succeed } from '@fgv/ts-utils';\nimport { IMemoryObservationQuery, IMemoryObservationRecord, IMemoryObserver } from './observer';\n\n/**\n * Construction options for {@link MemoryObservationStore.create}.\n * @public\n */\nexport interface IMemoryObservationStoreCreateParams {\n  /**\n   * Maximum number of observation records retained before the oldest is\n   * overwritten. Defaults to `1000`. Must be a positive integer if supplied.\n   */\n  readonly maxRecords?: number;\n}\n\n/**\n * The default in-memory observation store: an {@link IMemoryObserver} that\n * retains the records it observes in a bounded ring and answers schema-aware\n * {@link MemoryObservationStore.query | queries} over them.\n *\n * @remarks\n * **Privacy posture — this store is most-permissive by design.** It retains\n * every field of every record verbatim, including any `provenance` and\n * `querySnapshot`. The library bakes in **no** redaction, retention, or\n * field-stripping policy — that is deployment policy, not library policy. A\n * deployment that must redact wraps this store with its own\n * {@link IMemoryObserver} that transforms records before forwarding, or\n * substitutes a different observer entirely. Size is the only bounded\n * dimension, via `maxRecords`.\n *\n * The store composes `RetainingRingBuffer` from `@fgv/ts-utils` (it does not\n * hand-roll a ring) and implements {@link IMemoryObserver} directly — `observe`\n * (the hook) and `query` (the read surface) live on the same class. Wire it via\n * {@link IFileTreeMemoryStoreCreateParams.observers}. `seq` and `timestamp` are\n * assigned by the firing authority (the store) before `observe`, so this store\n * never mints them.\n * @public\n */\nexport class MemoryObservationStore implements IMemoryObserver {\n  /**\n   * The bounded ring of observed records. The firing authority assigns each\n   * record's `seq`, so the ring's monotonic-`seq` cursor contract is satisfied\n   * by that authority's per-instance counter.\n   * @internal\n   */\n  private readonly _buffer: Collections.RetainingRingBuffer<IMemoryObservationRecord>;\n\n  /**\n   * @param buffer - The pre-constructed backing ring buffer.\n   * @internal\n   */\n  private constructor(buffer: Collections.RetainingRingBuffer<IMemoryObservationRecord>) {\n    this._buffer = buffer;\n  }\n\n  /**\n   * The highest `seq` observed so far. Hold this value and pass it as\n   * `sinceSeq` to {@link MemoryObservationStore.query | query} to page only\n   * records observed afterward. Stable across ring eviction and\n   * {@link MemoryObservationStore.clear | clear}.\n   */\n  public get lastSeq(): number {\n    return this._buffer.lastSeq;\n  }\n\n  /**\n   * The number of records currently retained.\n   */\n  public get size(): number {\n    return this._buffer.size;\n  }\n\n  /**\n   * Family-convention factory.\n   * @param params - {@link IMemoryObservationStoreCreateParams | Construction options}.\n   * @returns On success, a new store. Fails if `maxRecords` is supplied and is\n   * not a positive integer.\n   */\n  public static create(params?: IMemoryObservationStoreCreateParams): Result<MemoryObservationStore> {\n    const maxRecords: number | undefined = params?.maxRecords;\n    if (maxRecords !== undefined && (!Number.isInteger(maxRecords) || maxRecords < 1)) {\n      return fail(`MemoryObservationStore: maxRecords must be a positive integer (got ${maxRecords})`);\n    }\n    return succeed(\n      new MemoryObservationStore(\n        new Collections.RetainingRingBuffer<IMemoryObservationRecord>({ maxRecords })\n      )\n    );\n  }\n\n  /**\n   * {@inheritDoc IMemoryObserver.observe}\n   */\n  public observe(record: IMemoryObservationRecord): Promise<Result<unknown>> {\n    this._buffer.push(record);\n    return Promise.resolve(succeed(record));\n  }\n\n  /**\n   * Returns retained records, oldest-first, narrowed by the supplied criteria.\n   * @param criteria - {@link IMemoryObservationQuery | AND-combined filter criteria}.\n   * @returns The matching records, oldest-first.\n   */\n  public query(criteria?: IMemoryObservationQuery): ReadonlyArray<IMemoryObservationRecord> {\n    return this._buffer.query({\n      sinceSeq: criteria?.sinceSeq,\n      limit: criteria?.limit,\n      filter:\n        criteria === undefined ? undefined : (record) => MemoryObservationStore._matches(record, criteria)\n    });\n  }\n\n  /**\n   * Clears all retained records. Does NOT reset\n   * {@link MemoryObservationStore.lastSeq | lastSeq}, so a held `sinceSeq`\n   * cursor never re-sees a sequence number.\n   */\n  public clear(): void {\n    this._buffer.clear();\n  }\n\n  /**\n   * Tests a record against the non-`seq`/`limit` criteria (those are applied by\n   * the ring buffer itself).\n   * @internal\n   */\n  private static _matches(record: IMemoryObservationRecord, criteria: IMemoryObservationQuery): boolean {\n    if (criteria.since !== undefined && record.timestamp < criteria.since) {\n      return false;\n    }\n    if (criteria.until !== undefined && record.timestamp > criteria.until) {\n      return false;\n    }\n    if (criteria.scope !== undefined && record.scope !== criteria.scope) {\n      return false;\n    }\n    if (criteria.kind !== undefined && record.kind !== criteria.kind) {\n      return false;\n    }\n    if (criteria.phase !== undefined && record.phase !== criteria.phase) {\n      return false;\n    }\n    if (criteria.outcome !== undefined && record.outcome !== criteria.outcome) {\n      return false;\n    }\n    // A record carrying no embed outcome never matches an `embed` criterion —\n    // \"the question did not apply here\" is not the same answer as any of the\n    // four, and matching it would put unwired writes in a coverage-gap report.\n    if (criteria.embed !== undefined && record.embed !== criteria.embed) {\n      return false;\n    }\n    return true;\n  }\n}\n"]}

package/lib/packlets/observe/observer.d.ts

@@ -18,6 +18,55 @@ export type MemoryObservationPhase = 'read' | 'write' | 'delete' | 'retrieve';
  * @public
  */
 export type MemoryObservationOutcome = 'success' | 'failure';
+/**
+ * What the record-granular vector index did about a written record.
+ *
+ * @remarks
+ * This exists because **`embeddingRef` absence is three-ways ambiguous**: a
+ * record with no reference may have been declined, excluded, or genuinely
+ * failed to embed, and the `put`'s own `outcome` cannot tell you which — it is
+ * `'success'` in all three, because embed-on-write is best-effort by design and
+ * never fails a durable write. Deriving index coverage from the absent field
+ * alone therefore cannot distinguish a policy decision from an outage.
+ *
+ * - `'embedded'` — embedded and added; the record carries an `embeddingRef`.
+ * - `'declined'` — the {@link MemoryEmbedder} resolved `undefined`: deliberately
+ *   not embedded. Not a fault.
+ * - `'excluded'` — the record's kind is outside the store's `embedKinds`
+ *   declaration, so the embedder was never called. Also not a fault, and the
+ *   cheaper of the two.
+ * - `'failed'` — the embedder returned a `Failure` (or threw), **or** the index
+ *   `add` did. Both are faults, and what they leave behind depends on whether
+ *   the record had been embedded before: a **first** write ends up with no
+ *   `embeddingRef` and nothing in the index, while an **update** keeps the
+ *   reference and vector it already had — so the index goes on answering on the
+ *   record's **previous** content until a `rebuild` reconciles it. Stale, not
+ *   absent. The store's diagnostic logger names which fault it was, because the
+ *   remediation differs (an embedder outage versus an index outage) while the
+ *   coverage answer — "this record needs a re-embed" — does not.
+ *
+ * Absent on a write observation means **no outcome is being reported**, which
+ * covers three cases:
+ *
+ * 1. no vector index / embedder is wired, so there is no index for the record to
+ *    be absent from;
+ * 2. the `put` was a dedup no-op, which attempted nothing;
+ * 3. the `put` **failed** (`outcome: 'failure'`). An embed step may well have run
+ *    before the failure — a record can even have been added to the index and then
+ *    lost its durable write, leaving an orphan vector that a later `rebuild`
+ *    reconciles. That is deliberately not reported here: the field answers
+ *    "is this *stored* record in the index?", and on a failed write there is no
+ *    stored record for it to be a statement about.
+ *
+ * So `embed` is a property of successful writes. Never present on `'read'` /
+ * `'delete'` / `'retrieve'`.
+ *
+ * Record-granular only. The fragment path is independent and reports nothing
+ * here — a record may be fragment-embedded while its record-level outcome is
+ * `'excluded'`.
+ * @public
+ */
+export type MemoryEmbedOutcome = 'embedded' | 'declined' | 'excluded' | 'failed';
 /**
  * A single audit record produced by an observed store (or retriever) operation.
  *
@@ -51,6 +100,12 @@ export interface IMemoryObservationRecord {
     readonly error?: string;
     /** Structured provenance of the write, when the operation carried one. */
     readonly provenance?: IProvenance;
+    /**
+     * For `'write'` observations: what the record-granular vector index did about
+     * this record. Absent when the question does not apply — see
+     * {@link MemoryEmbedOutcome}.
+     */
+    readonly embed?: MemoryEmbedOutcome;
     /**
      * For `'retrieve'` observations: an opaque snapshot of the query that drove
      * the retrieval. Carried verbatim; never interpreted by the store.
@@ -106,5 +161,11 @@ export interface IMemoryObservationQuery {
     readonly phase?: MemoryObservationPhase;
     /** Only records with this outcome. */
     readonly outcome?: MemoryObservationOutcome;
+    /**
+     * Only `'write'` records with this embed outcome. Records carrying no embed
+     * outcome never match, so `embed: 'failed'` answers "which writes left the
+     * index short?" without a full scan of every record's `embeddingRef`.
+     */
+    readonly embed?: MemoryEmbedOutcome;
 }
 //# sourceMappingURL=observer.d.ts.map

package/lib/packlets/observe/observer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"observer.d.ts","sourceRoot":"","sources":["../../../src/packlets/observe/observer.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAEvE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE9E;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG,SAAS,GAAG,SAAS,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,6CAA6C;IAC7C,QAAQ,CAAC,KAAK,EAAE,sBAAsB,CAAC;IACvC,wDAAwD;IACxD,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;IAChC,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC;IACvB,mDAAmD;IACnD,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC;IACrB,uCAAuC;IACvC,QAAQ,CAAC,OAAO,EAAE,wBAAwB,CAAC;IAC3C,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,UAAU,CAAC,EAAE,WAAW,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC5D;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC;;;;;OAKG;IACH,OAAO,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;CACrE;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,4CAA4C;IAC5C,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;IAChC,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC;IACrB,kCAAkC;IAClC,QAAQ,CAAC,KAAK,CAAC,EAAE,sBAAsB,CAAC;IACxC,sCAAsC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,wBAAwB,CAAC;CAC7C"}
+{"version":3,"file":"observer.d.ts","sourceRoot":"","sources":["../../../src/packlets/observe/observer.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAEvE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE9E;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG,SAAS,GAAG,SAAS,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,QAAQ,CAAC;AAEjF;;;;;;;;;;GAUG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,6CAA6C;IAC7C,QAAQ,CAAC,KAAK,EAAE,sBAAsB,CAAC;IACvC,wDAAwD;IACxD,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;IAChC,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC;IACvB,mDAAmD;IACnD,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC;IACrB,uCAAuC;IACvC,QAAQ,CAAC,OAAO,EAAE,wBAAwB,CAAC;IAC3C,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,UAAU,CAAC,EAAE,WAAW,CAAC;IAClC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,kBAAkB,CAAC;IACpC;;;OAGG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC5D;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC;;;;;OAKG;IACH,OAAO,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;CACrE;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,4CAA4C;IAC5C,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;IAChC,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC;IACrB,kCAAkC;IAClC,QAAQ,CAAC,KAAK,CAAC,EAAE,sBAAsB,CAAC;IACxC,sCAAsC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,wBAAwB,CAAC;IAC5C;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,kBAAkB,CAAC;CACrC"}

package/lib/packlets/observe/observer.js.map

@@ -1 +1 @@
-{"version":3,"file":"observer.js","sourceRoot":"","sources":["../../../src/packlets/observe/observer.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*\n * Copyright (c) 2026 Erik Fortune\n * SPDX-License-Identifier: MIT\n */\n\nimport { Result } from '@fgv/ts-utils';\nimport { IProvenance, Kind, MemoryId, MemoryScopeKey } from '../types';\n\n/**\n * The store/retriever operation an observation record describes.\n *\n * @remarks\n * `'read'` / `'write'` / `'delete'` are fired post-op by\n * {@link FileTreeMemoryStore} (on `get` / `put` / `delete` respectively) when\n * observers are wired. `'retrieve'` is reserved for retriever-fired\n * observations; no B2 retriever fires one (a single seq authority per\n * observation store is the supported topology), so it never appears in B2 but\n * is part of the vocabulary so a future retriever-firing hook is additive.\n * @public\n */\nexport type MemoryObservationPhase = 'read' | 'write' | 'delete' | 'retrieve';\n\n/**\n * The outcome of the observed operation.\n * @public\n */\nexport type MemoryObservationOutcome = 'success' | 'failure';\n\n/**\n * A single audit record produced by an observed store (or retriever) operation.\n *\n * @remarks\n * `seq` and `timestamp` are assigned by the firing authority (the store) before\n * fan-out, so the same record carries the same `seq` across every observer it\n * lands in. `seq` is strictly increasing per authority, satisfying the\n * `RetainingRingBuffer` cursor contract that {@link MemoryObservationStore}\n * relies on.\n * @public\n */\nexport interface IMemoryObservationRecord {\n  /**\n   * Monotonic 1-based sequence number assigned by the firing authority, stable\n   * across a store's ring eviction. The ordering / paging key.\n   */\n  readonly seq: number;\n  /** Milliseconds since epoch when the firing authority produced the record. */\n  readonly timestamp: number;\n  /** Which operation this record describes. */\n  readonly phase: MemoryObservationPhase;\n  /** The scope the operation touched, when resolvable. */\n  readonly scope?: MemoryScopeKey;\n  /** The record id the operation touched, when resolvable. */\n  readonly id?: MemoryId;\n  /** The kind the operation targeted, when known. */\n  readonly kind?: Kind;\n  /** Whether the operation succeeded. */\n  readonly outcome: MemoryObservationOutcome;\n  /** Present on failure: the failure `Result`'s message. */\n  readonly error?: string;\n  /** Structured provenance of the write, when the operation carried one. */\n  readonly provenance?: IProvenance;\n  /**\n   * For `'retrieve'` observations: an opaque snapshot of the query that drove\n   * the retrieval. Carried verbatim; never interpreted by the store.\n   */\n  readonly querySnapshot?: Readonly<Record<string, unknown>>;\n}\n\n/**\n * Single-method async observer hook. The store fires `observe` once per public\n * `get` / `put` / `delete` call when observers are wired.\n *\n * @remarks\n * Observer errors never affect the store operation — the store swallows a\n * failed `Result` or a thrown / rejected `observe`, logging it to the injected\n * diagnostic logger at `warn`.\n * @public\n */\nexport interface IMemoryObserver {\n  /**\n   * When `true`, the store dispatches `observe` without awaiting it, so a slow\n   * remote observer (SIEM, network sink) does not extend the store operation's\n   * latency. Defaults to `false` (awaited), which is correct for the cheap\n   * in-memory default {@link MemoryObservationStore}. Errors are swallowed\n   * either way.\n   */\n  readonly fireAndForget?: boolean;\n  /**\n   * Receives a fully-formed observation record.\n   * @param record - The observation record.\n   * @returns A `Result` whose failure is swallowed (logged to the store's\n   * diagnostic logger). A rejected promise is likewise swallowed.\n   */\n  observe(record: IMemoryObservationRecord): Promise<Result<unknown>>;\n}\n\n/**\n * Query criteria for {@link MemoryObservationStore.query}. All supplied criteria\n * are AND-combined.\n * @public\n */\nexport interface IMemoryObservationQuery {\n  /** Only records with `seq > sinceSeq` (incremental paging cursor). */\n  readonly sinceSeq?: number;\n  /** Return at most this many records — the most-recent N, still oldest-first. */\n  readonly limit?: number;\n  /** Only records with `timestamp >= since`. */\n  readonly since?: number;\n  /** Only records with `timestamp <= until`. */\n  readonly until?: number;\n  /** Only records that touched this scope. */\n  readonly scope?: MemoryScopeKey;\n  /** Only records that targeted this kind. */\n  readonly kind?: Kind;\n  /** Only records of this phase. */\n  readonly phase?: MemoryObservationPhase;\n  /** Only records with this outcome. */\n  readonly outcome?: MemoryObservationOutcome;\n}\n"]}
+{"version":3,"file":"observer.js","sourceRoot":"","sources":["../../../src/packlets/observe/observer.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*\n * Copyright (c) 2026 Erik Fortune\n * SPDX-License-Identifier: MIT\n */\n\nimport { Result } from '@fgv/ts-utils';\nimport { IProvenance, Kind, MemoryId, MemoryScopeKey } from '../types';\n\n/**\n * The store/retriever operation an observation record describes.\n *\n * @remarks\n * `'read'` / `'write'` / `'delete'` are fired post-op by\n * {@link FileTreeMemoryStore} (on `get` / `put` / `delete` respectively) when\n * observers are wired. `'retrieve'` is reserved for retriever-fired\n * observations; no B2 retriever fires one (a single seq authority per\n * observation store is the supported topology), so it never appears in B2 but\n * is part of the vocabulary so a future retriever-firing hook is additive.\n * @public\n */\nexport type MemoryObservationPhase = 'read' | 'write' | 'delete' | 'retrieve';\n\n/**\n * The outcome of the observed operation.\n * @public\n */\nexport type MemoryObservationOutcome = 'success' | 'failure';\n\n/**\n * What the record-granular vector index did about a written record.\n *\n * @remarks\n * This exists because **`embeddingRef` absence is three-ways ambiguous**: a\n * record with no reference may have been declined, excluded, or genuinely\n * failed to embed, and the `put`'s own `outcome` cannot tell you which — it is\n * `'success'` in all three, because embed-on-write is best-effort by design and\n * never fails a durable write. Deriving index coverage from the absent field\n * alone therefore cannot distinguish a policy decision from an outage.\n *\n * - `'embedded'` — embedded and added; the record carries an `embeddingRef`.\n * - `'declined'` — the {@link MemoryEmbedder} resolved `undefined`: deliberately\n *   not embedded. Not a fault.\n * - `'excluded'` — the record's kind is outside the store's `embedKinds`\n *   declaration, so the embedder was never called. Also not a fault, and the\n *   cheaper of the two.\n * - `'failed'` — the embedder returned a `Failure` (or threw), **or** the index\n *   `add` did. Both are faults, and what they leave behind depends on whether\n *   the record had been embedded before: a **first** write ends up with no\n *   `embeddingRef` and nothing in the index, while an **update** keeps the\n *   reference and vector it already had — so the index goes on answering on the\n *   record's **previous** content until a `rebuild` reconciles it. Stale, not\n *   absent. The store's diagnostic logger names which fault it was, because the\n *   remediation differs (an embedder outage versus an index outage) while the\n *   coverage answer — \"this record needs a re-embed\" — does not.\n *\n * Absent on a write observation means **no outcome is being reported**, which\n * covers three cases:\n *\n * 1. no vector index / embedder is wired, so there is no index for the record to\n *    be absent from;\n * 2. the `put` was a dedup no-op, which attempted nothing;\n * 3. the `put` **failed** (`outcome: 'failure'`). An embed step may well have run\n *    before the failure — a record can even have been added to the index and then\n *    lost its durable write, leaving an orphan vector that a later `rebuild`\n *    reconciles. That is deliberately not reported here: the field answers\n *    \"is this *stored* record in the index?\", and on a failed write there is no\n *    stored record for it to be a statement about.\n *\n * So `embed` is a property of successful writes. Never present on `'read'` /\n * `'delete'` / `'retrieve'`.\n *\n * Record-granular only. The fragment path is independent and reports nothing\n * here — a record may be fragment-embedded while its record-level outcome is\n * `'excluded'`.\n * @public\n */\nexport type MemoryEmbedOutcome = 'embedded' | 'declined' | 'excluded' | 'failed';\n\n/**\n * A single audit record produced by an observed store (or retriever) operation.\n *\n * @remarks\n * `seq` and `timestamp` are assigned by the firing authority (the store) before\n * fan-out, so the same record carries the same `seq` across every observer it\n * lands in. `seq` is strictly increasing per authority, satisfying the\n * `RetainingRingBuffer` cursor contract that {@link MemoryObservationStore}\n * relies on.\n * @public\n */\nexport interface IMemoryObservationRecord {\n  /**\n   * Monotonic 1-based sequence number assigned by the firing authority, stable\n   * across a store's ring eviction. The ordering / paging key.\n   */\n  readonly seq: number;\n  /** Milliseconds since epoch when the firing authority produced the record. */\n  readonly timestamp: number;\n  /** Which operation this record describes. */\n  readonly phase: MemoryObservationPhase;\n  /** The scope the operation touched, when resolvable. */\n  readonly scope?: MemoryScopeKey;\n  /** The record id the operation touched, when resolvable. */\n  readonly id?: MemoryId;\n  /** The kind the operation targeted, when known. */\n  readonly kind?: Kind;\n  /** Whether the operation succeeded. */\n  readonly outcome: MemoryObservationOutcome;\n  /** Present on failure: the failure `Result`'s message. */\n  readonly error?: string;\n  /** Structured provenance of the write, when the operation carried one. */\n  readonly provenance?: IProvenance;\n  /**\n   * For `'write'` observations: what the record-granular vector index did about\n   * this record. Absent when the question does not apply — see\n   * {@link MemoryEmbedOutcome}.\n   */\n  readonly embed?: MemoryEmbedOutcome;\n  /**\n   * For `'retrieve'` observations: an opaque snapshot of the query that drove\n   * the retrieval. Carried verbatim; never interpreted by the store.\n   */\n  readonly querySnapshot?: Readonly<Record<string, unknown>>;\n}\n\n/**\n * Single-method async observer hook. The store fires `observe` once per public\n * `get` / `put` / `delete` call when observers are wired.\n *\n * @remarks\n * Observer errors never affect the store operation — the store swallows a\n * failed `Result` or a thrown / rejected `observe`, logging it to the injected\n * diagnostic logger at `warn`.\n * @public\n */\nexport interface IMemoryObserver {\n  /**\n   * When `true`, the store dispatches `observe` without awaiting it, so a slow\n   * remote observer (SIEM, network sink) does not extend the store operation's\n   * latency. Defaults to `false` (awaited), which is correct for the cheap\n   * in-memory default {@link MemoryObservationStore}. Errors are swallowed\n   * either way.\n   */\n  readonly fireAndForget?: boolean;\n  /**\n   * Receives a fully-formed observation record.\n   * @param record - The observation record.\n   * @returns A `Result` whose failure is swallowed (logged to the store's\n   * diagnostic logger). A rejected promise is likewise swallowed.\n   */\n  observe(record: IMemoryObservationRecord): Promise<Result<unknown>>;\n}\n\n/**\n * Query criteria for {@link MemoryObservationStore.query}. All supplied criteria\n * are AND-combined.\n * @public\n */\nexport interface IMemoryObservationQuery {\n  /** Only records with `seq > sinceSeq` (incremental paging cursor). */\n  readonly sinceSeq?: number;\n  /** Return at most this many records — the most-recent N, still oldest-first. */\n  readonly limit?: number;\n  /** Only records with `timestamp >= since`. */\n  readonly since?: number;\n  /** Only records with `timestamp <= until`. */\n  readonly until?: number;\n  /** Only records that touched this scope. */\n  readonly scope?: MemoryScopeKey;\n  /** Only records that targeted this kind. */\n  readonly kind?: Kind;\n  /** Only records of this phase. */\n  readonly phase?: MemoryObservationPhase;\n  /** Only records with this outcome. */\n  readonly outcome?: MemoryObservationOutcome;\n  /**\n   * Only `'write'` records with this embed outcome. Records carrying no embed\n   * outcome never match, so `embed: 'failed'` answers \"which writes left the\n   * index short?\" without a full scan of every record's `embeddingRef`.\n   */\n  readonly embed?: MemoryEmbedOutcome;\n}\n"]}

package/lib/packlets/store/fileTreeMemoryStore.d.ts

@@ -1,6 +1,6 @@
 import { Logging, Result } from '@fgv/ts-utils';
 import { FileTree } from '@fgv/ts-json-base';
-import { EntityId, IIdentityCodec, IMemoryRecord, IWritePolicy, Kind, MemoryId, MemoryScopeKey, RankProjector, Tag } from '../types';
+import { DedupScope, EntityId, IIdentityCodec, IMemoryRecord, IWritePolicy, Kind, MemoryId, MemoryScopeKey, RankProjector, Tag } from '../types';
 import { IBodyConverterRegistry as IRegistry } from '../converters';
 import { IMemoryIndex } from '../index';
 import { IMemoryObserver } from '../observe';
@@ -87,12 +87,67 @@ export interface IMemoryStore {
     /**
      * Adapt this store to the {@link IMemoryRecordSource} seam so it can drive
      * {@link IVectorIndex} rebuilds (e.g. `InMemoryCosineIndex.rebuild`). The
-     * returned source's `list()` delegates to {@link IMemoryStore.listScoped}. The
-     * store cannot implement {@link IMemoryRecordSource} directly because its
+     * returned source's `list()` delegates to {@link IMemoryStore.listScoped},
+     * **filtered to the kinds {@link IMemoryStore.embedsKind | embedsKind} reports** —
+     * this source exists to feed the record vector index, so a kind excluded from
+     * that index is excluded here too, and a reopen does not re-embed records the
+     * index will never return. With no
+     * {@link IFileTreeMemoryStoreCreateParams.embedKinds | embedKinds} declaration
+     * every kind participates and the filter is the identity. `listScoped` itself is
+     * **not** filtered and remains the whole-vault surface.
+     *
+     * The store cannot implement {@link IMemoryRecordSource} directly because its
      * `list(filter?)` returns bare records (the ergonomic query surface) while the
      * seam's `list()` returns scope-qualified records.
      */
     asRecordSource(): IMemoryRecordSource;
+    /**
+     * The EFFECTIVE {@link DedupScope} for `kind` — the granularity at which a
+     * write for this kind deduplicates against the existing vault.
+     *
+     * @remarks
+     * This is a **read accessor over the store's already-injected write policies**,
+     * and it is the single place any caller — the store's own write path included —
+     * asks what a kind's dedup granularity is. It resolves the full chain the store
+     * applies on write: the kind's registered {@link IWritePolicy}, falling back to
+     * the store's default policy, then that policy's
+     * {@link IWritePolicy.dedupScope | dedupScope}, falling back to
+     * {@link DEFAULT_DEDUP_SCOPE}. Note the store's default policy is a
+     * {@link KnowledgeLwwPolicy}, which declares `'content'` — so a kind with NO
+     * registered policy resolves to `'content'`, not to `DEFAULT_DEDUP_SCOPE`.
+     *
+     * It exists so a caller that must agree with the store about dedup granularity
+     * — notably the ingest orchestrator's stage-4 layer-1 exact match — can read the
+     * declaration through this seam instead of being handed a second copy of the
+     * policy map. A second declaration site is precisely the defect this accessor
+     * was added to remove.
+     *
+     * Deliberately synchronous, total, and NOT `Result`-returning: it reads
+     * constructor-injected configuration, touches no I/O, and cannot fail (every
+     * link in the fallback chain has a total default). It exposes only the scope,
+     * never the {@link IWritePolicy} itself, so it can never become a back door for
+     * invoking admission or merge logic out of band.
+     */
+    dedupScopeFor(kind: Kind): DedupScope;
+    /**
+     * Whether records of `kind` participate in the **record-granular** vector index.
+     *
+     * @remarks
+     * A read accessor over the store's injected {@link IFileTreeMemoryStoreCreateParams.embedKinds | embedKinds}
+     * declaration, in the same spirit as {@link IMemoryStore.dedupScopeFor} — one
+     * place to ask, so the store's write path and any caller reasoning about index
+     * coverage cannot disagree. `true` for every kind when no declaration was made.
+     *
+     * **This is distinct from a {@link MemoryEmbedder} decline, and the difference is
+     * cost.** An embedder that returns `undefined` has already been called: the
+     * round trip is paid, and on a locally-hosted model that round trip is the
+     * expense. A kind excluded here is never handed to the embedder at all. The
+     * decline makes the intent *expressible*; this makes it *free*.
+     *
+     * Deliberately synchronous, total, and NOT `Result`-returning: it reads
+     * constructor-injected configuration, touches no I/O, and cannot fail.
+     */
+    embedsKind(kind: Kind): boolean;
     /**
      * Write a record. Validates the body, computes a content hash, deduplicates
      * (scope-wide, before policy), applies the kind's {@link IWritePolicy}, stamps
@@ -136,6 +191,37 @@ export interface IFileTreeMemoryStoreCreateParams {
      * guard-host-callbacks conventions).
      */
     readonly rankProjectors?: ReadonlyMap<Kind, RankProjector>;
+    /**
+     * The kinds whose records participate in the **record-granular** vector index.
+     *
+     * @remarks
+     * **Absent means every kind participates**, which is the pre-existing behavior —
+     * so omitting this is byte-identical to before it existed. Supplying it makes the
+     * set an allowlist: a kind outside it is never handed to the {@link MemoryEmbedder}
+     * on write, and is omitted from {@link IMemoryStore.asRecordSource | asRecordSource},
+     * so a rebuild driven from this store does not pay for it either.
+     *
+     * Two costs motivate it, and the second is the one that is easy to miss:
+     *
+     * - **Embedder work on the critical path.** Embed-on-write is synchronous with
+     *   the write. A bookkeeping row — a status, a counter, a lease — that no query
+     *   will ever return still pays a full embedding round trip, and on a
+     *   locally-hosted model the first call after a restart pays a cold model load
+     *   on top.
+     * - **Un-queried kinds crowd the `topK` window.** `IVectorIndex.query` applies
+     *   `topK` *before* any kind filter the retriever adds, so vectors that can never
+     *   be returned still occupy candidate slots. Over-fetching to compensate hides
+     *   this until the un-queried kinds start scoring well — at which point recall is
+     *   silently lost. Restricting what is indexed fixes the recall problem, not just
+     *   the cost.
+     *
+     * Applies to the record-granular path only. The fragment path
+     * ({@link IFileTreeMemoryStoreCreateParams.fragmentIndex | fragmentIndex} /
+     * `fragmentEmbedder`) is independent and unaffected — a kind may legitimately be
+     * fragment-embedded and not record-embedded, which is the right shape for a long
+     * document whose whole body exceeds the model's context.
+     */
+    readonly embedKinds?: ReadonlySet<Kind>;
     /** Default codec for kinds without an explicit entry. */
     readonly defaultCodec?: IIdentityCodec;
     /**
@@ -290,6 +376,8 @@ export declare class FileTreeMemoryStore implements IMemoryStore {
     private readonly _writePolicies;
     private readonly _codecs;
     private readonly _rankProjectors;
+    /** `undefined` = no declaration = every kind participates. */
+    private readonly _embedKinds;
     private readonly _defaultCodec;
     private readonly _defaultPolicy;
     private readonly _scopeEncoding;
@@ -297,11 +385,9 @@ export declare class FileTreeMemoryStore implements IMemoryStore {
     private readonly _index;
     private readonly _hasher;
     private readonly _observers;
+    /** Record- and fragment-vector maintenance; every operation is best-effort. */
+    private readonly _vectors;
     private readonly _logger;
-    private readonly _vectorIndex;
-    private readonly _embed;
-    private readonly _fragmentIndex;
-    private readonly _fragmentEmbedder;
     /**
      * Records the initial walk could not load. Populated during `create()` in
      * {@link MemoryRecordErrorMode | `'skip'` mode}; empty otherwise.
@@ -418,39 +504,6 @@ export declare class FileTreeMemoryStore implements IMemoryStore {
      * later eviction failure never loses data with nothing written in its place.
      */
     private _admitWrite;
-    /**
-     * Best-effort embed-on-write. When a vector index AND an embedder are wired,
-     * embeds the built record, `add`s the vector (replace semantics handle a same-id
-     * re-embed — no explicit remove), and stamps the returned `embeddingRef`. A
-     * failure (returned `fail` OR a thrown/rejected hook) is logged and the
-     * unembedded record is returned unchanged — the put still persists, and the
-     * derived index is reconciled by a later `rebuild`. A pass-through no-op when
-     * unwired (byte-identical record).
-     *
-     * Always succeeds (`Result` is the chain's shape, never a vector-induced
-     * failure).
-     */
-    private _embedOnWrite;
-    /**
-     * Best-effort fragment-embed-on-write. When a fragment index AND a fragment
-     * embedder are wired, chunks + embeds the built record and replaces its
-     * fragments in the index (`addFragments` is whole-record-replace, so a re-authored
-     * document never leaves stale fragments behind — no explicit remove needed). A
-     * failure (returned `fail` OR a thrown/rejected hook) is logged and the record is
-     * returned unchanged — the put still persists, and the fragment index is a derived
-     * view a later `rebuild` reconciles. Unlike {@link FileTreeMemoryStore._embedOnWrite}
-     * it stamps nothing on the record (fragments have no per-record `embeddingRef`
-     * analog). A pass-through no-op when unwired (byte-identical record).
-     */
-    private _embedFragmentsOnWrite;
-    /**
-     * Best-effort fragment removal. A no-op unless the full fragment lifecycle is
-     * wired (both an index AND an embedder), so an unwired store does no fragment
-     * work and behaves byte-identically. Failures are logged, never surfaced — a
-     * committed delete/eviction must not fail because a derived fragment index could
-     * not be pruned.
-     */
-    private _removeFragmentsBestEffort;
     /**
      * Evict the records named by a `cull-oldest` decision, best-effort. Runs only
      * after the authoritative `_persist`, so a failed eviction is logged (never
@@ -459,26 +512,6 @@ export declare class FileTreeMemoryStore implements IMemoryStore {
      * `accept` / `reject` decisions evict nothing.
      */
     private _applyEvictions;
-    /**
-     * Best-effort vector removal for each evicted record (never fails the put).
-     * Every evicted record is in the same `scope` as the incoming write (the
-     * cull-oldest cohort is the incoming record's `(scope, kind)` cohort), so that
-     * scope qualifies each removal target.
-     */
-    private _removeEvictedVectors;
-    /**
-     * Run a consumer-supplied vector hook, normalizing a thrown/rejected hook into a
-     * `Failure` and logging any failure at `warn`. Best-effort: the caller proceeds
-     * regardless, since the index is rebuildable.
-     */
-    private _tryVectorOp;
-    /**
-     * Best-effort vector removal. A no-op unless the full vector lifecycle is wired
-     * (both an index AND an embedder), so an unwired store does no vector work and
-     * behaves byte-identically. Failures are logged, never surfaced — a committed
-     * delete/eviction must not fail because a derived index could not be pruned.
-     */
-    private _removeVectorBestEffort;
     /**
      * Build the record to persist. On a first write the incoming envelope is the
      * base (final content equals the incoming content, so the dedup `hash` is
@@ -610,6 +643,10 @@ export declare class FileTreeMemoryStore implements IMemoryStore {
     private _stampRank;
     private _codecFor;
     private _policyFor;
+    /** {@inheritDoc IMemoryStore.dedupScopeFor} */
+    dedupScopeFor(kind: Kind): DedupScope;
+    /** {@inheritDoc IMemoryStore.embedsKind} */
+    embedsKind(kind: Kind): boolean;
     /**
      * Read and validate the record at `<scope>/<idStem>.md`, returning `undefined`
      * when the scope directory or file is absent. Verifies the on-disk id ↔

package/lib/packlets/store/fileTreeMemoryStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fileTreeMemoryStore.d.ts","sourceRoot":"","sources":["../../../src/packlets/store/fileTreeMemoryStore.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"fileTreeMemoryStore.d.ts","sourceRoot":"","sources":["../../../src/packlets/store/fileTreeMemoryStore.ts"],"names":[],"mappings":"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"}