@peers-app/peers-sdk 0.26.6 → 0.27.0

package/dist/package-loader/isolated-artifact.test.js

@@ -106,33 +106,27 @@ describe("isolated package artifact", () => {
         const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact);
         expect(manifest.tables).toEqual([]);
     });
-    test("validates private action aliases without extending the public contract", () => {
-        const { artifact, contractId } = makeArtifact();
+    test("keeps a private tool out of the public contract definition", () => {
+        const { artifact } = makeArtifact();
         artifact.manifest.provides[0].tools.push({
             name: "private-write",
             usageDescription: "Internal write",
             private: true,
             suggestedAccessLevel: access_level_1.AccessLevel.Writer,
         });
-        artifact.manifest.actionAliases = [
-            {
-                name: "write",
-                target: { contractId, version: 1, toolName: "private-write" },
-            },
-        ];
         const validated = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact);
         expect((0, isolated_artifact_1.isolatedContractToDefinition)(validated.provides[0], []).tools.map((tool) => tool.name)).toEqual(["greet"]);
-        expect((0, isolated_artifact_1.parseIsolatedPackageArtifact)((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact)).manifest
-            .actionAliases).toEqual(artifact.manifest.actionAliases);
-        artifact.manifest.actionAliases.push(artifact.manifest.actionAliases[0]);
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow("duplicate action alias");
-        artifact.manifest.actionAliases = [
-            {
-                name: "write",
-                target: { contractId, version: 1, toolName: "missing" },
-            },
+    });
+    test("accepts an older manifest's retired action aliases and ignores them", () => {
+        const { artifact, contractId } = makeArtifact();
+        const old = artifact.manifest;
+        old.actionAliases = [
+            { name: "write", target: { contractId, version: 1, toolName: "missing" } },
         ];
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow("no registered target");
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).not.toThrow();
+        expect(() => (0, isolated_artifact_1.parseIsolatedPackageArtifact)((0, isolated_artifact_1.serializeIsolatedPackageArtifact)(artifact))).not.toThrow();
+        old.actionAliases = "not even an array";
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).not.toThrow();
     });
     test("accepts a package-private table without adding it to the contract definition", () => {
         const { artifact } = makeArtifact();
@@ -201,6 +195,55 @@ describe("isolated package artifact", () => {
             },
         ]);
     });
+    test("accepts local-only tables and keeps the flag out of the contract shape", () => {
+        const { artifact } = makeArtifact();
+        const fields = [
+            { name: "stateId", type: field_type_1.FieldType.id },
+            { name: "count", type: field_type_1.FieldType.number },
+        ];
+        artifact.manifest.tables = [
+            { name: "DeviceState", primaryKeyName: "stateId", fields, localOnly: true },
+            { name: "SharedState", primaryKeyName: "stateId", fields, localOnly: false },
+        ];
+        artifact.manifest.provides[0].tables = [{ name: "DeviceState" }, { name: "SharedState" }];
+        const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact);
+        const definition = (0, isolated_artifact_1.isolatedContractToDefinition)(manifest.provides[0], manifest.tables ?? []);
+        expect(manifest.tables?.[0].localOnly).toBe(true);
+        // Sync policy belongs to the provider's table, not to the contract consumers depend on.
+        expect(definition.tables.map((table) => table.name)).toEqual(["DeviceState", "SharedState"]);
+        for (const table of definition.tables)
+            expect(table).not.toHaveProperty("localOnly");
+    });
+    test("rejects a localOnly flag that isn't a boolean", () => {
+        const { artifact } = makeArtifact();
+        artifact.manifest.tables = [
+            {
+                name: "State",
+                primaryKeyName: "stateId",
+                fields: [{ name: "stateId", type: field_type_1.FieldType.id }],
+                localOnly: "yes",
+            },
+        ];
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/localOnly must be a boolean/);
+    });
+    test("accepts guestApi 2 and 3 and rejects other values", () => {
+        for (const guestApi of [2, 3]) {
+            const { artifact } = makeArtifact();
+            artifact.manifest.guestApi = guestApi;
+            expect((0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact).guestApi).toBe(guestApi);
+        }
+        for (const guestApi of [1, "2", 4]) {
+            const { artifact: other } = makeArtifact();
+            other.manifest.guestApi = guestApi;
+            expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(other)).toThrow(/guestApi must be 2 or 3/);
+        }
+    });
+    test.each([true, false, "jobs", null])("rejects the removed serial option (%s)", (serial) => {
+        const { artifact } = makeArtifact();
+        const tool = artifact.manifest.provides[0].tools[0];
+        tool.serial = serial;
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/\.serial is not supported/);
+    });
     test("rejects malformed isolated tables", () => {
         const { artifact } = makeArtifact();
         artifact.manifest.tables = [
@@ -307,6 +350,121 @@ describe("isolated package artifact", () => {
             { contractId: targetContractId, version: { from: 2, to: 4 } },
         ]);
     });
+    test.each([
+        "range",
+        "id",
+        "version",
+        "shape",
+    ])("rejects a carried target with a mismatched %s", (problem) => {
+        const { artifact } = makeArtifact();
+        const definition = (0, isolated_artifact_1.isolatedContractToDefinition)(artifact.manifest.provides[0], []);
+        definition.contractId = (0, utils_1.newid)();
+        const target = { contractId: definition.contractId, version: 1, definition };
+        artifact.manifest.provides[0].alsoImplements = [target];
+        if (problem === "range")
+            Object.assign(target, { version: { from: 1, to: 2 } });
+        if (problem === "id")
+            definition.contractId = (0, utils_1.newid)();
+        if (problem === "version")
+            definition.version = 2;
+        if (problem === "shape")
+            Object.assign(definition, { tools: null });
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/definition/);
+    });
+    test.each([
+        false,
+        true,
+    ])("rejects a single alias to an explicitly provided version (carried: %p)", (carried) => {
+        const { artifact, contractId } = makeArtifact();
+        const newer = structuredClone(artifact.manifest.provides[0]);
+        newer.version = 3;
+        newer.alsoImplements = [
+            {
+                contractId,
+                version: 1,
+                ...(carried
+                    ? { definition: (0, isolated_artifact_1.isolatedContractToDefinition)(artifact.manifest.provides[0], []) }
+                    : {}),
+            },
+        ];
+        artifact.manifest.provides.push(newer);
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/provides explicitly/);
+    });
+    test("keeps legacy ranges that overlap explicitly provided versions", () => {
+        const { artifact, contractId } = makeArtifact();
+        const newer = structuredClone(artifact.manifest.provides[0]);
+        newer.version = 3;
+        newer.alsoImplements = [{ contractId, version: { from: 1, to: 2 } }];
+        artifact.manifest.provides.push(newer);
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).not.toThrow();
+    });
+    test.each([
+        "table",
+        "input",
+        "output",
+        "event",
+        "observable",
+    ])("bounds the nesting of a carried %s field", (kind) => {
+        const { artifact } = makeArtifact();
+        const definition = (0, isolated_artifact_1.isolatedContractToDefinition)(artifact.manifest.provides[0], []);
+        definition.contractId = (0, utils_1.newid)();
+        let field = { name: "leaf", type: field_type_1.FieldType.string };
+        for (let depth = 0; depth < isolated_artifact_1.ISOLATED_MAX_FIELD_DEPTH; depth++) {
+            field = { name: "nested", type: field_type_1.FieldType.object, fields: [field] };
+        }
+        if (kind === "input")
+            definition.tools[0].inputFields = [field];
+        if (kind === "output")
+            definition.tools[0].outputFields = [field];
+        if (kind === "table")
+            definition.tables = [
+                { name: "Rows", description: "", primaryKeyName: "id", fields: [field] },
+            ];
+        if (kind === "event")
+            definition.events = [{ name: "changed", description: "", payloadFields: [field] }];
+        if (kind === "observable") {
+            const { name: _name, ...value } = field;
+            definition.observables = [
+                { name: "value", description: "", writable: false, valueType: field_type_1.FieldType.object, value },
+            ];
+        }
+        artifact.manifest.provides[0].alsoImplements = [
+            { contractId: definition.contractId, version: 1, definition },
+        ];
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/nests more than 16 levels/);
+    });
+    test("validates exposes: other provided contracts, kept out of the definition", () => {
+        const { artifact, contractId } = makeArtifact();
+        const hubContractId = (0, utils_1.newid)();
+        artifact.manifest.provides.push({
+            contractId: hubContractId,
+            version: 2,
+            name: "Hub",
+            tools: [],
+            events: [{ name: "alert", description: "Attention." }],
+            exposes: [{ contractId, version: 1 }],
+        });
+        const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(JSON.parse(JSON.stringify(artifact)));
+        expect(manifest.provides[1].exposes).toEqual([{ contractId, version: 1 }]);
+        expect(manifest.provides[0]).not.toHaveProperty("exposes");
+        const definition = (0, isolated_artifact_1.isolatedContractToDefinition)(manifest.provides[1], manifest.tables ?? []);
+        expect(definition).not.toHaveProperty("exposes");
+        const withExposes = (exposes) => {
+            const copy = JSON.parse(JSON.stringify(artifact));
+            copy.manifest.provides[1].exposes = exposes;
+            return () => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(copy);
+        };
+        expect(withExposes({ contractId, version: 1 })).toThrow("provides[1].exposes must be an array");
+        expect(withExposes([{ contractId, version: 1, toolName: "greet" }])).toThrow(/provides\[1\]\.exposes\[0\]/);
+        expect(withExposes([{ contractId: "short", version: 1 }])).toThrow(/exposes\[0\]\.contractId/);
+        expect(withExposes([{ contractId, version: 0 }])).toThrow(/exposes\[0\]\.version/);
+        expect(withExposes([{ contractId: hubContractId, version: 2 }])).toThrow("a contract can't expose itself");
+        expect(withExposes([
+            { contractId, version: 1 },
+            { contractId, version: 1 },
+        ])).toThrow("is exposed twice");
+        expect(withExposes([{ contractId, version: 2 }])).toThrow(`provides[1] exposes ${contractId}@2, which the package doesn't provide`);
+    });
     test("maps declared events to the public contract definition", () => {
         const { artifact } = makeArtifact();
         artifact.manifest.provides[0].events = [
@@ -357,6 +515,103 @@ describe("isolated package artifact", () => {
         ];
         expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/type must be a FieldType/);
     });
+    test("checks nested fields and enum values, and carries them into the contract", () => {
+        const { artifact } = makeArtifact();
+        const tool = artifact.manifest.provides[0].tools[0];
+        tool.inputFields = [
+            { name: "mode", type: field_type_1.FieldType.string, enumValues: ["on", "off"], optional: true },
+            {
+                name: "items",
+                type: field_type_1.FieldType.object,
+                isArray: true,
+                fields: [
+                    { name: "label", type: field_type_1.FieldType.string },
+                    { name: "size", type: field_type_1.FieldType.any, enumValues: [1, "large", true] },
+                ],
+            },
+        ];
+        artifact.manifest.provides[0].observables = [
+            {
+                name: "state",
+                description: "The state.",
+                valueType: field_type_1.FieldType.any,
+                value: {
+                    type: field_type_1.FieldType.object,
+                    optional: true,
+                    fields: [{ name: "on", type: field_type_1.FieldType.boolean }],
+                },
+                writable: false,
+            },
+        ];
+        artifact.manifest.guestApi = 3;
+        const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact, { strict: true });
+        const definition = (0, isolated_artifact_1.isolatedContractToDefinition)(manifest.provides[0], []);
+        expect(definition.tools[0].inputFields).toEqual(tool.inputFields);
+        expect(definition.observables[0].value).toEqual({
+            type: field_type_1.FieldType.object,
+            optional: true,
+            fields: [{ name: "on", type: field_type_1.FieldType.boolean }],
+        });
+    });
+    test.each([
+        [{ name: "x", type: field_type_1.FieldType.string, enumValues: [] }, /enumValues must be a non-empty array/],
+        [{ name: "x", type: field_type_1.FieldType.string, enumValues: ["a", 1] }, /enumValues must all be string/],
+        [
+            { name: "x", type: field_type_1.FieldType.number, enumValues: [Number.NaN] },
+            /enumValues must all be number/,
+        ],
+        [{ name: "x", type: field_type_1.FieldType.id, enumValues: ["a"] }, /enumValues must all be id/],
+        [{ name: "x", type: field_type_1.FieldType.string, fields: [] }, /fields is only allowed on object fields/],
+        [
+            { name: "x", type: field_type_1.FieldType.object, fields: [{ name: "", type: field_type_1.FieldType.string }] },
+            /fields\[0\]\.name is required/,
+        ],
+        [{ name: "x", type: field_type_1.FieldType.object, fields: {} }, /fields must be an array/],
+    ])("rejects a malformed field %#", (field, message) => {
+        const { artifact } = makeArtifact();
+        artifact.manifest.provides[0].tools[0].inputFields = [field];
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(message);
+    });
+    test("refuses fields nested deeper than the limit", () => {
+        const nest = (levels) => levels === 1
+            ? { name: "leaf", type: field_type_1.FieldType.string }
+            : { name: `level${levels}`, type: field_type_1.FieldType.object, fields: [nest(levels - 1)] };
+        const { artifact } = makeArtifact();
+        artifact.manifest.provides[0].tools[0].inputFields = [nest(isolated_artifact_1.ISOLATED_MAX_FIELD_DEPTH)];
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(structuredClone(artifact))).not.toThrow();
+        artifact.manifest.provides[0].tools[0].inputFields = [
+            nest(isolated_artifact_1.ISOLATED_MAX_FIELD_DEPTH + 1),
+        ];
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/nests more than 16 levels/);
+    });
+    test("a host drops field keys it doesn't know; the build refuses them", () => {
+        const { artifact } = makeArtifact();
+        const withUnknown = () => {
+            const copy = structuredClone(artifact);
+            copy.manifest.provides[0].tools[0].inputFields = [
+                {
+                    name: "mode",
+                    type: field_type_1.FieldType.object,
+                    format: "future",
+                    fields: [
+                        // As a manifest arrives: JSON.parse makes "__proto__" an own key.
+                        JSON.parse('{"name":"on","type":"boolean","__proto__":{"polluted":true}}'),
+                    ],
+                },
+            ];
+            return copy;
+        };
+        const manifest = (0, isolated_artifact_1.validateIsolatedPackageArtifact)(withUnknown());
+        expect(manifest.provides[0].tools[0].inputFields).toEqual([
+            { name: "mode", type: field_type_1.FieldType.object, fields: [{ name: "on", type: field_type_1.FieldType.boolean }] },
+        ]);
+        expect({}.polluted).toBeUndefined();
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(withUnknown(), { strict: true })).toThrow(/inputFields\[0\]\.format is not supported/);
+        // Other manifest objects still refuse unknown keys: they carry policy, not descriptions.
+        const tool = artifact.manifest.provides[0].tools[0];
+        tool.cachePolicy = "forever";
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/cachePolicy is not supported/);
+    });
     test("rejects unsupported contract features instead of dropping them", () => {
         const { artifact } = makeArtifact();
         artifact.manifest.provides[0].streams = [];
@@ -381,12 +636,30 @@ describe("isolated package artifact", () => {
             },
         ];
         expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/must match.*number/);
-        artifact.manifest.provides[0].observables[0].valueType = field_type_1.FieldType.object;
-        artifact.manifest.provides[0].observables[0].persistentVar.defaultValue = {
-            callback: () => undefined,
+        const [observable] = artifact.manifest.provides[0].observables;
+        observable.valueType = field_type_1.FieldType.object;
+        observable.persistentVar = {
+            scope: "device",
+            name: "sharedCount",
+            defaultValue: { callback: () => undefined },
         };
         expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/JSON-compatible/);
     });
+    test("an observable without a persistentVar is held by a guest API 2 worker", () => {
+        const { artifact } = makeArtifact();
+        const status = {
+            name: "status",
+            description: "Current status",
+            valueType: field_type_1.FieldType.string,
+            writable: false,
+        };
+        artifact.manifest.provides[0].observables = [status];
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/observables\[0\]\.persistentVar is required unless the package uses guestApi 2/);
+        artifact.manifest.guestApi = 2;
+        expect((0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact).provides[0].observables).toEqual([status]);
+        artifact.manifest.provides[0].observables = [{ ...status, persistentVar: null }];
+        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact)).toThrow(/persistentVar must be an object/);
+    });
     test("accepts a network allowlist and rejects a host with a scheme", () => {
         const { artifact } = makeArtifact();
         artifact.manifest.network = {

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

@@ -4,7 +4,7 @@ import type { IContractCall, IContractProviderEndpoint } from "../contracts/cont
 import type { ContractRegistry } from "../contracts/registry";
 import type { PersistentVarScope } from "../data/persistent-vars";
 import type { IField } from "../types/field-type";
-import type { IIsolatedContractToolRef, IIsolatedInstallResult, IIsolatedPackageArtifact } from "./isolated-artifact";
+import type { IIsolatedContractToolRef, IIsolatedInstalledPackage, IIsolatedInstallResult, IIsolatedPackageArtifact } from "./isolated-artifact";
 import type { IPackageWorkerHealth } from "./package-runtime-state";
 /** 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"];
@@ -91,6 +91,8 @@ export interface IIsolatedPackageRuntime {
     provides(contractId: string, version: number): boolean;
     /** True when this runtime has installed `packageId`. */
     isInstalled(packageId: string): boolean;
+    /** Read an installed package's declaration without starting its worker or exposing source. */
+    getInstalledPackage?(packageId: string): IIsolatedInstalledPackage | undefined;
     /**
      * Report whether the package's worker is running and its last worker start or crash
      * failure since install or replacement. Workers start lazily, so a broken provider only
@@ -120,13 +122,21 @@ export interface IIsolatedPackageRuntime {
      * @param principal - Trusted caller authority. Defaults to Self when omitted.
      */
     invokeOwnedTool?(packageId: string, ref: IIsolatedContractToolRef, args: unknown, principal?: IIsolatedCallPrincipal): Promise<unknown>;
-    /** Narrow a projected action turn by the trusted consumer's selected contract consume ceiling. */
+    /**
+     * Narrow a delegated turn by the trusted consumer's selected contract consume ceiling, for
+     * `context.dispatchTool` and the Contract Catalog's projections.
+     */
     actionDispatchPrincipal?(principal: IIsolatedCallPrincipal, consumerPackageId?: string, ref?: IIsolatedContractToolRef): IIsolatedCallPrincipal;
-    /** Project aliases whose wrapper and canonical targets allow the trusted caller. */
-    authorizedActionNames?(packageId: string, principal: IIsolatedCallPrincipal, consumerPackageId?: string, selectedContract?: {
+    /**
+     * Project authority for a named provider's exposed contract. Checks the caller's current
+     * declarations and provider restrictions, including direct-consume precedence. Undefined
+     * means the package cannot reach this target. Tool admission is checked separately.
+     */
+    exposedContractPrincipal?(principal: IIsolatedCallPrincipal, consumerPackageId: string, target: {
         contractId: string;
         version: number;
-    }): string[] | Promise<string[]>;
+        providerPackageId: string;
+    }): IIsolatedCallPrincipal | undefined;
     /** Terminate every worker and drop installed state. */
     dispose(): Promise<void>;
 }
@@ -153,6 +163,8 @@ export interface IIsolatedPackageTableDeclaration extends IIsolatedPackageTableR
     fields: IField[];
     /** Schema version for host table-definition updates. */
     versionNumber?: number;
+    /** Rows stay on the writing device; see `IIsolatedPackageTable.localOnly`. */
+    localOnly?: boolean;
 }
 /**
  * Trusted host capability for isolated-package table persistence.
@@ -180,8 +192,11 @@ export interface IIsolatedPackageTableGateway {
     /** 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.
+     * Invoke one allowlisted standard operation on a declared table: for the owning package
+     * (`ctx.callOwnedTable`), private tables included, or for a consumer through a contract that
+     * exposes it when the provider predates guest API 3 (guest API 3 sends consumer calls to the
+     * provider's worker, whose table class calls this as the owner). The host validates
+     * declaration, exposure, and provider identity before calling the gateway.
      */
     call(ref: IIsolatedPackageTableRef, operation: IsolatedContractTableOperation, args: unknown[]): Promise<unknown>;
     /**

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

@@ -40,10 +40,15 @@ function validateDeclaration(declaration) {
     if (primaryKey.type !== "id") {
         throw new Error("Isolated table primary key must refer to a field of type id");
     }
+    if (declaration.localOnly !== undefined && typeof declaration.localOnly !== "boolean") {
+        throw new Error("Isolated table localOnly must be a boolean");
+    }
+    const { localOnly, ...rest } = declaration;
     return {
-        ...declaration,
+        ...rest,
         fields: declaration.fields.map((field) => ({ ...field })),
         versionNumber: versionNumber(declaration),
+        ...(localOnly ? { localOnly: true } : {}),
     };
 }
 function toMetaData(rawDeclaration) {
@@ -56,13 +61,12 @@ function toMetaData(rawDeclaration) {
         primaryKeyName: declaration.primaryKeyName,
         fields: declaration.fields,
         versionNumber: versionNumber(declaration),
+        // Only when set: stored definitions hash their metadata, and older ones have no such key.
+        ...(declaration.localOnly ? { localOnly: true } : {}),
     };
 }
 function normalizedMetaData(metaData) {
-    return {
-        ...metaData,
-        fields: metaData.fields.map(({ defaultValue: _defaultValue, ...field }) => field),
-    };
+    return { ...metaData, fields: (0, types_1.comparableTableFields)(metaData.fields) };
 }
 function sameDefinition(existing, incoming) {
     return ((0, utils_1.simpleObjectHash)(normalizedMetaData(existing)) ===
@@ -106,6 +110,7 @@ function declarationFromMetaData(metaData) {
         primaryKeyName: metaData.primaryKeyName,
         fields: metaData.fields,
         versionNumber: metaData.versionNumber,
+        localOnly: metaData.localOnly,
     });
 }
 function metaDataFromStoredDefinition(record, incoming) {
@@ -158,8 +163,22 @@ function copyTableResult(value) {
     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);
+/** Equality and `$in` conditions, as the memory gateway supports; other operators fail. */
+function matchingFilter(filter = {}) {
+    const conditions = Object.entries(filter).map(([name, value]) => {
+        if (name.startsWith("$")) {
+            throw new Error(`The memory table gateway supports equality and $in filters only`);
+        }
+        if (value === null || typeof value !== "object" || value instanceof Date) {
+            return (row) => row[name] === value;
+        }
+        const candidates = value.$in;
+        if (Object.keys(value).length !== 1 || !Array.isArray(candidates)) {
+            throw new Error(`The memory table gateway supports equality and $in filters only`);
+        }
+        return (row) => candidates.includes(row[name]);
+    });
+    return (row) => conditions.every((matches) => matches(row));
 }
 function assertTableEvent(eventName) {
     if (!isolated_runtime_1.ISOLATED_CONTRACT_TABLE_EVENTS.includes(eventName)) {
@@ -254,18 +273,18 @@ function createMemoryIsolatedPackageTableGateway() {
                 case "list": {
                     const filter = (args[0] ?? {});
                     const opts = (args[1] ?? {});
-                    const matching = [...tableRows.values()].filter((row) => matchesFilter(row, filter));
+                    const matching = [...tableRows.values()].filter(matchingFilter(filter));
                     const pageSize = opts.pageSize ?? matching.length;
-                    const start = (opts.page ?? 0) * pageSize;
+                    const start = (Math.max(1, Math.round(opts.page || 1)) - 1) * 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;
+                    return [...tableRows.values()].filter(matchingFilter(filter)).length;
                 }
                 case "findOne": {
                     const filter = (args[0] ?? {});
-                    return (0, isolated_value_1.copyIsolatedValue)([...tableRows.values()].find((row) => matchesFilter(row, filter)));
+                    return (0, isolated_value_1.copyIsolatedValue)([...tableRows.values()].find(matchingFilter(filter)));
                 }
                 case "save":
                 case "insert":