@peers-app/peers-sdk 0.26.5 → 0.27.0

package/dist/define/manifest.js

@@ -0,0 +1,653 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.irFields = irFields;
+exports.schemaValueType = schemaValueType;
+exports.fitsValueType = fitsValueType;
+exports.contractManifest = contractManifest;
+exports.buildPackageManifest = buildPackageManifest;
+const zod_1 = require("zod");
+const validate_1 = require("../contracts/validate");
+const types_1 = require("../data/orm/types");
+const isolated_artifact_1 = require("../package-loader/isolated-artifact");
+const peer_id_1 = require("../peer-id");
+const field_type_1 = require("../types/field-type");
+const events_1 = require("./events");
+const generated_field_1 = require("./generated-field");
+const observables_1 = require("./observables");
+const OPTIONAL_INPUT_TYPES = new Set(["ZodDefault", "ZodOptional", "ZodCatch"]);
+/**
+ * The scalar type of an enum or literal, which `schemaToFields` leaves as `any`: an enum or a
+ * string literal is `string`, as for event payloads and observable values.
+ */
+function literalType(schema) {
+    let def = schema._def;
+    let array = false;
+    while (def.innerType ||
+        def.schema ||
+        def.typeName === "ZodBranded" ||
+        def.typeName === "ZodArray") {
+        // These wrappers can produce null, nested arrays, or a transformed value. Narrowing
+        // their former `any` type would make the host refuse valid inputs or stored rows.
+        if (def.typeName === "ZodNullable" ||
+            (def.typeName === "ZodEffects" && def.effect.type === "transform") ||
+            (array && (def.typeName === "ZodArray" || def.typeName === "ZodOptional"))) {
+            return undefined;
+        }
+        if (def.typeName === "ZodArray")
+            array = true;
+        def = (def.innerType ?? def.schema ?? def.type)._def;
+    }
+    if (def.typeName === "ZodEnum")
+        return field_type_1.FieldType.string;
+    if (def.typeName !== "ZodLiteral")
+        return undefined;
+    if (typeof def.value === "string")
+        return field_type_1.FieldType.string;
+    if (typeof def.value === "number")
+        return field_type_1.FieldType.number;
+    if (typeof def.value === "boolean")
+        return field_type_1.FieldType.boolean;
+    return undefined;
+}
+/** The scalar values an enum, a literal, or a union of them allows; undefined for anything else. */
+function enumValuesOf(schema) {
+    const def = schema._def;
+    switch (def.typeName) {
+        case "ZodEnum":
+            return [...def.values];
+        case "ZodNativeEnum": {
+            // A numeric TypeScript enum maps each value back to its name too; skip those keys.
+            const values = def.values;
+            return Object.keys(values)
+                .filter((key) => typeof values[values[key]] !== "number")
+                .map((key) => values[key]);
+        }
+        case "ZodLiteral":
+            return ["string", "number", "boolean"].includes(typeof def.value) ? [def.value] : undefined;
+        case "ZodUnion": {
+            const values = [];
+            for (const option of def.options) {
+                const optionValues = enumValuesOf(option);
+                if (!optionValues) {
+                    return undefined;
+                }
+                values.push(...optionValues);
+            }
+            return values;
+        }
+        default:
+            return undefined;
+    }
+}
+/**
+ * What a field's schema says beyond its type: an object's own fields and the values an enum or
+ * literal allows. Walks the wrappers `schemaToFields` walks, into one array's elements, and
+ * stops at a transform, a preprocess, a pipeline, or a nested array, where the schema no longer
+ * describes the value in IR terms. Only details that fit `type` are kept, preserving the
+ * field's existing scalar type.
+ *
+ * A field has one empty value in Peers, missing, so `.nullable()` is refused unless the field is
+ * also `.optional()` (a `null` sent for it is removed) and has no default (an empty field gets
+ * the default). `.optional().nullable()` is marked `optional`, which `schemaToFields` misses.
+ */
+function fieldDetails(schema, shape, input, depth, path, event = false, wholeValue = false) {
+    const { type } = shape;
+    let current = schema;
+    let nullable = false;
+    let optional = false;
+    let defaulted = false;
+    let inArray = false;
+    let emptyElement = false;
+    walk: while (true) {
+        const def = current._def;
+        switch (def.typeName) {
+            case "ZodNullable":
+                nullable ||= !inArray;
+                emptyElement ||= inArray;
+                current = def.innerType;
+                continue;
+            case "ZodOptional":
+                optional ||= !inArray;
+                emptyElement ||= inArray;
+                current = def.innerType;
+                continue;
+            case "ZodDefault":
+            case "ZodCatch":
+                defaulted ||= !inArray;
+                current = def.innerType;
+                continue;
+            case "ZodReadonly":
+                current = def.innerType;
+                continue;
+            case "ZodBranded":
+                current = def.type;
+                continue;
+            case "ZodEffects":
+                if (def.effect.type !== "refinement") {
+                    break walk;
+                }
+                current = def.schema;
+                continue;
+            case "ZodArray":
+                if (inArray) {
+                    break walk;
+                }
+                inArray = true;
+                current = def.type;
+                continue;
+            default:
+                break walk;
+        }
+    }
+    if (!wholeValue && nullable && defaulted) {
+        throw new Error(`Field "${path}" has a default and uses .nullable(); an empty field gets its default in Peers, so drop .nullable()`);
+    }
+    if (!wholeValue && nullable && !optional) {
+        throw new Error(`Field "${path}" uses .nullable(); an empty field is a missing field in Peers, so use .optional() (a null sent for it is removed)`);
+    }
+    const details = nullable || (wholeValue && optional) ? { optional: true } : {};
+    if (current._def.typeName === "ZodObject" &&
+        type === field_type_1.FieldType.object &&
+        depth < isolated_artifact_1.ISOLATED_MAX_FIELD_DEPTH) {
+        details.fields = event
+            ? eventFields(current, depth + 1, path)
+            : irFields(current, input, depth + 1, path);
+    }
+    const values = enumValuesOf(current);
+    if (!emptyElement && values?.length && values.every((value) => (0, isolated_artifact_1.enumValueFits)(value, type))) {
+        details.enumValues = [...new Set(values)];
+    }
+    return details;
+}
+/** Run `build`, naming `label` in an error it throws. */
+function describing(label, build) {
+    try {
+        return build();
+    }
+    catch (error) {
+        throw new Error(`${label}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * A zod object schema as Peers IR. Defaults stay in the package. Defaulted tool inputs may be
+ * omitted; table fields describe complete stored rows, after the provider parses a save. Shared
+ * with the mock host; not a public SDK export.
+ *
+ * @internal
+ * @param schema - A tool's input or output, a table's row, or an event's payload schema.
+ * @param input - True for tool inputs, where a defaulted field may be omitted.
+ * @param depth - How deep this field list nests in object `fields` (top level is 1).
+ * @param parent - The path of the object field these fields belong to, for error messages.
+ */
+function irFields(schema, input = false, depth = 1, parent = "") {
+    return (0, types_1.schemaToFields)(schema).map((schemaField) => {
+        const path = parent ? `${parent}.${schemaField.name}` : schemaField.name;
+        return irField(schema.shape[schemaField.name], schemaField, input, depth, path);
+    });
+}
+/** Describe a field, or a synthetic field holding an observable's whole value. */
+function irField(schema, schemaField, input, depth, path, wholeValue = false) {
+    const generated = (0, generated_field_1.generatedFieldMetadata)(schema);
+    if (generated)
+        return { name: schemaField.name, ...generated.shape };
+    const literal = schemaField.type === field_type_1.FieldType.any ? literalType(schema) : undefined;
+    const field = literal ? { ...schemaField, type: literal } : schemaField;
+    const { defaultValue: _default, ...rest } = field;
+    const result = typeof _default === "function" ? rest : field;
+    const details = fieldDetails(schema, field, input, depth, path, false, wholeValue);
+    // Tool callers may omit a defaulted input: the guest, rather than the host, fills it in.
+    // Walk refinements, readonly, and brands too, without executing schema/default code.
+    // `.catch()` accepts any input, a missing one included.
+    let current = input ? schema : undefined;
+    while (current) {
+        const def = current._def;
+        if (OPTIONAL_INPUT_TYPES.has(def.typeName)) {
+            return { ...result, optional: true, ...details };
+        }
+        current = def.innerType ?? def.schema ?? (def.typeName === "ZodBranded" ? def.type : undefined);
+    }
+    return { ...result, ...details };
+}
+function toolManifest(tool) {
+    const definition = tool.definition;
+    const withSchemas = "inputSchema" in definition;
+    return {
+        name: definition.name,
+        usageDescription: definition.usageDescription,
+        suggestedAccessLevel: definition.accessLevel,
+        ...(definition.authorityPropagation === undefined
+            ? {}
+            : { authorityPropagation: definition.authorityPropagation }),
+        ...(definition.private === undefined ? {} : { private: definition.private }),
+        ...(definition.remoteAccessLevel === undefined
+            ? {}
+            : { remoteAccessLevel: definition.remoteAccessLevel }),
+        ...(definition.timeoutMs === undefined ? {} : { timeoutMs: definition.timeoutMs }),
+        inputFields: withSchemas
+            ? describing(`Tool ${definition.name} input`, () => irFields(definition.inputSchema, true))
+            : definition.inputFields,
+        outputFields: withSchemas
+            ? describing(`Tool ${definition.name} output`, () => irFields(definition.outputSchema))
+            : definition.outputFields,
+    };
+}
+/** zod types whose values JSON can't carry. */
+const NON_JSON_TYPES = new Set([
+    "ZodDate",
+    "ZodBigInt",
+    "ZodSymbol",
+    "ZodFunction",
+    "ZodMap",
+    "ZodSet",
+    "ZodPromise",
+    "ZodNaN",
+]);
+/** Reject explicitly non-JSON schemas even when nested or hidden by a nullable wrapper. */
+function assertJsonSchema(name, schema, seen = new Set()) {
+    if (seen.has(schema)) {
+        return;
+    }
+    seen.add(schema);
+    const def = schema._def;
+    if (NON_JSON_TYPES.has(def.typeName) ||
+        (def.typeName === "ZodLiteral" && ["bigint", "symbol"].includes(typeof def.value))) {
+        throw new Error(`Observable ${name} has a ${def.typeName} schema; its value must be JSON`);
+    }
+    const children = [];
+    switch (def.typeName) {
+        case "ZodObject":
+            children.push(...Object.values(schema.shape), def.catchall);
+            break;
+        case "ZodArray":
+        case "ZodBranded":
+            children.push(def.type);
+            break;
+        case "ZodRecord":
+            children.push(def.valueType);
+            break;
+        case "ZodTuple":
+            children.push(...def.items, def.rest);
+            break;
+        case "ZodUnion":
+        case "ZodDiscriminatedUnion":
+            children.push(...def.options);
+            break;
+        case "ZodIntersection":
+            children.push(def.left, def.right);
+            break;
+        case "ZodPipeline":
+            children.push(def.in, def.out);
+            break;
+        case "ZodLazy":
+            children.push(def.getter());
+            break;
+        default:
+            children.push(def.innerType, def.schema);
+    }
+    for (const child of children) {
+        if (child) {
+            assertJsonSchema(name, child, seen);
+        }
+    }
+}
+/**
+ * The IR value type for an observable's schema, which the host checks values against.
+ * Values are JSON, so a Date can't be one. Shared with the mock host; not a public SDK export.
+ *
+ * @internal
+ * @param name - The observable's name, for schema errors.
+ * @param schema - The observable's value schema.
+ */
+function schemaValueType(name, schema) {
+    assertJsonSchema(name, schema);
+    const generated = (0, generated_field_1.generatedFieldMetadata)(schema);
+    if (generated?.valueType !== undefined)
+        return generated.valueType;
+    // Walk defaults, refinements, readonly, and brands to the type underneath.
+    let def = schema._def;
+    while (true) {
+        if (def._fieldType) {
+            return def._fieldType;
+        }
+        switch (def.typeName) {
+            // A null or missing value (published as null) fits only `any`. Do not run user
+            // refinements/defaults to discover this: inference must not execute schema code.
+            case "ZodNullable":
+            case "ZodOptional":
+                return field_type_1.FieldType.any;
+            case "ZodEffects":
+                // A transform can change the output type. Zod carries no inspectable output schema.
+                if (def.effect.type === "transform") {
+                    return field_type_1.FieldType.any;
+                }
+                break;
+            case "ZodString":
+            case "ZodEnum":
+                return field_type_1.FieldType.string;
+            case "ZodNumber":
+                return field_type_1.FieldType.number;
+            case "ZodBoolean":
+                return field_type_1.FieldType.boolean;
+            case "ZodObject":
+            case "ZodRecord":
+            case "ZodArray":
+            case "ZodTuple":
+                return field_type_1.FieldType.object;
+            case "ZodNativeEnum":
+                return Object.values(def.values).some((value) => typeof value === "number")
+                    ? field_type_1.FieldType.any
+                    : field_type_1.FieldType.string;
+            case "ZodLiteral":
+                return typeof def.value === "string"
+                    ? field_type_1.FieldType.string
+                    : typeof def.value === "number"
+                        ? field_type_1.FieldType.number
+                        : typeof def.value === "boolean"
+                            ? field_type_1.FieldType.boolean
+                            : field_type_1.FieldType.any;
+        }
+        const inner = def.innerType ?? def.schema ?? (def.typeName === "ZodBranded" ? def.type : undefined);
+        if (!inner) {
+            return field_type_1.FieldType.any;
+        }
+        def = inner._def;
+    }
+}
+/**
+ * True when the host's observable `valueType` check accepts `value`. Shared with the mock host;
+ * not a public SDK export.
+ *
+ * @internal
+ * @param value - An incoming observable write or published value.
+ * @param type - The manifest's declared value type.
+ */
+function fitsValueType(value, type) {
+    switch (type) {
+        case field_type_1.FieldType.any:
+            return true;
+        case field_type_1.FieldType.id:
+            return typeof value === "string" && (0, peer_id_1.isid)(value);
+        case field_type_1.FieldType.string:
+            return typeof value === "string";
+        case field_type_1.FieldType.number:
+            return typeof value === "number" && Number.isFinite(value);
+        case field_type_1.FieldType.boolean:
+            return typeof value === "boolean";
+        case field_type_1.FieldType.object:
+            return value !== null && typeof value === "object";
+        default:
+            return false;
+    }
+}
+function observableManifest(observable) {
+    if (!(0, observables_1.isPackageObservable)(observable)) {
+        return { ...observable };
+    }
+    const { definition } = observable;
+    const persistentVar = observable.persistentVar;
+    const schema = "schema" in definition ? definition.schema : undefined;
+    if (schema && persistentVar && !schema.safeParse(persistentVar.defaultValue).success) {
+        throw new Error(`Observable ${definition.name}: variable "${persistentVar.name}"'s defaultValue doesn't match the schema`);
+    }
+    const valueType = schema
+        ? schemaValueType(definition.name, schema)
+        : definition.valueType;
+    // A declared observable has no source yet: its implementation's is checked when provided.
+    if (!persistentVar && (0, observables_1.isImplementedObservable)(observable)) {
+        // The worker publishes the source's value when it starts (undefined as null), and the host
+        // rejects one that doesn't fit, which fails the start. Catch it here instead.
+        const initial = observable.definition.source();
+        if (!fitsValueType(initial ?? null, valueType)) {
+            const shown = initial === undefined || initial === null
+                ? String(initial)
+                : `a ${Array.isArray(initial) ? "array" : typeof initial}`;
+            throw new Error(`Observable ${definition.name}'s source starts as ${shown}, which doesn't match its valueType ${valueType}; the worker publishes it at start, so give the source a matching initial value or widen the schema`);
+        }
+    }
+    // The value's full shape follows field rules: `valueType` stays what the host checks.
+    const value = schema ? observableValueShape(definition.name, schema) : undefined;
+    return {
+        name: definition.name,
+        description: definition.description,
+        valueType,
+        ...(value ? { value } : {}),
+        writable: definition.writable ?? false,
+        ...(persistentVar
+            ? {
+                persistentVar: {
+                    scope: persistentVar.scope,
+                    name: persistentVar.name,
+                    defaultValue: persistentVar.defaultValue,
+                },
+            }
+            : {}),
+    };
+}
+/** The output shape of one parsed event field, restricted to what event IR can express. */
+function eventValueShape(schema) {
+    const def = schema._def;
+    if (def._fieldType) {
+        return { type: def._fieldType };
+    }
+    switch (def.typeName) {
+        case "ZodOptional":
+        case "ZodNullable":
+            return { ...eventValueShape(def.innerType), optional: true };
+        case "ZodDefault":
+        case "ZodReadonly":
+            return eventValueShape(def.innerType);
+        case "ZodBranded":
+            return eventValueShape(def.type);
+        case "ZodEffects":
+            return def.effect.type === "transform"
+                ? { type: field_type_1.FieldType.any, optional: true }
+                : eventValueShape(def.schema);
+        case "ZodPipeline":
+            return eventValueShape(def.out);
+        case "ZodString":
+        case "ZodEnum":
+            return { type: field_type_1.FieldType.string };
+        case "ZodNumber":
+            return { type: field_type_1.FieldType.number };
+        case "ZodBoolean":
+            return { type: field_type_1.FieldType.boolean };
+        case "ZodDate":
+            return { type: field_type_1.FieldType.Date };
+        case "ZodObject":
+        case "ZodRecord":
+            return { type: field_type_1.FieldType.object };
+        case "ZodArray": {
+            const element = eventValueShape(def.type);
+            return {
+                // Event IR can't express nullable elements or nested arrays with a scalar type.
+                type: element.optional || element.isArray ? field_type_1.FieldType.any : element.type,
+                isArray: true,
+            };
+        }
+        case "ZodTuple":
+            return { type: field_type_1.FieldType.any, isArray: true };
+        case "ZodLiteral":
+            if (typeof def.value === "string")
+                return { type: field_type_1.FieldType.string };
+            if (typeof def.value === "number")
+                return { type: field_type_1.FieldType.number };
+            if (typeof def.value === "boolean")
+                return { type: field_type_1.FieldType.boolean };
+    }
+    // Unions, catches, and opaque schemas may produce null or omit a field. The package
+    // parses the complete payload before sending; the host must accept every valid output.
+    return { type: field_type_1.FieldType.any, optional: true };
+}
+function eventManifest(event) {
+    if (!(0, events_1.isPackageEvent)(event)) {
+        return { ...event };
+    }
+    const { definition } = event;
+    const schema = "payloadSchema" in definition ? definition.payloadSchema : undefined;
+    return {
+        name: definition.name,
+        description: definition.description,
+        payloadFields: schema
+            ? describing(`Event ${definition.name} payload`, () => eventFields(schema))
+            : "payloadFields" in definition
+                ? (definition.payloadFields ?? [])
+                : [],
+    };
+}
+/** Event fields describe parsed output at every depth, including transforms and pipelines. */
+function eventFields(schema, depth = 1, parent = "") {
+    return (0, types_1.schemaToFields)(schema).map((field) => {
+        const generated = (0, generated_field_1.generatedFieldMetadata)(schema.shape[field.name]);
+        if (generated)
+            return { name: field.name, ...generated.shape };
+        const { type: _type, optional: _optional, isArray: _array, defaultValue, ...metadata } = field;
+        const shape = eventValueShape(schema.shape[field.name]);
+        const path = parent ? `${parent}.${field.name}` : field.name;
+        return {
+            ...metadata,
+            ...(typeof defaultValue !== "function" && defaultValue !== undefined ? { defaultValue } : {}),
+            ...shape,
+            ...fieldDetails(schema.shape[field.name], shape, false, depth, path, true),
+        };
+    });
+}
+/**
+ * An observable value's shape, by field rules. The value itself may be empty (null on the wire,
+ * marked `optional`): it isn't a field of a record, so a nullable value isn't refused.
+ */
+function observableValueShape(name, schema) {
+    const generated = (0, generated_field_1.generatedFieldMetadata)(schema);
+    if (generated)
+        return generated.shape;
+    let root = schema;
+    let empty = false;
+    while (root._def.typeName === "ZodNullable" || root._def.typeName === "ZodOptional") {
+        empty = true;
+        root = root._def.innerType;
+    }
+    const { name: _name, ...shape } = describing(`Observable ${name} value`, () => irField(root, (0, types_1.schemaToFields)(zod_1.z.object({ value: root }))[0], false, 1, "value", true));
+    return empty ? { ...shape, optional: true } : shape;
+}
+function tableManifest(table) {
+    const { name, description, primaryKeyName, schema, versionNumber, localOnly } = table.definition;
+    return {
+        name,
+        description,
+        primaryKeyName,
+        fields: describing(`Table ${name}`, () => irFields(schema)),
+        ...(versionNumber === undefined ? {} : { versionNumber }),
+        ...(localOnly ? { localOnly: true } : {}),
+    };
+}
+/** One contract's manifest entry, with name-only references to its tables. */
+function providedContractManifest(contract) {
+    return {
+        contractId: contract.contractId,
+        version: contract.version,
+        name: contract.name,
+        ...(contract.description === undefined ? {} : { description: contract.description }),
+        ...(contract.tables.length
+            ? { tables: contract.tables.map((table) => ({ name: table.definition.name })) }
+            : {}),
+        tools: contract.tools.map(toolManifest),
+        ...(contract.observables.length
+            ? { observables: contract.observables.map(observableManifest) }
+            : {}),
+        ...(contract.events.length ? { events: contract.events.map(eventManifest) } : {}),
+        ...(contract.exposes?.length
+            ? {
+                exposes: contract.exposes.map(({ contractId, version }) => ({ contractId, version })),
+            }
+            : {}),
+    };
+}
+/**
+ * A contract's manifest entry and its tables' definitions, from a contract or a declaration:
+ * the IR a provider of it would register. Used to generate a declaration from another one; not
+ * a public SDK export.
+ *
+ * @internal
+ * @param contract - From `defineContract`, `implementContract`, or a declaration's members.
+ */
+function contractManifest(contract) {
+    return {
+        contract: providedContractManifest(contract),
+        tables: contract.tables.map((table) => tableManifest(table)),
+    };
+}
+/**
+ * Turn a package definition into its manifest: plain JSON in Peers IR, which the Runtime reads
+ * without running any package code. `peers-package manifest` writes it to `dist/manifest.json`.
+ *
+ * @param definition - The default export of the package's `src/package.ts`.
+ * @param options - The package's frozen contracts, for `alsoImplements` by version number.
+ */
+function buildPackageManifest(definition, options = {}) {
+    if (definition?.kind !== "package") {
+        throw new Error("buildPackageManifest takes the result of definePackage(...)");
+    }
+    const provides = definition.provides.map((contract) => providedContractManifest(contract));
+    const manifest = {
+        packageId: definition.packageId,
+        version: definition.version,
+        guestApi: isolated_artifact_1.ISOLATED_GUEST_API_VERSION,
+        ...(definition.executionMode === undefined ? {} : { executionMode: definition.executionMode }),
+        provides,
+        consumes: definition.consumes.map(({ ref, optional, providerPackageIds, fallbackToDefaultProvider }) => ({
+            contractId: ref.contractId,
+            version: ref.version,
+            ...(optional ? { optional: true } : {}),
+            ...(providerPackageIds === undefined
+                ? {}
+                : { providerPackageIds: [...providerPackageIds] }),
+            ...(fallbackToDefaultProvider === undefined ? {} : { fallbackToDefaultProvider }),
+        })),
+        ...(definition.tables.length ? { tables: definition.tables.map(tableManifest) } : {}),
+        ...(definition.network === undefined ? {} : { network: definition.network }),
+        ...(definition.appNavs.length ? { appNavs: [...definition.appNavs] } : {}),
+    };
+    const providedKeys = new Set(provides.map(({ contractId, version }) => `${contractId}@${version}`));
+    definition.provides.forEach((contract, index) => {
+        if (!contract.alsoImplements?.length)
+            return;
+        provides[index] = {
+            ...provides[index],
+            alsoImplements: contract.alsoImplements.map((target) => alsoImplementsEntry(contract, provides[index], manifest.tables ?? [], target, {
+                providedKeys,
+                frozen: options.frozen,
+            })),
+        };
+    });
+    // The manifest is data: drop anything JSON can't carry, so what's checked is what ships.
+    return JSON.parse(JSON.stringify(manifest));
+}
+/**
+ * One `alsoImplements` entry, carrying the target's definition so the host can register it on a
+ * cold start: an older version of the contract from `frozen-contracts.json`, or another
+ * contract from its declaration. The contract's shape must satisfy it.
+ */
+function alsoImplementsEntry(contract, provided, tables, target, context) {
+    const label = `Contract ${contract.name} (${contract.contractId}@${contract.version})`;
+    let definition;
+    if (typeof target === "number") {
+        const frozen = context.frozen?.contracts.find((entry) => entry.contractId === contract.contractId && entry.version === target);
+        if (!frozen) {
+            throw new Error(`${label} also implements v${target}, which frozen-contracts.json doesn't record. Run peers-package contract freeze for the stable release that provided v${target}, or provide v${target} with pkg.provides.`);
+        }
+        const { frozenBy: _frozenBy, ...shape } = frozen;
+        definition = shape;
+    }
+    else {
+        const declared = contractManifest(target.declaration);
+        definition = (0, isolated_artifact_1.isolatedContractToDefinition)(declared.contract, declared.tables);
+    }
+    const key = `${definition.contractId}@${definition.version}`;
+    if (context.providedKeys.has(key)) {
+        throw new Error(`${label} also implements ${key}, which the package provides with pkg.provides`);
+    }
+    const satisfied = (0, validate_1.validateProviderSatisfiesContract)((0, isolated_artifact_1.isolatedContractToDefinition)(provided, tables), definition);
+    if (!satisfied.valid) {
+        throw new Error(`${label} doesn't satisfy ${definition.name} (${key}), which it also implements: ${satisfied.errors.map(({ message }) => message).join("; ")}`);
+    }
+    return { contractId: definition.contractId, version: definition.version, definition };
+}