@fgv/ts-agent-memory 5.1.0-36

package/dist/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.58.7"
+    }
+  ]
+}

package/eslint.config.js

@@ -0,0 +1,15 @@
+// ESLint 9 flat config
+const nodeProfile = require('@rushstack/eslint-config/flat/profile/node');
+const packletsPlugin = require('@rushstack/eslint-config/flat/mixins/packlets');
+const tsdocPlugin = require('@rushstack/eslint-config/flat/mixins/tsdoc');
+
+module.exports = [
+  ...nodeProfile,
+  packletsPlugin,
+  ...tsdocPlugin,
+  {
+    rules: {
+      '@rushstack/packlets/mechanics': 'warn'
+    }
+  }
+];

package/etc/ts-agent-memory.api.md

@@ -0,0 +1,525 @@
+## API Report File for "@fgv/ts-agent-memory"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { Brand } from '@fgv/ts-utils';
+import { Converter } from '@fgv/ts-utils';
+import { FileTree } from '@fgv/ts-json-base';
+import { JsonSchema } from '@fgv/ts-json-base';
+import { Logging } from '@fgv/ts-utils';
+import { Result } from '@fgv/ts-utils';
+
+// @public
+export type AdmissionDecision = {
+    readonly decision: 'accept';
+} | {
+    readonly decision: 'reject';
+    readonly reason: string;
+} | {
+    readonly decision: 'cull-oldest';
+    readonly evict: ReadonlyArray<MemoryId>;
+};
+
+// @public
+export function assertPortableFilenameStem(stem: string): Result<string>;
+
+// @public
+export class BodyConverterRegistry implements IBodyConverterRegistry {
+    convert(kind: Kind, body: unknown): Result<unknown>;
+    static create(): Result<BodyConverterRegistry>;
+    getConverter(kind: Kind): Result<Converter<unknown>>;
+    has(kind: Kind): boolean;
+    register<T>(kind: Kind, converter: Converter<T>): void;
+    registerSchema<T>(kind: Kind, schema: JsonSchema.ISchemaValidator<T>): void;
+}
+
+// @public
+export const Convert: {
+    readonly memoryId: Converter<MemoryId>;
+    readonly entityId: Converter<EntityId>;
+    readonly kind: Converter<Kind>;
+    readonly tag: Converter<Tag>;
+    readonly scopeKey: Converter<MemoryScopeKey>;
+    readonly linkType: Converter<LinkType>;
+};
+
+// @public
+export type DedupScope = 'content' | 'entity';
+
+// @public
+export const DEFAULT_DEDUP_SCOPE: DedupScope;
+
+// @public
+export function defaultMemoryScopeEncoding(scope: MemoryScopeKey): Result<string>;
+
+// @public
+export const edgeConverter: Converter<IEdge>;
+
+// @public
+export type EntityId = Brand<string, 'EntityId'>;
+
+// @public
+export const envelopeConverter: Converter<IMemoryEnvelope>;
+
+// @public
+export const envelopeYamlConverter: Converter<IMemoryEnvelope>;
+
+// @public
+export class FileTreeMemoryStore implements IMemoryStore {
+    static create(params: IFileTreeMemoryStoreCreateParams): Result<FileTreeMemoryStore>;
+    delete(kind: Kind, entityId: EntityId): Promise<Result<MemoryId>>;
+    get(kind: Kind, entityId: EntityId): Promise<Result<IMemoryRecord<unknown> | undefined>>;
+    getById(scope: MemoryScopeKey, id: MemoryId): Promise<Result<IMemoryRecord<unknown> | undefined>>;
+    list(filter?: IMemoryStoreListFilter): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+    put(record: IMemoryRecord<unknown>): Promise<Result<IMemoryRecord<unknown>>>;
+}
+
+// @public
+export function guardRetrieverCapabilities(query: IMemoryQuery, capabilities: IMemoryRetrieverCapabilities): Result<true>;
+
+// @public
+export class HybridRetriever implements IMemoryRetriever {
+    get capabilities(): IMemoryRetrieverCapabilities;
+    static create(retrievers: ReadonlyArray<IMemoryRetriever>, mergeStrategy: IMergeStrategy): Result<HybridRetriever>;
+    retrieve(query: IMemoryQuery): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+}
+
+// @public
+export interface IBodyConverterRegistry {
+    convert(kind: Kind, body: unknown): Result<unknown>;
+    getConverter(kind: Kind): Result<Converter<unknown>>;
+    has(kind: Kind): boolean;
+    register<T>(kind: Kind, converter: Converter<T>): void;
+    registerSchema<T>(kind: Kind, schema: JsonSchema.ISchemaValidator<T>): void;
+}
+
+// @public
+export interface IEdge {
+    readonly confidence?: number;
+    readonly invalid_at?: number | null;
+    readonly provenance?: IProvenance;
+    readonly target: MemoryId;
+    readonly type: LinkType;
+    readonly valid_at?: number;
+}
+
+// @public
+export interface IFileTreeMemoryStoreCreateParams {
+    readonly clock?: () => number;
+    readonly codecs?: ReadonlyMap<Kind, IIdentityCodec>;
+    readonly defaultCodec?: IIdentityCodec;
+    readonly embed?: MemoryEmbedder;
+    readonly logger?: Logging.ILogger;
+    readonly observers?: ReadonlyArray<IMemoryObserver>;
+    readonly registry: IBodyConverterRegistry;
+    readonly root: FileTree.IMutableFileTreeDirectoryItem;
+    readonly scopeEncoding?: (scope: MemoryScopeKey) => Result<string>;
+    readonly vectorIndex?: IVectorIndex;
+    readonly writePolicies?: ReadonlyMap<Kind, IWritePolicy>;
+}
+
+// @public
+export interface IIdentityCodec {
+    decode(scope: MemoryScopeKey, encodedStem: string): Result<EntityId>;
+    encode(entityId: EntityId): Result<IIdentityCodecResult>;
+    verifyRoundTrip(scope: MemoryScopeKey, stem: string): Result<true>;
+}
+
+// @public
+export interface IIdentityCodecResult {
+    readonly idStem: string;
+    readonly isVersioned: boolean;
+    readonly scope: MemoryScopeKey;
+}
+
+// @public
+export interface IIndexedMemoryRecord {
+    readonly record: IMemoryRecord<unknown>;
+    readonly scope: MemoryScopeKey;
+}
+
+// @public
+export interface IMemoryCapCullPolicyParams {
+    readonly maxRecords?: number;
+    readonly mutableFields: ReadonlyArray<string>;
+}
+
+// @public
+export interface IMemoryEnvelope {
+    readonly contentHash: string;
+    readonly created: number;
+    readonly embeddingRef?: string | null;
+    readonly entityId: EntityId;
+    readonly id: MemoryId;
+    readonly kind: Kind;
+    readonly links: ReadonlyArray<IEdge>;
+    readonly provenance: IProvenance;
+    readonly seq: number;
+    readonly tags: ReadonlyArray<Tag>;
+    readonly temporal?: ITemporalBlock;
+    readonly updated: number;
+}
+
+// @public
+export interface IMemoryFileParts {
+    readonly body: string;
+    readonly frontmatter: string;
+}
+
+// @public
+export interface IMemoryIndex {
+    backlinks(target: MemoryId): ReadonlyArray<MemoryId>;
+    byKind(kind: Kind): ReadonlyArray<IMemoryRecord<unknown>>;
+    byRecency(): ReadonlyArray<IMemoryRecord<unknown>>;
+    byTag(tag: Tag): ReadonlyArray<IMemoryRecord<unknown>>;
+    entries(): ReadonlyArray<IIndexedMemoryRecord>;
+    patch(op: MemoryIndexPatchOp, entry: IIndexedMemoryRecord): Result<IIndexedMemoryRecord>;
+    rebuild(entries: ReadonlyArray<IIndexedMemoryRecord>): Result<number>;
+}
+
+// @public
+export interface IMemoryObservationQuery {
+    readonly kind?: Kind;
+    readonly limit?: number;
+    readonly outcome?: MemoryObservationOutcome;
+    readonly phase?: MemoryObservationPhase;
+    readonly scope?: MemoryScopeKey;
+    readonly since?: number;
+    readonly sinceSeq?: number;
+    readonly until?: number;
+}
+
+// @public
+export interface IMemoryObservationRecord {
+    readonly error?: string;
+    readonly id?: MemoryId;
+    readonly kind?: Kind;
+    readonly outcome: MemoryObservationOutcome;
+    readonly phase: MemoryObservationPhase;
+    readonly provenance?: IProvenance;
+    readonly querySnapshot?: Readonly<Record<string, unknown>>;
+    readonly scope?: MemoryScopeKey;
+    readonly seq: number;
+    readonly timestamp: number;
+}
+
+// @public
+export interface IMemoryObservationStoreCreateParams {
+    readonly maxRecords?: number;
+}
+
+// @public
+export interface IMemoryObserver {
+    readonly fireAndForget?: boolean;
+    observe(record: IMemoryObservationRecord): Promise<Result<unknown>>;
+}
+
+// @public
+export interface IMemoryQuery {
+    readonly asOf?: number;
+    readonly filter?: (record: IMemoryRecord<unknown>) => boolean;
+    readonly hops?: number;
+    readonly kind?: Kind;
+    readonly limit?: number;
+    readonly linkedFrom?: MemoryId;
+    readonly linkedTo?: MemoryId;
+    readonly scope?: MemoryScopeKey;
+    readonly semantic?: string;
+    readonly tag?: Tag;
+    readonly topK?: number;
+}
+
+// @public
+export interface IMemoryRecord<TBody = unknown> {
+    readonly body: TBody;
+    readonly envelope: IMemoryEnvelope;
+}
+
+// @public
+export interface IMemoryRecordSource {
+    list(): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+}
+
+// @public
+export interface IMemoryRetriever {
+    readonly capabilities: IMemoryRetrieverCapabilities;
+    retrieve(query: IMemoryQuery): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+}
+
+// @public
+export interface IMemoryRetrieverCapabilities {
+    readonly supportsLinkTraversal: boolean;
+    readonly supportsSemanticRecall: boolean;
+    readonly supportsTemporalQuery: boolean;
+}
+
+// @public
+export interface IMemoryStore {
+    delete(kind: Kind, entityId: EntityId): Promise<Result<MemoryId>>;
+    get(kind: Kind, entityId: EntityId): Promise<Result<IMemoryRecord<unknown> | undefined>>;
+    getById(scope: MemoryScopeKey, id: MemoryId): Promise<Result<IMemoryRecord<unknown> | undefined>>;
+    list(filter?: IMemoryStoreListFilter): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+    put(record: IMemoryRecord<unknown>): Promise<Result<IMemoryRecord<unknown>>>;
+}
+
+// @public
+export interface IMemoryStoreListFilter {
+    readonly asOf?: number;
+    readonly kind?: Kind;
+    readonly scope?: MemoryScopeKey;
+    readonly tag?: Tag;
+}
+
+// @public
+export interface IMergeStrategy {
+    merge(resultSets: ReadonlyArray<ReadonlyArray<IMemoryRecord<unknown>>>): Result<ReadonlyArray<IMemoryRecord<unknown>>>;
+}
+
+// @public
+export function indexedRecordMatchesQuery(entry: IIndexedMemoryRecord, query: IMemoryQuery): boolean;
+
+// @public
+export class InMemoryCosineIndex implements IVectorIndex {
+    add(id: MemoryId, vector: Float32Array): Promise<Result<string>>;
+    static create(): Result<InMemoryCosineIndex>;
+    query(vector: Float32Array, topK: number): Promise<Result<ReadonlyArray<IVectorQueryHit>>>;
+    rebuild(source: IMemoryRecordSource, embed: MemoryEmbedder): Promise<Result<number>>;
+    remove(id: MemoryId): Promise<Result<MemoryId>>;
+    get size(): number;
+}
+
+// @public
+export interface IProvenance {
+    readonly [key: string]: unknown;
+    readonly by?: string;
+    readonly confidence?: number;
+    readonly derivedFrom?: MemoryId;
+    readonly model?: string;
+    readonly source: ProvenanceSource;
+}
+
+// @public
+export interface ISemanticBackend {
+    readonly embedQuery: QueryEmbedder;
+    readonly vectorIndex: IVectorIndex;
+}
+
+// @public
+export interface ISemanticRetrieverCreateParams {
+    readonly backend?: ISemanticBackend;
+    readonly index: IMemoryIndex;
+}
+
+// @public
+export interface ITemporalBlock {
+    readonly invalid_at?: number | null;
+    readonly valid_at?: number;
+}
+
+// @public
+export interface IVectorIndex {
+    add(id: MemoryId, vector: Float32Array): Promise<Result<string>>;
+    query(vector: Float32Array, topK: number): Promise<Result<ReadonlyArray<IVectorQueryHit>>>;
+    remove(id: MemoryId): Promise<Result<MemoryId>>;
+}
+
+// @public
+export interface IVectorQueryHit {
+    readonly id: MemoryId;
+    readonly score: number;
+}
+
+// @public
+export interface IWritePolicy {
+    admit(incoming: IMemoryRecord<unknown>, existing: ReadonlyArray<IMemoryRecord<unknown>>): Result<AdmissionDecision>;
+    applyUpdate(existing: IMemoryRecord<unknown>, patch: Record<string, unknown>): Result<IMemoryRecord<unknown>>;
+    readonly dedupScope?: DedupScope;
+    readonly mutableFields: ReadonlyArray<string>;
+}
+
+// @public
+export function joinFrontmatter(frontmatter: string, body: string): string;
+
+// @public
+export type Kind = Brand<string, 'Kind'>;
+
+// @public
+export class KnowledgeIdentityCodec implements IIdentityCodec {
+    decode(scope: MemoryScopeKey, encodedStem: string): Result<EntityId>;
+    encode(entityId: EntityId): Result<IIdentityCodecResult>;
+    static readonly scope: MemoryScopeKey;
+    verifyRoundTrip(scope: MemoryScopeKey, stem: string): Result<true>;
+}
+
+// @public
+export class KnowledgeLwwPolicy implements IWritePolicy {
+    admit(__incoming: IMemoryRecord<unknown>, __existing: ReadonlyArray<IMemoryRecord<unknown>>): Result<AdmissionDecision>;
+    applyUpdate(existing: IMemoryRecord<unknown>, patch: Record<string, unknown>): Result<IMemoryRecord<unknown>>;
+    static create(): Result<KnowledgeLwwPolicy>;
+    readonly dedupScope: DedupScope;
+    readonly mutableFields: ReadonlyArray<string>;
+}
+
+// @public
+export function limitRecords(records: ReadonlyArray<IMemoryRecord<unknown>>, limit?: number): ReadonlyArray<IMemoryRecord<unknown>>;
+
+// @public
+export const LINK_TRAVERSAL_NO_SEED_MESSAGE: string;
+
+// @public
+export const LINK_TRAVERSAL_UNWIRED_MESSAGE: string;
+
+// @public
+export class LinkTraversalRetriever implements IMemoryRetriever {
+    get capabilities(): IMemoryRetrieverCapabilities;
+    static create(index: IMemoryIndex): Result<LinkTraversalRetriever>;
+    retrieve(query: IMemoryQuery): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+}
+
+// @public
+export type LinkType = Brand<string, 'LinkType'>;
+
+// @public
+export class LtmIdentityCodec implements IIdentityCodec {
+    decode(scope: MemoryScopeKey, encodedStem: string): Result<EntityId>;
+    encode(entityId: EntityId): Result<IIdentityCodecResult>;
+    static readonly scope: MemoryScopeKey;
+    verifyRoundTrip(scope: MemoryScopeKey, stem: string): Result<true>;
+}
+
+// @public
+export class MemoryCapCullPolicy implements IWritePolicy {
+    admit(__incoming: IMemoryRecord<unknown>, existing: ReadonlyArray<IMemoryRecord<unknown>>): Result<AdmissionDecision>;
+    applyUpdate(existing: IMemoryRecord<unknown>, patch: Record<string, unknown>): Result<IMemoryRecord<unknown>>;
+    static create(params: IMemoryCapCullPolicyParams): Result<MemoryCapCullPolicy>;
+    readonly dedupScope: DedupScope;
+    readonly mutableFields: ReadonlyArray<string>;
+}
+
+// @public
+export type MemoryEmbedder = (record: IMemoryRecord<unknown>) => Promise<Result<Float32Array>>;
+
+// @public
+export type MemoryId = Brand<string, 'MemoryId'>;
+
+// @public
+export class MemoryIndex implements IMemoryIndex {
+    backlinks(target: MemoryId): ReadonlyArray<MemoryId>;
+    byKind(kind: Kind): ReadonlyArray<IMemoryRecord<unknown>>;
+    byRecency(): ReadonlyArray<IMemoryRecord<unknown>>;
+    byTag(tag: Tag): ReadonlyArray<IMemoryRecord<unknown>>;
+    static create(): Result<MemoryIndex>;
+    entries(): ReadonlyArray<IIndexedMemoryRecord>;
+    patch(op: MemoryIndexPatchOp, entry: IIndexedMemoryRecord): Result<IIndexedMemoryRecord>;
+    rebuild(entries: ReadonlyArray<IIndexedMemoryRecord>): Result<number>;
+}
+
+// @public
+export type MemoryIndexPatchOp = 'put' | 'delete';
+
+// @public
+export type MemoryObservationOutcome = 'success' | 'failure';
+
+// @public
+export type MemoryObservationPhase = 'read' | 'write' | 'delete' | 'retrieve';
+
+// @public
+export class MemoryObservationStore implements IMemoryObserver {
+    clear(): void;
+    static create(params?: IMemoryObservationStoreCreateParams): Result<MemoryObservationStore>;
+    get lastSeq(): number;
+    observe(record: IMemoryObservationRecord): Promise<Result<unknown>>;
+    query(criteria?: IMemoryObservationQuery): ReadonlyArray<IMemoryObservationRecord>;
+    get size(): number;
+}
+
+// @public
+export type MemoryScopeKey = Brand<string, 'MemoryScopeKey'>;
+
+// @public
+export class MtmIdentityCodec implements IIdentityCodec {
+    decode(scope: MemoryScopeKey, encodedStem: string): Result<EntityId>;
+    encode(entityId: EntityId): Result<IIdentityCodecResult>;
+    static readonly rootScopeSegment: string;
+    static readonly turnStemPrefix: string;
+    verifyRoundTrip(scope: MemoryScopeKey, stem: string): Result<true>;
+}
+
+// @public
+export const NON_SEMANTIC_CAPABILITIES: IMemoryRetrieverCapabilities;
+
+// @public
+export function parseMemoryFile(raw: string, registry: IBodyConverterRegistry): Result<IMemoryRecord<unknown>>;
+
+// @public
+export const provenanceConverter: Converter<IProvenance>;
+
+// @public
+export type ProvenanceSource = 'agent' | 'host-ingest' | 'human' | (string & {});
+
+// @public
+export type QueryEmbedder = (text: string) => Promise<Result<Float32Array>>;
+
+// @public
+export function recencyCompare(a: IMemoryRecord<unknown>, b: IMemoryRecord<unknown>): number;
+
+// @public
+export class RecencyRetriever implements IMemoryRetriever {
+    get capabilities(): IMemoryRetrieverCapabilities;
+    static create(index: IMemoryIndex): Result<RecencyRetriever>;
+    retrieve(query: IMemoryQuery): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+}
+
+// @public
+export class ScoreUnionMergeStrategy implements IMergeStrategy {
+    static create(): Result<ScoreUnionMergeStrategy>;
+    merge(resultSets: ReadonlyArray<ReadonlyArray<IMemoryRecord<unknown>>>): Result<ReadonlyArray<IMemoryRecord<unknown>>>;
+}
+
+// @public
+export function selectByQuery(entries: ReadonlyArray<IIndexedMemoryRecord>, query: IMemoryQuery): IMemoryRecord<unknown>[];
+
+// @public
+export const SEMANTIC_UNWIRED_MESSAGE: string;
+
+// @public
+export class SemanticRetriever implements IMemoryRetriever {
+    get capabilities(): IMemoryRetrieverCapabilities;
+    static create(params: ISemanticRetrieverCreateParams): Result<SemanticRetriever>;
+    retrieve(query: IMemoryQuery): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+}
+
+// @public
+export function serializeMemoryFile(envelope: IMemoryEnvelope, body: string): Result<string>;
+
+// @public
+export function splitFrontmatter(raw: string): Result<IMemoryFileParts>;
+
+// @public
+export class StructuredFilterRetriever implements IMemoryRetriever {
+    get capabilities(): IMemoryRetrieverCapabilities;
+    static create(index: IMemoryIndex): Result<StructuredFilterRetriever>;
+    retrieve(query: IMemoryQuery): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+}
+
+// @public
+export type Tag = Brand<string, 'Tag'>;
+
+// @public
+export class TagRetriever implements IMemoryRetriever {
+    get capabilities(): IMemoryRetrieverCapabilities;
+    static create(index: IMemoryIndex): Result<TagRetriever>;
+    retrieve(query: IMemoryQuery): Promise<Result<ReadonlyArray<IMemoryRecord<unknown>>>>;
+}
+
+// @public
+export const temporalConverter: Converter<ITemporalBlock>;
+
+// @public
+export function temporalUnwiredMessage(kind?: Kind): string;
+
+// (No @packageDocumentation comment for this package)
+
+```

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+export * from './packlets/types';
+export * from './packlets/converters';
+export * from './packlets/store';
+export * from './packlets/index';
+export * from './packlets/retrieve';
+export * from './packlets/observe';
+export * from './packlets/vector';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC"}

package/lib/index.js

@@ -0,0 +1,28 @@
+"use strict";
+/*
+ * Copyright (c) 2026 Erik Fortune
+ * SPDX-License-Identifier: MIT
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./packlets/types"), exports);
+__exportStar(require("./packlets/converters"), exports);
+__exportStar(require("./packlets/store"), exports);
+__exportStar(require("./packlets/index"), exports);
+__exportStar(require("./packlets/retrieve"), exports);
+__exportStar(require("./packlets/observe"), exports);
+__exportStar(require("./packlets/vector"), exports);
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;;;;;AAEH,mDAAiC;AACjC,wDAAsC;AACtC,mDAAiC;AACjC,mDAAiC;AACjC,sDAAoC;AACpC,qDAAmC;AACnC,oDAAkC","sourcesContent":["/*\n * Copyright (c) 2026 Erik Fortune\n * SPDX-License-Identifier: MIT\n */\n\nexport * from './packlets/types';\nexport * from './packlets/converters';\nexport * from './packlets/store';\nexport * from './packlets/index';\nexport * from './packlets/retrieve';\nexport * from './packlets/observe';\nexport * from './packlets/vector';\n"]}

package/lib/packlets/converters/bodyConverterRegistry.d.ts

@@ -0,0 +1,64 @@
+import { Converter, Result } from '@fgv/ts-utils';
+import { JsonSchema } from '@fgv/ts-json-base';
+import { Kind } from '../types';
+/**
+ * Registry of per-kind body Converters. Each memory {@link Kind} registers the
+ * validated shape of its body; the store dispatches an `unknown` body through
+ * the registered Converter on every write. Type-safe — no `any`.
+ * @public
+ */
+export interface IBodyConverterRegistry {
+    /**
+     * Register a Converter for a kind. Replaces any prior registration for the
+     * same kind.
+     */
+    register<T>(kind: Kind, converter: Converter<T>): void;
+    /**
+     * Register a `JsonSchema` validator (from `@fgv/ts-json-base`) for a kind —
+     * the schema IS a Validator. Replaces any prior registration for the same
+     * kind.
+     */
+    registerSchema<T>(kind: Kind, schema: JsonSchema.ISchemaValidator<T>): void;
+    /** Returns `true` if a converter is registered for the kind. */
+    has(kind: Kind): boolean;
+    /**
+     * Get the raw converter registered for a kind. Fails if the kind is
+     * unregistered. Exposed for implementors that need to re-validate a patched
+     * body (e.g. a temporal-versioned policy's `applyUpdate`).
+     */
+    getConverter(kind: Kind): Result<Converter<unknown>>;
+    /**
+     * Convert an `unknown` body value for the given kind. Fails with
+     * `no converter registered for kind '<k>'` when unregistered.
+     */
+    convert(kind: Kind, body: unknown): Result<unknown>;
+}
+/**
+ * Default in-memory {@link IBodyConverterRegistry}.
+ *
+ * @remarks
+ * Both `register` and `registerSchema` adapt the supplied converter/validator
+ * into a `Converter<unknown>` via `Converters.generic`, so the heterogeneous
+ * per-kind types are stored uniformly with no cast and no `any`. A
+ * `Converter<T>` is not structurally a `Converter<unknown>` (the `map` callback
+ * makes the type invariant), so the `generic` wrapper — whose callback returns
+ * `Result<T>` (assignable to `Result<unknown>`) — is the type-safe bridge.
+ * @public
+ */
+export declare class BodyConverterRegistry implements IBodyConverterRegistry {
+    private readonly _converters;
+    private constructor();
+    /** Family-convention factory. */
+    static create(): Result<BodyConverterRegistry>;
+    /** {@inheritDoc IBodyConverterRegistry.register} */
+    register<T>(kind: Kind, converter: Converter<T>): void;
+    /** {@inheritDoc IBodyConverterRegistry.registerSchema} */
+    registerSchema<T>(kind: Kind, schema: JsonSchema.ISchemaValidator<T>): void;
+    /** {@inheritDoc IBodyConverterRegistry.has} */
+    has(kind: Kind): boolean;
+    /** {@inheritDoc IBodyConverterRegistry.getConverter} */
+    getConverter(kind: Kind): Result<Converter<unknown>>;
+    /** {@inheritDoc IBodyConverterRegistry.convert} */
+    convert(kind: Kind, body: unknown): Result<unknown>;
+}
+//# sourceMappingURL=bodyConverterRegistry.d.ts.map

package/lib/packlets/converters/bodyConverterRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bodyConverterRegistry.d.ts","sourceRoot":"","sources":["../../../src/packlets/converters/bodyConverterRegistry.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAc,MAAM,EAAiB,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAEhC;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAEvD;;;;OAIG;IACH,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAE5E,gEAAgE;IAChE,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC;IAEzB;;;;OAIG;IACH,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;IAErD;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;CACrD;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,qBAAsB,YAAW,sBAAsB;IAClE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAgC;IAE5D,OAAO;IAIP,iCAAiC;WACnB,MAAM,IAAI,MAAM,CAAC,qBAAqB,CAAC;IAIrD,oDAAoD;IAC7C,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI;IAO7D,0DAA0D;IACnD,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,IAAI;IAOlF,+CAA+C;IACxC,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO;IAI/B,wDAAwD;IACjD,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IAQ3D,mDAAmD;IAC5C,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC;CAG3D"}