@peers-app/peers-sdk 0.23.4 → 0.23.6

package/dist/package-loader/isolated-runtime.d.ts

@@ -0,0 +1,229 @@
+import type { IContractProviderEndpointRequest } from "../contracts/contract-provider-router";
+import type { IContractCall, IContractProviderEndpoint } from "../contracts/contract-proxy";
+import type { ContractRegistry } from "../contracts/registry";
+import type { PersistentVarScope } from "../data/persistent-vars";
+import type { IField } from "../types/field-type";
+import type { IIsolatedInstallResult, IIsolatedPackageArtifact } from "./isolated-artifact";
+/** Standard table methods exposed through isolated contract-table references. */
+export declare const ISOLATED_CONTRACT_TABLE_OPERATIONS: readonly ["get", "list", "count", "findOne", "save", "insert", "update", "delete"];
+/** Consumer-callable operation on an isolated contract table. */
+export type IsolatedContractTableOperation = (typeof ISOLATED_CONTRACT_TABLE_OPERATIONS)[number];
+/**
+ * Trusted caller identity for an isolated tool call. Never read from guest
+ * payloads — the host derives this from `DataContext` / workflow state.
+ */
+export interface IIsolatedCallPrincipal {
+    userAccessLevel: number;
+    /** Omit for a direct user invocation. */
+    assistantAccessLevel?: number;
+}
+/** Trusted lifecycle metadata supplied when an isolated artifact is installed. */
+export interface IIsolatedPackageInstallOptions {
+    /**
+     * Contract maturity derived from the trusted active PackageVersion.
+     * Guest artifacts cannot select or change this value.
+     */
+    contractLifecycle: "mutable" | "stable";
+    /** Trusted selected PackageVersion record ID. */
+    packageVersionId?: string;
+    /** Trusted semantic version copied from the selected PackageVersion. */
+    packageVersion?: string;
+    /** Trusted release channel copied from the selected PackageVersion. */
+    versionTag?: string;
+}
+/** Options for removing one package from an isolated runtime. */
+export interface IIsolatedPackageUninstallOptions {
+    /**
+     * Keep the shared registry untouched because the host has already activated
+     * a replacement implementation for the same package.
+     */
+    preserveRegistry?: boolean;
+}
+/**
+ * Host-owned supervisor for isolated package providers.
+ *
+ * `peers-sdk` defines the interface only. Electron (or a future PWA host)
+ * registers a factory that constructs an implementation backed by
+ * `peers-isolate` workers. The SDK never depends on Node or SES.
+ */
+export interface IIsolatedPackageRuntime {
+    /**
+     * Register a validated artifact. Provider source is stored, not evaluated
+     * on the host.
+     */
+    install(artifact: IIsolatedPackageArtifact, options?: IIsolatedPackageInstallOptions): Promise<IIsolatedInstallResult>;
+    /**
+     * Atomically replace an installed package version. Implementations stop the
+     * previous worker and preserve the old registration if replacement fails.
+     */
+    replace(artifact: IIsolatedPackageArtifact, options?: IIsolatedPackageInstallOptions): Promise<IIsolatedInstallResult>;
+    /** Stop the package worker (if any) and optionally unregister its contracts. */
+    uninstall(packageId: string, options?: IIsolatedPackageUninstallOptions): Promise<void>;
+    /**
+     * Return a sandbox-backed endpoint when this runtime owns the active
+     * provider for the requested contract. Otherwise `undefined` so the
+     * caller can fall back to in-process system resolvers.
+     */
+    resolveEndpoint(request: IContractProviderEndpointRequest): Promise<IContractProviderEndpoint | undefined>;
+    /**
+     * True when an isolated package installed here declares this contract
+     * version. Registry “active provider” is not required — this runtime can
+     * still serve the installed artifact.
+     */
+    provides(contractId: string, version: number): boolean;
+    /** True when this runtime has installed `packageId`. */
+    isInstalled(packageId: string): boolean;
+    /** Terminate every worker and drop installed state. */
+    dispose(): Promise<void>;
+}
+/**
+ * Identity of one isolated package table. The host binds storage to this
+ * tuple; guest payloads never choose the owning package.
+ */
+export interface IIsolatedPackageTableRef {
+    /** Owning isolated package. Bound by the host, never by guest payload. */
+    packageId: string;
+    /** Package-local table name from the isolated manifest. */
+    tableName: string;
+}
+/**
+ * Host-owned declaration used to register an isolated table schema in a
+ * data context. Guest code never sees this object.
+ */
+export interface IIsolatedPackageTableDeclaration extends IIsolatedPackageTableRef {
+    /** Human-readable table description from the manifest. */
+    description: string;
+    /** Primary-key field name. Must be an `id` field. */
+    primaryKeyName: string;
+    /** Column metadata copied from the isolated artifact. */
+    fields: IField[];
+    /** Schema version for host table-definition updates. */
+    versionNumber?: number;
+}
+/**
+ * Trusted host capability for isolated-package table persistence.
+ *
+ * Implementations own `Table` / SQLite access. The isolated worker never
+ * receives a `DataContext`, table instance, or SQL handle.
+ */
+export interface IIsolatedPackageTableGateway {
+    /**
+     * Bind a declared table to its owning package. Data is retained across
+     * worker and package unload so a later reinstall can resume it.
+     */
+    register(declaration: IIsolatedPackageTableDeclaration): Promise<void>;
+    /**
+     * Validate and bind a package's complete table set as one registration.
+     * Validation failure must not publish any declaration from the batch.
+     */
+    registerBatch(declarations: readonly IIsolatedPackageTableDeclaration[]): Promise<void>;
+    /** Return a copied record, or `undefined` when it does not exist. */
+    get(ref: IIsolatedPackageTableRef, recordId: string): Promise<Record<string, unknown> | undefined>;
+    /** Insert or replace a copied record and return the stored copy. */
+    save(ref: IIsolatedPackageTableRef, record: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Invoke one allowlisted standard operation for a consumer-facing contract table.
+     * The host validates declaration and provider identity before calling the gateway.
+     */
+    call(ref: IIsolatedPackageTableRef, operation: IsolatedContractTableOperation, args: unknown[]): Promise<unknown>;
+}
+/**
+ * Trusted identity of one package-owned pvar.
+ *
+ * `packageId` is bound from the worker session. The guest chooses only a
+ * package-local logical name and one standard pvar scope.
+ */
+export interface IIsolatedPackagePersistentVarRef {
+    /** Owning isolated package. Bound by the host, never by guest payload. */
+    packageId: string;
+    /** Guest-visible package-local name before host prefixing. */
+    name: string;
+    /** Existing Peers storage/synchronization scope. */
+    scope: PersistentVarScope;
+}
+/**
+ * Trusted host capability for isolated package-owned pvars.
+ *
+ * Implementations derive physical names from trusted package and route
+ * identity. No operation can opt out of package prefixing.
+ */
+export interface IIsolatedPackagePersistentVarGateway {
+    /** Return a copied JSON value, or `undefined` when unset. */
+    get(ref: IIsolatedPackagePersistentVarRef): Promise<unknown>;
+    /** Persist a copied JSON value and return the stored copy. */
+    set(ref: IIsolatedPackagePersistentVarRef, value: unknown): Promise<unknown>;
+    /**
+     * Subscribe to canonical value changes, including updates applied by device sync.
+     *
+     * @returns A callback that detaches the host-side subscription.
+     */
+    subscribe(ref: IIsolatedPackagePersistentVarRef, handler: (value: unknown) => void): Promise<() => void>;
+}
+/**
+ * Trusted request from an isolated runtime for a host/resolver-backed provider.
+ *
+ * Both package identities are selected from host runtime state. Guest call
+ * payloads cannot choose either identity.
+ */
+export interface IIsolatedContractProviderEndpointRequest extends IContractProviderEndpointRequest {
+    /** Installed isolated package making the consumed-contract call. */
+    consumerPackageId: string;
+    /** Registry-selected provider package. */
+    providerPackageId: string;
+    /** Optional deadline the gateway should enforce for provider setup/calls. */
+    timeoutMs?: number;
+}
+/**
+ * Host gateway that lets isolated consumers reach selected non-isolated
+ * providers through the same endpoint abstraction used by local and remote routers.
+ */
+export interface IIsolatedContractProviderGateway {
+    /**
+     * Resolve the selected resolver-backed provider, including subscription
+     * support through the request's notification sink.
+     */
+    resolveEndpoint(request: IIsolatedContractProviderEndpointRequest): Promise<IContractProviderEndpoint | undefined>;
+}
+/** Options passed to a registered {@link IsolatedPackageRuntimeFactory}. */
+export interface IIsolatedPackageRuntimeFactoryOptions {
+    /** Shared per-data-context contract registry from {@link PackageLoader}. */
+    registry: ContractRegistry;
+    /** Owning data-context id (personal user id or group id). */
+    dataContextId: string;
+    /**
+     * Host-owned table capability for this data context. Required when an
+     * isolated package declares tables.
+     */
+    tableGateway?: IIsolatedPackageTableGateway;
+    /** Host-owned package-prefixed pvar capability for this data context. */
+    persistentVarGateway?: IIsolatedPackagePersistentVarGateway;
+    /** Gateway for consumed calls to selected host/system providers. */
+    providerGateway?: IIsolatedContractProviderGateway;
+}
+/**
+ * Host callback that builds an {@link IIsolatedPackageRuntime} for one
+ * data context. Registered once at process startup, before any
+ * `DataContext` / `PackageLoader` is constructed.
+ */
+export type IsolatedPackageRuntimeFactory = (options: IIsolatedPackageRuntimeFactoryOptions) => IIsolatedPackageRuntime;
+/**
+ * Optional hook used by a concrete runtime to derive the host principal for
+ * a renderer- or CLI-originated call.
+ */
+export type IsolatedHostPrincipalResolver = (request: IContractProviderEndpointRequest, call: IContractCall) => IIsolatedCallPrincipal | Promise<IIsolatedCallPrincipal>;
+/**
+ * Register the process-wide isolated package runtime factory.
+ *
+ * Call from the Electron main process (or a test) before
+ * `initializePeerDevice` constructs any `DataContext`. Pass `undefined` to
+ * clear the factory.
+ *
+ * @param factory - Host factory, or `undefined` to unregister.
+ */
+export declare function setIsolatedPackageRuntimeFactory(factory: IsolatedPackageRuntimeFactory | undefined): void;
+/**
+ * Return the registered isolated package runtime factory, if any.
+ *
+ * @returns The process-wide factory, or `undefined` when isolation is not wired.
+ */
+export declare function getIsolatedPackageRuntimeFactory(): IsolatedPackageRuntimeFactory | undefined;

package/dist/package-loader/isolated-runtime.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISOLATED_CONTRACT_TABLE_OPERATIONS = void 0;
+exports.setIsolatedPackageRuntimeFactory = setIsolatedPackageRuntimeFactory;
+exports.getIsolatedPackageRuntimeFactory = getIsolatedPackageRuntimeFactory;
+/** Standard table methods exposed through isolated contract-table references. */
+exports.ISOLATED_CONTRACT_TABLE_OPERATIONS = [
+    "get",
+    "list",
+    "count",
+    "findOne",
+    "save",
+    "insert",
+    "update",
+    "delete",
+];
+let isolatedRuntimeFactory;
+/**
+ * Register the process-wide isolated package runtime factory.
+ *
+ * Call from the Electron main process (or a test) before
+ * `initializePeerDevice` constructs any `DataContext`. Pass `undefined` to
+ * clear the factory.
+ *
+ * @param factory - Host factory, or `undefined` to unregister.
+ */
+function setIsolatedPackageRuntimeFactory(factory) {
+    isolatedRuntimeFactory = factory;
+}
+/**
+ * Return the registered isolated package runtime factory, if any.
+ *
+ * @returns The process-wide factory, or `undefined` when isolation is not wired.
+ */
+function getIsolatedPackageRuntimeFactory() {
+    return isolatedRuntimeFactory;
+}

package/dist/package-loader/isolated-table-gateway.d.ts

@@ -0,0 +1,16 @@
+import type { DataContext } from "../context/data-context";
+import type { IIsolatedPackageTableGateway } from "./isolated-runtime";
+/**
+ * In-memory isolated table gateway for tests. Bindings and rows survive
+ * `register` of the same owner so unload/reinstall can resume persisted data.
+ *
+ * @returns A host-neutral gateway that never touches SQLite.
+ */
+export declare function createMemoryIsolatedPackageTableGateway(): IIsolatedPackageTableGateway;
+/**
+ * Create a per-data-context gateway that registers isolated table schemas in
+ * `TableContainer` and performs host-owned `get` / `save`.
+ *
+ * @param dataContext - Owning personal or group data context.
+ */
+export declare function createIsolatedPackageTableGateway(dataContext: DataContext): IIsolatedPackageTableGateway;

package/dist/package-loader/isolated-table-gateway.js

@@ -0,0 +1,375 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemoryIsolatedPackageTableGateway = createMemoryIsolatedPackageTableGateway;
+exports.createIsolatedPackageTableGateway = createIsolatedPackageTableGateway;
+const table_container_1 = require("../data/orm/table-container");
+const types_1 = require("../data/orm/types");
+const package_table_identity_1 = require("../data/package-table-identity");
+const table_definitions_table_1 = require("../data/table-definitions-table");
+const utils_1 = require("../utils");
+const isolated_value_1 = require("./isolated-value");
+function tableKey(ref) {
+    return `${ref.packageId}:${ref.tableName}`;
+}
+function versionNumber(declaration) {
+    return declaration.versionNumber ?? 1;
+}
+function validateDeclaration(declaration) {
+    (0, package_table_identity_1.packageScopedTableId)(declaration.packageId, declaration.tableName);
+    (0, package_table_identity_1.validateIsolatedSqlIdentifier)(declaration.primaryKeyName, "Isolated table primary key");
+    if (!Number.isInteger(versionNumber(declaration)) || versionNumber(declaration) < 1) {
+        throw new Error("Isolated table versionNumber must be a positive integer");
+    }
+    if (!Array.isArray(declaration.fields) || declaration.fields.length === 0) {
+        throw new Error("Isolated table fields must not be empty");
+    }
+    const fieldNames = new Set();
+    for (const field of declaration.fields) {
+        (0, package_table_identity_1.validateIsolatedSqlIdentifier)(field.name, "Isolated table field name");
+        if (fieldNames.has(field.name)) {
+            throw new Error(`Isolated table field "${field.name}" is declared more than once`);
+        }
+        fieldNames.add(field.name);
+    }
+    const primaryKey = declaration.fields.find((field) => field.name === declaration.primaryKeyName);
+    if (!primaryKey) {
+        throw new Error(`Isolated table primary key "${declaration.primaryKeyName}" is not present in fields`);
+    }
+    if (primaryKey.type !== "id") {
+        throw new Error("Isolated table primary key must refer to a field of type id");
+    }
+    return {
+        ...declaration,
+        fields: declaration.fields.map((field) => ({ ...field })),
+        versionNumber: versionNumber(declaration),
+    };
+}
+function toMetaData(rawDeclaration) {
+    const declaration = validateDeclaration(rawDeclaration);
+    return {
+        tableId: (0, package_table_identity_1.packageScopedTableId)(declaration.packageId, declaration.tableName),
+        packageId: declaration.packageId,
+        name: declaration.tableName,
+        description: declaration.description,
+        primaryKeyName: declaration.primaryKeyName,
+        fields: declaration.fields,
+        versionNumber: versionNumber(declaration),
+    };
+}
+function normalizedMetaData(metaData) {
+    return {
+        ...metaData,
+        fields: metaData.fields.map(({ defaultValue: _defaultValue, ...field }) => field),
+    };
+}
+function sameDefinition(existing, incoming) {
+    return ((0, utils_1.simpleObjectHash)(normalizedMetaData(existing)) ===
+        (0, utils_1.simpleObjectHash)(normalizedMetaData(incoming)));
+}
+function requiredPackageId(metaData) {
+    if (!metaData.packageId) {
+        throw new Error(`Isolated table "${metaData.name}" is missing package identity`);
+    }
+    return metaData.packageId;
+}
+function requiredTableId(metaData) {
+    if (!metaData.tableId) {
+        throw new Error(`Isolated table "${metaData.name}" is missing table identity`);
+    }
+    return metaData.tableId;
+}
+function selectNewerDefinition(existing, incoming) {
+    const existingVersion = existing.versionNumber ?? 0;
+    const incomingVersion = incoming.versionNumber ?? 0;
+    if (existingVersion === incomingVersion && !sameDefinition(existing, incoming)) {
+        throw new Error(`Isolated table "${(0, package_table_identity_1.packageScopedTableName)(requiredPackageId(incoming), incoming.name)}" has different schemas at version ${incomingVersion}`);
+    }
+    const decision = (0, table_container_1.checkVersionedUpdate)(existingVersion, incomingVersion, existing, incoming);
+    if (decision === "update") {
+        return incoming;
+    }
+    if (existingVersion > incomingVersion) {
+        throw new Error(`Refusing isolated table schema downgrade from version ${existingVersion} to ${incomingVersion}`);
+    }
+    return existing;
+}
+function declarationFromMetaData(metaData) {
+    if (!metaData.packageId) {
+        throw new Error("Stored isolated table definition is missing package identity");
+    }
+    return validateDeclaration({
+        packageId: metaData.packageId,
+        tableName: metaData.name,
+        description: metaData.description,
+        primaryKeyName: metaData.primaryKeyName,
+        fields: metaData.fields,
+        versionNumber: metaData.versionNumber,
+    });
+}
+function metaDataFromStoredDefinition(record, incoming) {
+    const stored = record.metaData;
+    const declaration = declarationFromMetaData({
+        ...stored,
+        versionNumber: record.versionNumber,
+    });
+    const metaData = toMetaData(declaration);
+    const expectedTableId = incoming.tableId;
+    const expectedName = (0, package_table_identity_1.packageScopedTableName)(requiredPackageId(incoming), incoming.name);
+    if (record.tableId !== expectedTableId ||
+        metaData.tableId !== expectedTableId ||
+        metaData.packageId !== incoming.packageId ||
+        metaData.name !== incoming.name ||
+        record.name !== expectedName) {
+        throw new Error(`Stored isolated table definition "${record.name}" has an invalid identity`);
+    }
+    return metaData;
+}
+function registerDeclaration(declarations, byTableId, rawDeclaration) {
+    const declaration = validateDeclaration(rawDeclaration);
+    const key = tableKey(declaration);
+    const tableId = (0, package_table_identity_1.packageScopedTableId)(declaration.packageId, declaration.tableName);
+    const existingKey = byTableId.get(tableId);
+    if (existingKey && existingKey !== key) {
+        const owner = declarations.get(existingKey);
+        throw new Error(`Isolated table ${declaration.tableName} collides with package ${owner?.packageId ?? "unknown"}`);
+    }
+    const current = declarations.get(key);
+    if (current) {
+        const selected = selectNewerDefinition(toMetaData(current), toMetaData(declaration));
+        if (selected.versionNumber === versionNumber(current)) {
+            return;
+        }
+    }
+    declarations.set(key, declaration);
+    byTableId.set(tableId, key);
+}
+function asRecord(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be a plain object`);
+    }
+    return { ...value };
+}
+function copyTableResult(value) {
+    const normalizeRecord = (item) => Object.prototype.toString.call(item) === "[object Object]"
+        ? asRecord(item, "Isolated table result")
+        : item;
+    const normalized = Array.isArray(value) ? value.map(normalizeRecord) : normalizeRecord(value);
+    return (0, isolated_value_1.copyIsolatedValue)(normalized);
+}
+function matchesFilter(row, filter = {}) {
+    return Object.entries(filter).every(([name, value]) => row[name] === value);
+}
+/**
+ * In-memory isolated table gateway for tests. Bindings and rows survive
+ * `register` of the same owner so unload/reinstall can resume persisted data.
+ *
+ * @returns A host-neutral gateway that never touches SQLite.
+ */
+function createMemoryIsolatedPackageTableGateway() {
+    const declarations = new Map();
+    const byTableId = new Map();
+    const rows = new Map();
+    const registerBatch = async (batch) => {
+        const candidateDeclarations = new Map(declarations);
+        const candidateByTableId = new Map(byTableId);
+        for (const declaration of batch) {
+            registerDeclaration(candidateDeclarations, candidateByTableId, declaration);
+        }
+        declarations.clear();
+        byTableId.clear();
+        for (const [key, declaration] of candidateDeclarations) {
+            declarations.set(key, declaration);
+            if (!rows.has(key)) {
+                rows.set(key, new Map());
+            }
+        }
+        for (const [tableId, key] of candidateByTableId) {
+            byTableId.set(tableId, key);
+        }
+    };
+    return {
+        async register(declaration) {
+            await registerBatch([declaration]);
+        },
+        registerBatch,
+        async get(ref, recordId) {
+            const key = tableKey(ref);
+            if (!declarations.has(key)) {
+                throw new Error(`Undeclared isolated table ${ref.tableName}`);
+            }
+            return (0, isolated_value_1.copyIsolatedValue)(rows.get(key)?.get(recordId));
+        },
+        async save(ref, record) {
+            const key = tableKey(ref);
+            const declaration = declarations.get(key);
+            if (!declaration) {
+                throw new Error(`Undeclared isolated table ${ref.tableName}`);
+            }
+            const stored = asRecord((0, isolated_value_1.copyIsolatedValue)(record), "Isolated table record");
+            const recordId = stored[declaration.primaryKeyName];
+            if (typeof recordId !== "string" || recordId.trim() === "") {
+                throw new Error(`Isolated table record is missing primary key "${declaration.primaryKeyName}"`);
+            }
+            const tableRows = rows.get(key) ?? new Map();
+            tableRows.set(recordId, stored);
+            rows.set(key, tableRows);
+            return (0, isolated_value_1.copyIsolatedValue)(stored);
+        },
+        async call(ref, operation, args) {
+            const key = tableKey(ref);
+            const declaration = declarations.get(key);
+            const tableRows = rows.get(key);
+            if (!declaration || !tableRows) {
+                throw new Error(`Undeclared isolated table ${ref.tableName}`);
+            }
+            const recordId = args[0];
+            switch (operation) {
+                case "get":
+                    return typeof recordId === "string"
+                        ? (0, isolated_value_1.copyIsolatedValue)(tableRows.get(recordId))
+                        : undefined;
+                case "list": {
+                    const filter = (args[0] ?? {});
+                    const opts = (args[1] ?? {});
+                    const matching = [...tableRows.values()].filter((row) => matchesFilter(row, filter));
+                    const pageSize = opts.pageSize ?? matching.length;
+                    const start = (opts.page ?? 0) * pageSize;
+                    return (0, isolated_value_1.copyIsolatedValue)(matching.slice(start, start + pageSize));
+                }
+                case "count": {
+                    const filter = (args[0] ?? {});
+                    return [...tableRows.values()].filter((row) => matchesFilter(row, filter)).length;
+                }
+                case "findOne": {
+                    const filter = (args[0] ?? {});
+                    return (0, isolated_value_1.copyIsolatedValue)([...tableRows.values()].find((row) => matchesFilter(row, filter)));
+                }
+                case "save":
+                case "insert":
+                case "update": {
+                    const stored = asRecord(args[0], "Isolated table record");
+                    const id = stored[declaration.primaryKeyName];
+                    if (typeof id !== "string" || id.trim() === "") {
+                        throw new Error(`Isolated table record is missing primary key "${declaration.primaryKeyName}"`);
+                    }
+                    if (operation === "insert" && tableRows.has(id)) {
+                        throw new Error(`Record ${id} already exists`);
+                    }
+                    if (operation === "update" && !tableRows.has(id)) {
+                        throw new Error(`Record ${id} does not exist`);
+                    }
+                    tableRows.set(id, stored);
+                    return (0, isolated_value_1.copyIsolatedValue)(stored);
+                }
+                case "delete": {
+                    const id = typeof recordId === "string"
+                        ? recordId
+                        : asRecord(recordId, "Isolated table record")[declaration.primaryKeyName];
+                    if (typeof id !== "string") {
+                        throw new Error(`Isolated table delete requires "${declaration.primaryKeyName}"`);
+                    }
+                    tableRows.delete(id);
+                    return undefined;
+                }
+            }
+        },
+    };
+}
+/**
+ * Create a per-data-context gateway that registers isolated table schemas in
+ * `TableContainer` and performs host-owned `get` / `save`.
+ *
+ * @param dataContext - Owning personal or group data context.
+ */
+function createIsolatedPackageTableGateway(dataContext) {
+    const declarations = new Map();
+    const byTableId = new Map();
+    let registrationQueue = Promise.resolve();
+    const resolve = (ref) => {
+        const key = tableKey(ref);
+        const declaration = declarations.get(key);
+        if (!declaration) {
+            throw new Error(`Undeclared isolated table ${ref.tableName}`);
+        }
+        return declaration;
+    };
+    const prepareTable = async (declaration) => {
+        const incomingMetaData = toMetaData(declaration);
+        const existingRecord = await (0, table_definitions_table_1.TableDefinitions)(dataContext).get(requiredTableId(incomingMetaData));
+        const activeMetaData = existingRecord
+            ? selectNewerDefinition(metaDataFromStoredDefinition(existingRecord, incomingMetaData), incomingMetaData)
+            : incomingMetaData;
+        return { activeMetaData, existingRecord, incomingMetaData };
+    };
+    const activateTable = async ({ activeMetaData, existingRecord, incomingMetaData, }) => {
+        if (!existingRecord || activeMetaData === incomingMetaData) {
+            await (0, table_definitions_table_1.TableDefinitions)(dataContext).save({
+                tableId: requiredTableId(activeMetaData),
+                name: (0, package_table_identity_1.packageScopedTableName)(requiredPackageId(activeMetaData), activeMetaData.name),
+                metaData: activeMetaData,
+                versionNumber: activeMetaData.versionNumber ?? 0,
+            });
+        }
+        dataContext.tableContainer.registerTableDefinition({
+            metaData: activeMetaData,
+            schema: (0, types_1.fieldsToSchema)(activeMetaData.fields),
+        }, { overwrite: true });
+        return dataContext.tableContainer.getTable(activeMetaData);
+    };
+    const ensureTable = async (declaration) => activateTable(await prepareTable(declaration));
+    const registerBatch = (batch) => {
+        const registration = registrationQueue.then(async () => {
+            const candidateDeclarations = new Map(declarations);
+            const candidateByTableId = new Map(byTableId);
+            for (const declaration of batch) {
+                registerDeclaration(candidateDeclarations, candidateByTableId, declaration);
+            }
+            const batchKeys = new Set(batch.map(tableKey));
+            const plans = [];
+            for (const key of batchKeys) {
+                const declaration = candidateDeclarations.get(key);
+                if (declaration) {
+                    plans.push(await prepareTable(declaration));
+                }
+            }
+            for (const plan of plans) {
+                await activateTable(plan);
+            }
+            declarations.clear();
+            byTableId.clear();
+            for (const [key, candidate] of candidateDeclarations) {
+                declarations.set(key, candidate);
+            }
+            for (const [tableId, key] of candidateByTableId) {
+                byTableId.set(tableId, key);
+            }
+        });
+        registrationQueue = registration.then(() => undefined, () => undefined);
+        return registration;
+    };
+    return {
+        register(declaration) {
+            return registerBatch([declaration]);
+        },
+        registerBatch,
+        async get(ref, recordId) {
+            await registrationQueue;
+            const table = await ensureTable(resolve(ref));
+            const row = await table.get(recordId);
+            return row ? copyTableResult(row) : undefined;
+        },
+        async save(ref, record) {
+            await registrationQueue;
+            const table = await ensureTable(resolve(ref));
+            const stored = await table.save(asRecord(record, "Isolated table record"));
+            return copyTableResult(stored);
+        },
+        async call(ref, operation, args) {
+            await registrationQueue;
+            const table = await ensureTable(resolve(ref));
+            const method = table[operation];
+            const result = await method.apply(table, (0, isolated_value_1.copyIsolatedValue)(args));
+            return copyTableResult(result);
+        },
+    };
+}

package/dist/package-loader/isolated-table-gateway.test.d.ts

@@ -0,0 +1 @@
+export {};