@peers-app/peers-sdk 0.16.5 → 0.17.0

package/dist/contracts/builder.d.ts

@@ -0,0 +1,102 @@
+import type { ITableDefinition } from "../data/orm/table-definitions.type";
+import type { IToolInstance } from "../data/tools";
+import type { IExtractableTableDef, IExtractableToolInstance } from "./extract";
+import type { IAlsoImplementsDeclaration, IContractDefinition, IContractObservable, IPackageDefinitionResult } from "./types";
+/**
+ * Scoped builder for a single contract within a package. Returned by
+ * `PackageBuilder.contract()`.
+ */
+export declare class ContractBuilder {
+    readonly contractId: string;
+    readonly version: number;
+    readonly name: string;
+    readonly description?: string | undefined;
+    readonly devTag?: "dev" | undefined;
+    private _tables;
+    private _tools;
+    private _observables;
+    private _alsoImplements;
+    /** Full runtime tool instances for this contract (used by the install flow). */
+    private _toolInstances;
+    /** Full table definitions for this contract (used by the install flow). */
+    private _tableDefinitions;
+    constructor(contractId: string, version: number, name: string, description?: string | undefined, devTag?: "dev" | undefined);
+    set tables(defs: IExtractableTableDef[]);
+    get tables(): IExtractableTableDef[];
+    set tools(instances: IExtractableToolInstance[]);
+    get tools(): IExtractableToolInstance[];
+    set observables(obs: IContractObservable[]);
+    get observables(): IContractObservable[];
+    /** Full tool instances with executable toolFn for runtime registration. */
+    set toolInstances(instances: IToolInstance[]);
+    get toolInstances(): IToolInstance[];
+    /** Full table definitions for runtime table registration. */
+    set tableDefinitions(defs: ITableDefinition[]);
+    get tableDefinitions(): ITableDefinition[];
+    /**
+     * Declare that this contract's implementation also satisfies another
+     * contract at the given version or inclusive version range.
+     */
+    alsoImplements(targetContractId: string, versionOrRange: number | {
+        from: number;
+        to: number;
+    }): void;
+    /** @internal Build the contract definition by extracting shapes. */
+    _build(): {
+        definition: IContractDefinition;
+        alsoImplements: IAlsoImplementsDeclaration[];
+        toolInstances: IToolInstance[];
+        tableDefinitions: ITableDefinition[];
+    };
+}
+/**
+ * Top-level builder passed to the `definePackage` callback.
+ *
+ * Packages may define **zero** contracts (e.g. UI-only apps with no persisted
+ * tables). Tables, tool shapes, and executable `toolInstances` /
+ * `tableDefinitions` are only attached via {@link PackageBuilder.contract} —
+ * there is no package-level API for them, so persistence always implies a
+ * contract.
+ */
+export declare class PackageBuilder {
+    private _packageId?;
+    private _version?;
+    private _versionTag?;
+    private _contracts;
+    private _consumes;
+    /** Package-level assistants (not part of any contract). */
+    assistants: unknown[];
+    /** Package-level app navigation items (not part of any contract). */
+    appNavs: unknown[];
+    /** The peer ID of this package (25-char alphanumeric from `newid()`). */
+    set packageId(id: string);
+    get packageId(): string | undefined;
+    /** Semantic version string (e.g. "1.0.0"). Typically imported from package.json at build time. */
+    set version(v: string);
+    get version(): string | undefined;
+    /** Version channel tag (e.g. "dev", "beta", "stable"). */
+    set versionTag(tag: string);
+    get versionTag(): string | undefined;
+    /**
+     * Define (and implement) a contract at the given version.
+     * Returns a `ContractBuilder` for assigning tables, tools, and observables.
+     *
+     * @param contractId - Must be a valid peer ID (25-char alphanumeric from `newid()`).
+     * @param version - Positive integer version number.
+     * @param name - Human-readable contract name. This is the meaningful identifier that creators can change over time.
+     * @param devTag - Set to `"dev"` while the contract shape is still mutable.
+     */
+    contract(contractId: string, version: number, name: string, devTag?: "dev"): ContractBuilder;
+    /**
+     * Declare a dependency on another package's contract.
+     */
+    consumes(contractId: string, version: number): void;
+    /** @internal Finalize and return the package definition result. */
+    _build(): IPackageDefinitionResult;
+}
+/**
+ * Entry point for defining a package.  The callback receives a
+ * `PackageBuilder` which is used to declare contracts, consumptions, and
+ * package-level items.  Returns the fully-built package definition.
+ */
+export declare function definePackage(fn: (pkg: PackageBuilder) => void): IPackageDefinitionResult;

package/dist/contracts/builder.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageBuilder = exports.ContractBuilder = void 0;
+exports.definePackage = definePackage;
+const utils_1 = require("../utils");
+const extract_1 = require("./extract");
+const types_1 = require("./types");
+/**
+ * Scoped builder for a single contract within a package. Returned by
+ * `PackageBuilder.contract()`.
+ */
+class ContractBuilder {
+    contractId;
+    version;
+    name;
+    description;
+    devTag;
+    _tables = [];
+    _tools = [];
+    _observables = [];
+    _alsoImplements = [];
+    /** Full runtime tool instances for this contract (used by the install flow). */
+    _toolInstances = [];
+    /** Full table definitions for this contract (used by the install flow). */
+    _tableDefinitions = [];
+    constructor(contractId, version, name, description, devTag) {
+        this.contractId = contractId;
+        this.version = version;
+        this.name = name;
+        this.description = description;
+        this.devTag = devTag;
+    }
+    set tables(defs) {
+        this._tables = defs;
+    }
+    get tables() {
+        return this._tables;
+    }
+    set tools(instances) {
+        this._tools = instances;
+    }
+    get tools() {
+        return this._tools;
+    }
+    set observables(obs) {
+        this._observables = obs;
+    }
+    get observables() {
+        return this._observables;
+    }
+    /** Full tool instances with executable toolFn for runtime registration. */
+    set toolInstances(instances) {
+        this._toolInstances = instances;
+    }
+    get toolInstances() {
+        return this._toolInstances;
+    }
+    /** Full table definitions for runtime table registration. */
+    set tableDefinitions(defs) {
+        this._tableDefinitions = defs;
+    }
+    get tableDefinitions() {
+        return this._tableDefinitions;
+    }
+    /**
+     * Declare that this contract's implementation also satisfies another
+     * contract at the given version or inclusive version range.
+     */
+    alsoImplements(targetContractId, versionOrRange) {
+        if (!(0, utils_1.isid)(targetContractId)) {
+            throw new Error(`alsoImplements targetContractId must be a valid peer ID (25-char alphanumeric), got "${targetContractId}"`);
+        }
+        this._alsoImplements.push({ contractId: targetContractId, version: versionOrRange });
+    }
+    /** @internal Build the contract definition by extracting shapes. */
+    _build() {
+        return {
+            definition: {
+                contractId: this.contractId,
+                version: this.version,
+                devTag: this.devTag,
+                name: this.name,
+                description: this.description ?? "",
+                tables: this._tables.map(extract_1.extractTableShape),
+                tools: this._tools.map(extract_1.extractToolShape),
+                observables: [...this._observables],
+            },
+            alsoImplements: [...this._alsoImplements],
+            toolInstances: [...this._toolInstances],
+            tableDefinitions: [...this._tableDefinitions],
+        };
+    }
+}
+exports.ContractBuilder = ContractBuilder;
+/**
+ * Top-level builder passed to the `definePackage` callback.
+ *
+ * Packages may define **zero** contracts (e.g. UI-only apps with no persisted
+ * tables). Tables, tool shapes, and executable `toolInstances` /
+ * `tableDefinitions` are only attached via {@link PackageBuilder.contract} —
+ * there is no package-level API for them, so persistence always implies a
+ * contract.
+ */
+class PackageBuilder {
+    _packageId;
+    _version;
+    _versionTag;
+    _contracts = [];
+    _consumes = [];
+    /** Package-level assistants (not part of any contract). */
+    assistants = [];
+    /** Package-level app navigation items (not part of any contract). */
+    appNavs = [];
+    /** The peer ID of this package (25-char alphanumeric from `newid()`). */
+    set packageId(id) {
+        if (!(0, utils_1.isid)(id)) {
+            throw new Error(`packageId must be a valid peer ID (25-char alphanumeric), got "${id}"`);
+        }
+        this._packageId = id;
+    }
+    get packageId() {
+        return this._packageId;
+    }
+    /** Semantic version string (e.g. "1.0.0"). Typically imported from package.json at build time. */
+    set version(v) {
+        this._version = v;
+    }
+    get version() {
+        return this._version;
+    }
+    /** Version channel tag (e.g. "dev", "beta", "stable"). */
+    set versionTag(tag) {
+        this._versionTag = tag;
+    }
+    get versionTag() {
+        return this._versionTag;
+    }
+    /**
+     * Define (and implement) a contract at the given version.
+     * Returns a `ContractBuilder` for assigning tables, tools, and observables.
+     *
+     * @param contractId - Must be a valid peer ID (25-char alphanumeric from `newid()`).
+     * @param version - Positive integer version number.
+     * @param name - Human-readable contract name. This is the meaningful identifier that creators can change over time.
+     * @param devTag - Set to `"dev"` while the contract shape is still mutable.
+     */
+    contract(contractId, version, name, devTag) {
+        if (!(0, utils_1.isid)(contractId)) {
+            throw new Error(`contractId must be a valid peer ID (25-char alphanumeric), got "${contractId}"`);
+        }
+        if (version < 1 || !Number.isInteger(version)) {
+            throw new Error(`Contract version must be a positive integer, got ${version}`);
+        }
+        const existing = this._contracts.find((c) => c.contractId === contractId && c.version === version);
+        if (existing) {
+            throw new Error(`Duplicate contract: ${contractId} v${version} is already defined in this package`);
+        }
+        const builder = new ContractBuilder(contractId, version, name, undefined, devTag);
+        this._contracts.push(builder);
+        return builder;
+    }
+    /**
+     * Declare a dependency on another package's contract.
+     */
+    consumes(contractId, version) {
+        if (!(0, utils_1.isid)(contractId)) {
+            throw new Error(`consumes contractId must be a valid peer ID (25-char alphanumeric), got "${contractId}"`);
+        }
+        this._consumes.push({ contractId, version });
+    }
+    /** @internal Finalize and return the package definition result. */
+    _build() {
+        if (!this._packageId) {
+            throw new Error("A package must set packageId before building");
+        }
+        const contracts = [];
+        const alsoImplementsMap = new Map();
+        const allToolInstances = [];
+        const allTableDefinitions = [];
+        for (const cb of this._contracts) {
+            const { definition, alsoImplements, toolInstances, tableDefinitions } = cb._build();
+            contracts.push(definition);
+            if (alsoImplements.length > 0) {
+                alsoImplementsMap.set((0, types_1.contractKey)(cb.contractId, cb.version), alsoImplements);
+            }
+            allToolInstances.push(...toolInstances);
+            allTableDefinitions.push(...tableDefinitions);
+        }
+        if (contracts.length === 0 && (allToolInstances.length > 0 || allTableDefinitions.length > 0)) {
+            throw new Error("Tables and executable tools must be declared on a contract (use pkg.contract(...), then assign .tables, .tools, .toolInstances, or .tableDefinitions on that builder). UI-only packages omit contracts and do not register tables or tools.");
+        }
+        return {
+            packageId: this._packageId,
+            version: this._version,
+            versionTag: this._versionTag,
+            contracts,
+            consumes: [...this._consumes],
+            alsoImplements: alsoImplementsMap,
+            assistants: [...this.assistants],
+            appNavs: [...this.appNavs],
+            toolInstances: allToolInstances,
+            tableDefinitions: allTableDefinitions,
+        };
+    }
+}
+exports.PackageBuilder = PackageBuilder;
+/**
+ * Entry point for defining a package.  The callback receives a
+ * `PackageBuilder` which is used to declare contracts, consumptions, and
+ * package-level items.  Returns the fully-built package definition.
+ */
+function definePackage(fn) {
+    const pkg = new PackageBuilder();
+    fn(pkg);
+    return pkg._build();
+}

package/dist/contracts/contract-providers.table.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import type { DataContext } from "../context/data-context";
+import { Table } from "../data/orm/table";
+import { type ITableMetaData } from "../data/orm/types";
+/**
+ * Zod schema for persisted contract provider mappings.
+ * Tracks which package provides each contract and whether it is the active
+ * provider for resolution purposes.
+ */
+declare const schema: z.ZodObject<{
+    contractProviderId: z.ZodEffects<z.ZodString, string, string>;
+    contractId: z.ZodEffects<z.ZodString, string, string>;
+    version: z.ZodNumber;
+    providerPackageId: z.ZodEffects<z.ZodString, string, string>;
+    isActive: z.ZodBoolean;
+    registeredAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version: number;
+    contractProviderId: string;
+    contractId: string;
+    providerPackageId: string;
+    isActive: boolean;
+    registeredAt: string;
+}, {
+    version: number;
+    contractProviderId: string;
+    contractId: string;
+    providerPackageId: string;
+    isActive: boolean;
+    registeredAt: string;
+}>;
+declare const metaData: ITableMetaData;
+/** Row type for the ContractProviders table. */
+export type IContractProviderRecord = z.infer<typeof schema>;
+/** Table class — no custom logic needed beyond base Table. */
+export declare class ContractProvidersTable extends Table<IContractProviderRecord> {
+}
+/** Accessor for the ContractProviders table. */
+export declare function ContractProviders(dataContext?: DataContext): ContractProvidersTable;
+export { schema as contractProvidersSchema, metaData as contractProvidersMetaData };

package/dist/contracts/contract-providers.table.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contractProvidersMetaData = exports.contractProvidersSchema = exports.ContractProvidersTable = void 0;
+exports.ContractProviders = ContractProviders;
+const zod_1 = require("zod");
+const context_1 = require("../context");
+const table_1 = require("../data/orm/table");
+const table_definitions_system_1 = require("../data/orm/table-definitions.system");
+const types_1 = require("../data/orm/types");
+const zod_types_1 = require("../types/zod-types");
+/**
+ * Zod schema for persisted contract provider mappings.
+ * Tracks which package provides each contract and whether it is the active
+ * provider for resolution purposes.
+ */
+const schema = zod_1.z.object({
+    contractProviderId: zod_types_1.zodPeerId,
+    contractId: zod_types_1.zodPeerId.describe("Contract this provider implements"),
+    version: zod_1.z.number().describe("Contract version (positive integer)"),
+    providerPackageId: zod_types_1.zodPeerId.describe("Package that provides this contract"),
+    isActive: zod_1.z.boolean().describe("Whether this provider is the current active resolver"),
+    registeredAt: zod_1.z.string().describe("ISO 8601 timestamp of registration"),
+});
+exports.contractProvidersSchema = schema;
+const metaData = {
+    name: "ContractProviders",
+    description: "Maps contracts to their provider packages and active selection",
+    primaryKeyName: "contractProviderId",
+    fields: (0, types_1.schemaToFields)(schema),
+    indexes: [{ fields: ["contractId", "version"] }, { fields: ["providerPackageId"] }],
+};
+exports.contractProvidersMetaData = metaData;
+/** Table class — no custom logic needed beyond base Table. */
+class ContractProvidersTable extends table_1.Table {
+}
+exports.ContractProvidersTable = ContractProvidersTable;
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, schema, ContractProvidersTable);
+/** Accessor for the ContractProviders table. */
+function ContractProviders(dataContext) {
+    return (0, context_1.getTableContainer)(dataContext).getTable(metaData, schema, ContractProvidersTable);
+}

package/dist/contracts/contracts.table.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import type { DataContext } from "../context/data-context";
+import { Table } from "../data/orm/table";
+import { type ITableMetaData } from "../data/orm/types";
+/**
+ * Zod schema for persisted contracts.
+ * The `shape` field stores the serialized `{ tables, tools, observables }` JSON
+ * so the full `IContractDefinition` can be rehydrated without re-extracting from
+ * live package code.
+ */
+declare const schema: z.ZodObject<{
+    contractId: z.ZodEffects<z.ZodString, string, string>;
+    version: z.ZodNumber;
+    devTag: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodString;
+    shape: z.ZodString;
+    registeredAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    shape: string;
+    version: number;
+    contractId: string;
+    registeredAt: string;
+    devTag?: string | undefined;
+}, {
+    name: string;
+    description: string;
+    shape: string;
+    version: number;
+    contractId: string;
+    registeredAt: string;
+    devTag?: string | undefined;
+}>;
+declare const metaData: ITableMetaData;
+/** Row type for the Contracts table. */
+export type IContractRecord = z.infer<typeof schema>;
+/** Table class — no custom logic needed beyond base Table. */
+export declare class ContractsTable extends Table<IContractRecord> {
+}
+/** Accessor for the Contracts table. */
+export declare function Contracts(dataContext?: DataContext): ContractsTable;
+export { schema as contractsSchema, metaData as contractsMetaData };

package/dist/contracts/contracts.table.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contractsMetaData = exports.contractsSchema = exports.ContractsTable = void 0;
+exports.Contracts = Contracts;
+const zod_1 = require("zod");
+const context_1 = require("../context");
+const table_1 = require("../data/orm/table");
+const table_definitions_system_1 = require("../data/orm/table-definitions.system");
+const types_1 = require("../data/orm/types");
+const zod_types_1 = require("../types/zod-types");
+/**
+ * Zod schema for persisted contracts.
+ * The `shape` field stores the serialized `{ tables, tools, observables }` JSON
+ * so the full `IContractDefinition` can be rehydrated without re-extracting from
+ * live package code.
+ */
+const schema = zod_1.z.object({
+    contractId: zod_types_1.zodPeerId,
+    version: zod_1.z.number().describe("Contract version (positive integer)"),
+    devTag: zod_1.z.string().optional().describe("'dev' if the contract shape is still mutable"),
+    name: zod_1.z.string().describe("Human-readable contract name"),
+    description: zod_1.z.string().describe("Contract description"),
+    shape: zod_1.z.string().describe("JSON-serialized { tables, tools, observables }"),
+    registeredAt: zod_1.z.string().describe("ISO 8601 timestamp of first registration"),
+});
+exports.contractsSchema = schema;
+const metaData = {
+    name: "Contracts",
+    description: "Persisted contract definition shapes for the contract registry",
+    primaryKeyName: "contractId",
+    fields: (0, types_1.schemaToFields)(schema),
+    localOnly: true,
+    indexes: [{ fields: ["contractId", "version"], unique: true }],
+};
+exports.contractsMetaData = metaData;
+/** Table class — no custom logic needed beyond base Table. */
+class ContractsTable extends table_1.Table {
+}
+exports.ContractsTable = ContractsTable;
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, schema, ContractsTable);
+/** Accessor for the Contracts table. */
+function Contracts(dataContext) {
+    return (0, context_1.getTableContainer)(dataContext).getTable(metaData, schema, ContractsTable);
+}

package/dist/contracts/extract.d.ts

@@ -0,0 +1,46 @@
+import type { z } from "zod";
+import type { IField } from "../types/field-type";
+import type { IContractTable, IContractTool } from "./types";
+/**
+ * Minimal table-definition shape accepted by extractTableShape.
+ * Mirrors the subset of ITableDefinition we need without importing the
+ * runtime module (which pulls in the full DI/table chain).
+ */
+export interface IExtractableTableDef {
+    metaData: {
+        name: string;
+        description: string;
+        primaryKeyName: string;
+        fields: IField[];
+    };
+    schema?: z.AnyZodObject;
+}
+/**
+ * Minimal tool-instance shape accepted by extractToolShape.
+ * Mirrors the subset of IToolInstance we need.
+ */
+export interface IExtractableToolInstance {
+    tool: {
+        name: string;
+        usageDescription: string;
+        inputSchema?: {
+            fields: IField[];
+        };
+        outputSchema?: {
+            fields: IField[];
+        };
+    };
+}
+/** Override the schemaToFields implementation (useful for tests). */
+export declare function setSchemaToFieldsFn(fn: (schema: z.AnyZodObject) => IField[]): void;
+/**
+ * Extract the contract-level table shape from a table definition.
+ * Prefers the Zod schema (via `schemaToFields`) when available, falling back
+ * to `metaData.fields`.
+ */
+export declare function extractTableShape(def: IExtractableTableDef): IContractTable;
+/**
+ * Extract the contract-level tool shape from a tool instance.
+ * Uses the tool record's `inputSchema.fields` and `outputSchema.fields`.
+ */
+export declare function extractToolShape(inst: IExtractableToolInstance): IContractTool;

package/dist/contracts/extract.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSchemaToFieldsFn = setSchemaToFieldsFn;
+exports.extractTableShape = extractTableShape;
+exports.extractToolShape = extractToolShape;
+/**
+ * Convert a Zod schema to IField[].  Lazy-loaded to avoid pulling in the
+ * heavy ORM module graph at import time.  In production this resolves to the
+ * real `schemaToFields`; tests can call `setSchemaToFieldsFn` to inject a
+ * lightweight alternative.
+ */
+let _schemaToFields;
+/** Override the schemaToFields implementation (useful for tests). */
+function setSchemaToFieldsFn(fn) {
+    _schemaToFields = fn;
+}
+function getSchemaToFields() {
+    if (!_schemaToFields) {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        _schemaToFields = require("../data/orm/types").schemaToFields;
+    }
+    return _schemaToFields;
+}
+/**
+ * Extract the contract-level table shape from a table definition.
+ * Prefers the Zod schema (via `schemaToFields`) when available, falling back
+ * to `metaData.fields`.
+ */
+function extractTableShape(def) {
+    const { metaData, schema } = def;
+    const fields = schema ? getSchemaToFields()(schema) : [...metaData.fields];
+    return {
+        name: metaData.name,
+        description: metaData.description,
+        primaryKeyName: metaData.primaryKeyName,
+        fields,
+    };
+}
+/**
+ * Extract the contract-level tool shape from a tool instance.
+ * Uses the tool record's `inputSchema.fields` and `outputSchema.fields`.
+ */
+function extractToolShape(inst) {
+    const { tool } = inst;
+    return {
+        name: tool.name,
+        usageDescription: tool.usageDescription,
+        inputFields: tool.inputSchema?.fields ?? [],
+        outputFields: tool.outputSchema?.fields ?? [],
+    };
+}

package/dist/contracts/index.d.ts

@@ -0,0 +1,9 @@
+export { ContractBuilder, definePackage, PackageBuilder } from "./builder";
+export { ContractProviders, ContractProvidersTable, contractProvidersMetaData, contractProvidersSchema, type IContractProviderRecord, } from "./contract-providers.table";
+export { Contracts, ContractsTable, contractsMetaData, contractsSchema, type IContractRecord, } from "./contracts.table";
+export { extractTableShape, extractToolShape, type IExtractableTableDef, type IExtractableToolInstance, setSchemaToFieldsFn, } from "./extract";
+export { PersistentContractRegistry } from "./persistent-registry";
+export { ContractRegistry } from "./registry";
+export type { IAlsoImplementsDeclaration, IConsumedContract, IContractDefinition, IContractObservable, IContractTable, IContractTool, IPackageDefinitionResult, IResolvedContract, IValidationError, IValidationResult, } from "./types";
+export { contractKey } from "./types";
+export { validateAlsoImplements, validateImmutability, validateProviderSatisfiesContract, } from "./validate";

package/dist/contracts/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProviderSatisfiesContract = exports.validateImmutability = exports.validateAlsoImplements = exports.contractKey = exports.ContractRegistry = exports.PersistentContractRegistry = exports.setSchemaToFieldsFn = exports.extractToolShape = exports.extractTableShape = exports.contractsSchema = exports.contractsMetaData = exports.ContractsTable = exports.Contracts = exports.contractProvidersSchema = exports.contractProvidersMetaData = exports.ContractProvidersTable = exports.ContractProviders = exports.PackageBuilder = exports.definePackage = exports.ContractBuilder = void 0;
+var builder_1 = require("./builder");
+Object.defineProperty(exports, "ContractBuilder", { enumerable: true, get: function () { return builder_1.ContractBuilder; } });
+Object.defineProperty(exports, "definePackage", { enumerable: true, get: function () { return builder_1.definePackage; } });
+Object.defineProperty(exports, "PackageBuilder", { enumerable: true, get: function () { return builder_1.PackageBuilder; } });
+var contract_providers_table_1 = require("./contract-providers.table");
+Object.defineProperty(exports, "ContractProviders", { enumerable: true, get: function () { return contract_providers_table_1.ContractProviders; } });
+Object.defineProperty(exports, "ContractProvidersTable", { enumerable: true, get: function () { return contract_providers_table_1.ContractProvidersTable; } });
+Object.defineProperty(exports, "contractProvidersMetaData", { enumerable: true, get: function () { return contract_providers_table_1.contractProvidersMetaData; } });
+Object.defineProperty(exports, "contractProvidersSchema", { enumerable: true, get: function () { return contract_providers_table_1.contractProvidersSchema; } });
+var contracts_table_1 = require("./contracts.table");
+Object.defineProperty(exports, "Contracts", { enumerable: true, get: function () { return contracts_table_1.Contracts; } });
+Object.defineProperty(exports, "ContractsTable", { enumerable: true, get: function () { return contracts_table_1.ContractsTable; } });
+Object.defineProperty(exports, "contractsMetaData", { enumerable: true, get: function () { return contracts_table_1.contractsMetaData; } });
+Object.defineProperty(exports, "contractsSchema", { enumerable: true, get: function () { return contracts_table_1.contractsSchema; } });
+var extract_1 = require("./extract");
+Object.defineProperty(exports, "extractTableShape", { enumerable: true, get: function () { return extract_1.extractTableShape; } });
+Object.defineProperty(exports, "extractToolShape", { enumerable: true, get: function () { return extract_1.extractToolShape; } });
+Object.defineProperty(exports, "setSchemaToFieldsFn", { enumerable: true, get: function () { return extract_1.setSchemaToFieldsFn; } });
+var persistent_registry_1 = require("./persistent-registry");
+Object.defineProperty(exports, "PersistentContractRegistry", { enumerable: true, get: function () { return persistent_registry_1.PersistentContractRegistry; } });
+var registry_1 = require("./registry");
+Object.defineProperty(exports, "ContractRegistry", { enumerable: true, get: function () { return registry_1.ContractRegistry; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "contractKey", { enumerable: true, get: function () { return types_1.contractKey; } });
+var validate_1 = require("./validate");
+Object.defineProperty(exports, "validateAlsoImplements", { enumerable: true, get: function () { return validate_1.validateAlsoImplements; } });
+Object.defineProperty(exports, "validateImmutability", { enumerable: true, get: function () { return validate_1.validateImmutability; } });
+Object.defineProperty(exports, "validateProviderSatisfiesContract", { enumerable: true, get: function () { return validate_1.validateProviderSatisfiesContract; } });

package/dist/contracts/persistent-registry.d.ts

@@ -0,0 +1,32 @@
+import type { DataContext } from "../context/data-context";
+import type { ContractRegistry } from "./registry";
+import type { IContractDefinition } from "./types";
+/**
+ * Bridges the in-memory `ContractRegistry` to SQLite-backed persistence tables.
+ * Handles persisting contract definitions and provider selections, as well as
+ * hydrating a fresh registry from stored data on startup.
+ */
+export declare class PersistentContractRegistry {
+    private registry;
+    private dataContext;
+    constructor(registry: ContractRegistry, dataContext: DataContext);
+    /**
+     * Persist a contract definition and its provider to the database.
+     * If the definition already exists (same contractId), updates it.
+     * Creates or updates the provider record with the given active status.
+     */
+    persist(definition: IContractDefinition, providerPackageId: string, isActive: boolean): Promise<void>;
+    /**
+     * Hydrate the in-memory registry from persisted definitions and providers.
+     * Registers all stored definitions with their respective providers, then
+     * sets the active provider for each contract.
+     */
+    hydrate(): Promise<void>;
+    /**
+     * Switch the active provider for a contract and persist the change.
+     * Returns false if the switch failed in the in-memory registry.
+     */
+    setActiveProvider(contractId: string, version: number, providerPackageId: string): Promise<boolean>;
+    /** Convert a persisted contract record back to an `IContractDefinition`. */
+    private recordToDefinition;
+}