@qlever-llc/trellis 0.7.0 → 0.8.0-rc.2

package/esm/npm/src/contract_support/mod.js

@@ -0,0 +1,1285 @@
+import Type from "typebox";
+import { TrellisError } from "../errors/TrellisError.js";
+import { canonicalizeJson, digestJson, isJsonValue, sha256Base64urlSync, } from "./canonical.js";
+import { schema, unwrapSchema, } from "./runtime.js";
+import { assertDataPointersExistAndAreTokenable, getSubschemaAtDataPointer, } from "./schema_pointers.js";
+export { ContractJobQueueSchema, ContractJobsSchema, ContractKvResourceSchema, ContractResourceBindingsSchema, ContractResourcesSchema, ContractSchemaRefSchema, ContractStateSchema, ContractStateStoreSchema, ContractStoreResourceSchema, EventHeaderSchema, InstalledServiceContractSchema, IsoDateSchema, JobsQueueBindingSchema, JobsResourceBindingSchema, KvResourceBindingSchema, PaginatedSchema, StoreResourceBindingSchema, } from "./protocol.js";
+export const CONTRACT_FORMAT_V1 = "trellis.contract.v1";
+export const CATALOG_FORMAT_V1 = "trellis.catalog.v1";
+const CONTRACT_MODULE_METADATA = Symbol.for("@qlever-llc/trellis/contracts/contract-module");
+export const CONTRACT_JOBS_METADATA = Symbol.for("@qlever-llc/trellis/contracts/jobs");
+export const CONTRACT_KV_METADATA = Symbol.for("@qlever-llc/trellis/contracts/kv");
+export const CONTRACT_STATE_METADATA = Symbol.for("@qlever-llc/trellis/contracts/state");
+const CONTRACT_ERROR_RUNTIME_METADATA = Symbol.for("@qlever-llc/trellis/contracts/error-runtime");
+const RESERVED_DEFINED_ERROR_FIELD_NAMES = new Set([
+    "id",
+    "type",
+    "message",
+    "context",
+    "traceId",
+    "cause",
+]);
+const DEFINED_ERROR_PAYLOAD = Symbol.for("@qlever-llc/trellis/contracts/defined-error-payload");
+function createSchemaRef(_schemas) {
+    void _schemas;
+    return (schemaName) => ({ schema: schemaName });
+}
+function getContractErrorType(errorClass) {
+    const explicitType = Reflect.get(errorClass, "type");
+    return typeof explicitType === "string" ? explicitType : errorClass.name;
+}
+function isSerializableErrorData(value) {
+    return !!value && typeof value === "object" &&
+        typeof value.id === "string" &&
+        typeof value.type === "string" &&
+        typeof value.message === "string";
+}
+function isErrorClass(value) {
+    return typeof value === "function" &&
+        typeof Reflect.get(value, "name") === "string" &&
+        typeof Reflect.get(value, "fromSerializable") === "function" &&
+        typeof Reflect.get(value, "schema") === "object";
+}
+function assertNoReservedDefinedErrorFieldNames(fields) {
+    for (const fieldName of Object.keys(fields)) {
+        if (RESERVED_DEFINED_ERROR_FIELD_NAMES.has(fieldName)) {
+            throw new Error(`Defined error field '${fieldName}' is reserved`);
+        }
+    }
+}
+function createDefinedErrorSchema(type, fields) {
+    return Type.Object({
+        id: Type.String(),
+        type: Type.Literal(type),
+        message: Type.String(),
+        ...fields,
+        context: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+        traceId: Type.Optional(Type.String()),
+    });
+}
+function definedErrorPayloadFieldNames(fields) {
+    return Object.keys(fields);
+}
+function pickDefinedErrorPayload(fieldNames, source) {
+    return Object.fromEntries(fieldNames.map((fieldName) => [fieldName, source[fieldName]]));
+}
+function definedErrorBaseOptions(options) {
+    const baseOptions = {};
+    if (options.cause !== undefined) {
+        baseOptions.cause = options.cause;
+    }
+    if (options.context !== undefined) {
+        baseOptions.context = options.context;
+    }
+    if (options.id !== undefined) {
+        baseOptions.id = options.id;
+    }
+    if (options.traceId !== undefined) {
+        baseOptions.traceId = options.traceId;
+    }
+    return baseOptions;
+}
+function attachDefinedErrorPayload(error, payload) {
+    error[DEFINED_ERROR_PAYLOAD] = payload;
+    return Object.assign(error, payload);
+}
+const TRELLIS_AUTH_CONTRACT_ID = "trellis.auth@v1";
+const TRELLIS_STATE_CONTRACT_ID = "trellis.state@v1";
+const BASELINE_AUTH_RPC_CALL = ["Auth.Me", "Auth.Logout"];
+const BASELINE_STATE_RPC_CALL = [
+    "State.Get",
+    "State.Put",
+    "State.Delete",
+    "State.List",
+];
+const UnknownRuntimeSchema = schema(Type.Unknown());
+function typedUnknownRuntimeSchema() {
+    return UnknownRuntimeSchema;
+}
+function trellisRpcDesc(name) {
+    return {
+        subject: rpcSubject(name, "v1"),
+        input: typedUnknownRuntimeSchema(),
+        output: typedUnknownRuntimeSchema(),
+        callerCapabilities: [],
+    };
+}
+const BASELINE_AUTH_API = {
+    rpc: {
+        "Auth.Me": trellisRpcDesc("Auth.Me"),
+        "Auth.Logout": trellisRpcDesc("Auth.Logout"),
+    },
+    operations: {},
+    events: {},
+    subjects: {},
+};
+const BASELINE_STATE_API = {
+    rpc: {
+        "State.Get": trellisRpcDesc("State.Get"),
+        "State.Put": trellisRpcDesc("State.Put"),
+        "State.Delete": trellisRpcDesc("State.Delete"),
+        "State.List": trellisRpcDesc("State.List"),
+    },
+    operations: {},
+    events: {},
+    subjects: {},
+};
+function createContractRefBuilder(registry) {
+    const schemaRef = registry.schemas
+        ? createSchemaRef(registry.schemas)
+        : undefined;
+    return {
+        schema(schemaName) {
+            if (!schemaRef) {
+                throw new Error(`Contract builder ref.schema('${schemaName}') requires a schemas registry`);
+            }
+            return schemaRef(schemaName);
+        },
+        error(errorName) {
+            return errorName;
+        },
+    };
+}
+function cloneSchema(schemaValue) {
+    const cloned = JSON.parse(JSON.stringify(schemaValue));
+    if (!isJsonValue(cloned)) {
+        throw new Error("Contract schema is not JSON-serializable");
+    }
+    return cloned;
+}
+function cloneSchemas(schemas) {
+    if (!schemas) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(schemas).map(([name, schemaValue]) => [name, cloneSchema(schemaValue)]));
+}
+function cloneContractExports(contractExports) {
+    if (!contractExports) {
+        return undefined;
+    }
+    return {
+        ...(contractExports.schemas
+            ? { schemas: [...contractExports.schemas] }
+            : {}),
+    };
+}
+function getErrorRuntimeSchema(errorDecl) {
+    const errorClass = getContractErrorRuntimeClass(errorDecl);
+    const runtimeSchema = errorClass
+        ? Reflect.get(errorClass, "schema")
+        : undefined;
+    if (!runtimeSchema || typeof runtimeSchema !== "object") {
+        return undefined;
+    }
+    return runtimeSchema;
+}
+function createContractErrorDecl(errorClass) {
+    const errorDecl = {
+        type: getContractErrorType(errorClass),
+    };
+    return attachContractErrorRuntimeMetadata(errorDecl, errorClass);
+}
+function normalizeErrorRegistry(errors) {
+    if (!errors) {
+        return undefined;
+    }
+    const normalizedEntries = Object.entries(errors).flatMap(([key, value]) => isErrorClass(value) ? [[key, createContractErrorDecl(value)]] : []);
+    if (normalizedEntries.length === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(normalizedEntries);
+}
+function getErrorClassRegistry(errors) {
+    if (!errors) {
+        return undefined;
+    }
+    const classEntries = Object.entries(errors).flatMap(([key, value]) => isErrorClass(value) ? [[key, value]] : []);
+    if (classEntries.length === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(classEntries);
+}
+function findMatchingSchemaName(schemas, targetSchema) {
+    if (!schemas) {
+        return undefined;
+    }
+    const targetDigest = digestCanonicalJson(cloneSchema(targetSchema));
+    for (const [schemaName, schemaValue] of Object.entries(schemas)) {
+        if (schemaValue === targetSchema) {
+            return schemaName;
+        }
+        if (digestCanonicalJson(cloneSchema(schemaValue)) === targetDigest) {
+            return schemaName;
+        }
+    }
+    return undefined;
+}
+function chooseDerivedErrorSchemaName(schemas, errorName, errorType) {
+    const baseNames = [`${errorType}Data`, `${errorName}Data`];
+    for (const baseName of baseNames) {
+        if (!Object.hasOwn(schemas, baseName)) {
+            return baseName;
+        }
+    }
+    let suffix = 2;
+    while (true) {
+        const candidate = `${errorType}Data${suffix}`;
+        if (!Object.hasOwn(schemas, candidate)) {
+            return candidate;
+        }
+        suffix += 1;
+    }
+}
+function materializeErrorSchemas(schemas, errors) {
+    if (!errors) {
+        return schemas;
+    }
+    let mergedSchemas = schemas;
+    for (const [errorName, errorDecl] of Object.entries(errors)) {
+        if (errorDecl.schema) {
+            continue;
+        }
+        const runtimeSchema = getErrorRuntimeSchema(errorDecl);
+        if (!runtimeSchema) {
+            continue;
+        }
+        if (findMatchingSchemaName(mergedSchemas, runtimeSchema)) {
+            continue;
+        }
+        mergedSchemas = { ...(mergedSchemas ?? {}) };
+        const derivedSchemaName = chooseDerivedErrorSchemaName(mergedSchemas, errorName, errorDecl.type);
+        mergedSchemas[derivedSchemaName] = runtimeSchema;
+    }
+    return mergedSchemas;
+}
+function assertSchemaRefExists(schemas, ref, context) {
+    if (!schemas || !Object.hasOwn(schemas, ref.schema)) {
+        throw new Error(`${context} references unknown schema '${ref.schema}'`);
+    }
+}
+function assertExportedSchemasExist(schemas, contractExports) {
+    for (const schemaName of contractExports?.schemas ?? []) {
+        if (!schemas || !Object.hasOwn(schemas, schemaName)) {
+            throw new Error(`contract exports reference unknown schema '${schemaName}'`);
+        }
+    }
+}
+function assertRegistryDoesNotDeclareExports(registry) {
+    if (Object.hasOwn(registry, "exports")) {
+        throw new Error("contract exports must be declared in the callback body, not the registry argument");
+    }
+}
+function resolveSchemaRef(schemas, ref, context) {
+    assertSchemaRefExists(schemas, ref, context);
+    return cloneSchema(schemas[ref.schema]);
+}
+function digestCanonicalJson(value) {
+    return sha256Base64urlSync(canonicalizeJson(value));
+}
+function sortedUnique(values) {
+    return [...new Set(values)].sort();
+}
+function collectSchemaRef(reachableSchemas, ref) {
+    if (ref) {
+        reachableSchemas.add(ref.schema);
+    }
+}
+function collectReachableSchemaNames(contract) {
+    const reachableSchemas = new Set();
+    for (const store of Object.values(contract.state ?? {})) {
+        collectSchemaRef(reachableSchemas, store.schema);
+        for (const accepted of Object.values(store.acceptedVersions ?? {})) {
+            collectSchemaRef(reachableSchemas, accepted);
+        }
+    }
+    for (const method of Object.values(contract.rpc ?? {})) {
+        collectSchemaRef(reachableSchemas, method.input);
+        collectSchemaRef(reachableSchemas, method.output);
+        for (const error of method.errors ?? []) {
+            const declaration = Object.values(contract.errors ?? {}).find((decl) => decl.type === error.type);
+            collectSchemaRef(reachableSchemas, declaration?.schema);
+        }
+    }
+    for (const operation of Object.values(contract.operations ?? {})) {
+        collectSchemaRef(reachableSchemas, operation.input);
+        collectSchemaRef(reachableSchemas, operation.progress);
+        collectSchemaRef(reachableSchemas, operation.output);
+    }
+    for (const event of Object.values(contract.events ?? {})) {
+        collectSchemaRef(reachableSchemas, event.event);
+    }
+    for (const job of Object.values(contract.jobs ?? {})) {
+        collectSchemaRef(reachableSchemas, job.payload);
+        collectSchemaRef(reachableSchemas, job.result);
+    }
+    for (const resource of Object.values(contract.resources?.kv ?? {})) {
+        collectSchemaRef(reachableSchemas, resource.schema);
+    }
+    return reachableSchemas;
+}
+function projectReachableSchemas(contract) {
+    const reachableNames = collectReachableSchemaNames(contract);
+    if (!contract.schemas || reachableNames.size === 0) {
+        return undefined;
+    }
+    const entries = Object.entries(contract.schemas).filter(([name]) => reachableNames.has(name));
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function projectRpcDeclaredErrors(contract) {
+    if (!contract.errors) {
+        return undefined;
+    }
+    const declaredErrorTypes = new Set();
+    for (const method of Object.values(contract.rpc ?? {})) {
+        for (const error of method.errors ?? []) {
+            declaredErrorTypes.add(error.type);
+        }
+    }
+    const entries = Object.entries(contract.errors).filter(([, error]) => declaredErrorTypes.has(error.type));
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function projectDigestResources(resources) {
+    if (!resources?.kv && !resources?.store) {
+        return undefined;
+    }
+    return {
+        ...(resources.kv ? { kv: resources.kv } : {}),
+        ...(resources.store ? { store: resources.store } : {}),
+    };
+}
+function projectDigestUses(uses) {
+    if (!uses) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(uses).map(([alias, use]) => [
+        alias,
+        {
+            contract: use.contract,
+            ...(use.rpc?.call ? { rpc: { call: sortedUnique(use.rpc.call) } } : {}),
+            ...(use.operations?.call
+                ? { operations: { call: sortedUnique(use.operations.call) } }
+                : {}),
+            ...((use.events?.publish || use.events?.subscribe)
+                ? {
+                    events: {
+                        ...(use.events.publish
+                            ? { publish: sortedUnique(use.events.publish) }
+                            : {}),
+                        ...(use.events.subscribe
+                            ? { subscribe: sortedUnique(use.events.subscribe) }
+                            : {}),
+                    },
+                }
+                : {}),
+        },
+    ]));
+}
+function projectDigestRpc(rpc) {
+    if (!rpc) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(rpc).map(([name, method]) => [
+        name,
+        {
+            ...method,
+            ...(method.capabilities?.call
+                ? { capabilities: { call: sortedUnique(method.capabilities.call) } }
+                : {}),
+            ...(method.errors
+                ? {
+                    errors: sortedUnique(method.errors.map((error) => error.type)).map((type) => ({ type })),
+                }
+                : {}),
+        },
+    ]));
+}
+function projectDigestOperations(operations) {
+    if (!operations) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(operations).map(([name, operation]) => [
+        name,
+        {
+            ...operation,
+            ...((operation.capabilities?.call || operation.capabilities?.read ||
+                operation.capabilities?.cancel)
+                ? {
+                    capabilities: {
+                        ...(operation.capabilities.call
+                            ? { call: sortedUnique(operation.capabilities.call) }
+                            : {}),
+                        ...(operation.capabilities.read
+                            ? { read: sortedUnique(operation.capabilities.read) }
+                            : {}),
+                        ...(operation.capabilities.cancel
+                            ? { cancel: sortedUnique(operation.capabilities.cancel) }
+                            : {}),
+                    },
+                }
+                : {}),
+        },
+    ]));
+}
+function projectDigestEvents(events) {
+    if (!events) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(events).map(([name, event]) => [
+        name,
+        {
+            ...event,
+            ...((event.capabilities?.publish || event.capabilities?.subscribe)
+                ? {
+                    capabilities: {
+                        ...(event.capabilities.publish
+                            ? { publish: sortedUnique(event.capabilities.publish) }
+                            : {}),
+                        ...(event.capabilities.subscribe
+                            ? { subscribe: sortedUnique(event.capabilities.subscribe) }
+                            : {}),
+                    },
+                }
+                : {}),
+        },
+    ]));
+}
+/**
+ * Build the normalized runtime/interface projection used for contract identity.
+ */
+export function projectContractDigestManifest(contract) {
+    const schemas = projectReachableSchemas(contract);
+    const errors = projectRpcDeclaredErrors(contract);
+    const resources = projectDigestResources(contract.resources);
+    const uses = projectDigestUses(contract.uses);
+    const rpc = projectDigestRpc(contract.rpc);
+    const operations = projectDigestOperations(contract.operations);
+    const events = projectDigestEvents(contract.events);
+    return {
+        format: contract.format,
+        id: contract.id,
+        kind: contract.kind,
+        ...(schemas ? { schemas } : {}),
+        ...(contract.state ? { state: contract.state } : {}),
+        ...(uses ? { uses } : {}),
+        ...(rpc ? { rpc } : {}),
+        ...(operations ? { operations } : {}),
+        ...(events ? { events } : {}),
+        ...(errors ? { errors } : {}),
+        ...(contract.jobs ? { jobs: contract.jobs } : {}),
+        ...(resources ? { resources } : {}),
+    };
+}
+/** Compute the v1 contract digest from the normalized digest projection. */
+export function digestContractManifest(contract) {
+    return digestCanonicalJson(projectContractDigestManifest(contract));
+}
+function rpcSubject(name, version) {
+    return `rpc.${version}.${name}`;
+}
+function operationSubject(name, version) {
+    return `operations.${version}.${name}`;
+}
+function eventSubject(name, version, params) {
+    const suffix = params && params.length > 0
+        ? `.${params.map((pointer) => `{${pointer}}`).join(".")}`
+        : "";
+    return `events.${version}.${name}${suffix}`;
+}
+function emitResources(resources) {
+    if (!resources?.kv && !resources?.store) {
+        return undefined;
+    }
+    return {
+        ...(resources.kv
+            ? {
+                kv: Object.fromEntries(Object.entries(resources.kv).map(([alias, resource]) => [
+                    alias,
+                    {
+                        purpose: resource.purpose,
+                        schema: { ...resource.schema },
+                        required: resource.required ?? true,
+                        history: resource.history ?? 1,
+                        ttlMs: resource.ttlMs ?? 0,
+                        ...(resource.maxValueBytes
+                            ? { maxValueBytes: resource.maxValueBytes }
+                            : {}),
+                    },
+                ])),
+            }
+            : {}),
+        ...(resources.store
+            ? {
+                store: Object.fromEntries(Object.entries(resources.store).map(([alias, resource]) => [
+                    alias,
+                    {
+                        purpose: resource.purpose,
+                        required: resource.required ?? true,
+                        ttlMs: resource.ttlMs ?? 0,
+                        ...(resource.maxObjectBytes !== undefined
+                            ? { maxObjectBytes: resource.maxObjectBytes }
+                            : {}),
+                        ...(resource.maxTotalBytes !== undefined
+                            ? { maxTotalBytes: resource.maxTotalBytes }
+                            : {}),
+                    },
+                ])),
+            }
+            : {}),
+    };
+}
+function emitJobs(jobs) {
+    if (!jobs) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(jobs).map(([queueType, queue]) => [
+        queueType,
+        {
+            payload: { ...queue.payload },
+            ...(queue.result ? { result: { ...queue.result } } : {}),
+            ...(queue.maxDeliver !== undefined
+                ? { maxDeliver: queue.maxDeliver }
+                : {}),
+            ...(queue.backoffMs ? { backoffMs: [...queue.backoffMs] } : {}),
+            ...(queue.ackWaitMs !== undefined
+                ? { ackWaitMs: queue.ackWaitMs }
+                : {}),
+            ...(queue.defaultDeadlineMs !== undefined
+                ? { defaultDeadlineMs: queue.defaultDeadlineMs }
+                : {}),
+            ...(queue.progress !== undefined ? { progress: queue.progress } : {}),
+            ...(queue.logs !== undefined ? { logs: queue.logs } : {}),
+            ...(queue.dlq !== undefined ? { dlq: queue.dlq } : {}),
+            ...(queue.concurrency !== undefined
+                ? { concurrency: queue.concurrency }
+                : {}),
+        },
+    ]));
+}
+function buildContractJobsMetadata(jobs) {
+    if (!jobs) {
+        return {};
+    }
+    return Object.fromEntries(Object.keys(jobs).map((queueType) => [queueType, {
+            payload: undefined,
+            result: undefined,
+        }]));
+}
+function buildContractKvMetadata(resources, schemas) {
+    const kv = resources?.kv;
+    if (!kv) {
+        return {};
+    }
+    const metadata = {};
+    for (const [alias, resource] of Object.entries(kv)) {
+        assertSchemaRefExists(schemas, resource.schema, `kv resource '${alias}'`);
+        metadata[alias] = {
+            required: resource.required ?? true,
+            value: undefined,
+            schema: schemas[resource.schema.schema],
+        };
+    }
+    return metadata;
+}
+function buildContractStateMetadata(state, schemas) {
+    if (!state) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(state).map(([storeName, store]) => [storeName, {
+            kind: store.kind,
+            value: undefined,
+            schema: resolveSchemaRef(schemas, store.schema, `state store '${storeName}'`),
+            stateVersion: store.stateVersion ?? "v1",
+            acceptedVersions: Object.fromEntries(Object.entries(store.acceptedVersions ?? {}).map(([version, schema]) => [
+                version,
+                resolveSchemaRef(schemas, schema, `state store '${storeName}' accepted version '${version}'`),
+            ])),
+        }]));
+}
+function emitState(state) {
+    if (!state) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(state).map(([storeName, store]) => [
+        storeName,
+        {
+            kind: store.kind,
+            schema: { ...store.schema },
+            ...(store.stateVersion === undefined
+                ? {}
+                : { stateVersion: store.stateVersion }),
+            ...(store.acceptedVersions === undefined
+                ? {}
+                : { acceptedVersions: store.acceptedVersions }),
+        },
+    ]));
+}
+function emitUses(uses) {
+    if (!uses) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(uses).map(([alias, use]) => [
+        alias,
+        {
+            contract: use.contract,
+            ...(use.rpc?.call ? { rpc: { call: sortedUnique(use.rpc.call) } } : {}),
+            ...(use.operations?.call
+                ? { operations: { call: sortedUnique(use.operations.call) } }
+                : {}),
+            ...((use.events?.publish || use.events?.subscribe)
+                ? {
+                    events: {
+                        ...(use.events.publish
+                            ? { publish: sortedUnique(use.events.publish) }
+                            : {}),
+                        ...(use.events.subscribe
+                            ? { subscribe: sortedUnique(use.events.subscribe) }
+                            : {}),
+                    },
+                }
+                : {}),
+        },
+    ]));
+}
+function emitContract(source) {
+    const rpc = source.rpc
+        ? Object.fromEntries(Object.entries(source.rpc).map(([name, method]) => {
+            const emitted = {
+                version: method.version,
+                subject: method.subject ?? rpcSubject(name, method.version),
+                input: { ...method.input },
+                output: { ...method.output },
+            };
+            if (method.capabilities?.call) {
+                emitted.capabilities = {
+                    call: sortedUnique(method.capabilities.call),
+                };
+            }
+            if (method.transfer) {
+                emitted.transfer = { ...method.transfer };
+            }
+            if (method.errors && method.errors.length > 0) {
+                emitted.errors = sortedUnique(method.errors.map((errorName) => source.errors?.[errorName]?.type ?? errorName)).map((type) => ({ type }));
+            }
+            return [name, emitted];
+        }))
+        : undefined;
+    const operations = source.operations
+        ? Object.fromEntries(Object.entries(source.operations).map(([name, operation]) => {
+            if (operation.transfer) {
+                const store = source.resources?.store?.[operation.transfer.store];
+                if (!store) {
+                    throw new Error(`Operation '${name}' references unknown store resource '${operation.transfer.store}'`);
+                }
+                const inputSchema = resolveSchemaRef(source.schemas, operation.input, `operation '${name}' input`);
+                for (const pointer of [
+                    operation.transfer.key,
+                    operation.transfer.contentType,
+                    operation.transfer.metadata,
+                ]) {
+                    if (!pointer) {
+                        continue;
+                    }
+                    if (getSubschemaAtDataPointer(inputSchema, pointer) === undefined) {
+                        throw new Error(`Invalid transfer pointer '${pointer}' for operation '${name}' (path not found in input schema)`);
+                    }
+                }
+            }
+            const emitted = {
+                version: operation.version,
+                subject: operation.subject ??
+                    operationSubject(name, operation.version),
+                input: { ...operation.input },
+                output: { ...operation.output },
+            };
+            if (operation.progress) {
+                emitted.progress = { ...operation.progress };
+            }
+            if (operation.transfer) {
+                emitted.transfer = { ...operation.transfer, direction: "send" };
+            }
+            if (operation.capabilities?.call || operation.capabilities?.read ||
+                operation.capabilities?.cancel) {
+                emitted.capabilities = {
+                    ...(operation.capabilities.call
+                        ? { call: sortedUnique(operation.capabilities.call) }
+                        : {}),
+                    ...(operation.capabilities.read
+                        ? { read: sortedUnique(operation.capabilities.read) }
+                        : {}),
+                    ...(operation.capabilities.cancel
+                        ? { cancel: sortedUnique(operation.capabilities.cancel) }
+                        : {}),
+                };
+            }
+            if (operation.cancel !== undefined) {
+                emitted.cancel = operation.cancel;
+            }
+            return [name, emitted];
+        }))
+        : undefined;
+    const events = source.events
+        ? Object.fromEntries(Object.entries(source.events).map(([name, event]) => {
+            if (event.params && event.params.length > 0) {
+                assertDataPointersExistAndAreTokenable(name, resolveSchemaRef(source.schemas, event.event, `event '${name}'`), event.params);
+            }
+            const emitted = {
+                version: event.version,
+                subject: event.subject ??
+                    eventSubject(name, event.version, event.params),
+                event: { ...event.event },
+            };
+            if (event.params && event.params.length > 0) {
+                emitted.params = [...event.params];
+            }
+            if (event.capabilities?.publish || event.capabilities?.subscribe) {
+                emitted.capabilities = {
+                    ...(event.capabilities.publish
+                        ? { publish: sortedUnique(event.capabilities.publish) }
+                        : {}),
+                    ...(event.capabilities.subscribe
+                        ? { subscribe: sortedUnique(event.capabilities.subscribe) }
+                        : {}),
+                };
+            }
+            return [name, emitted];
+        }))
+        : undefined;
+    const errors = source.errors
+        ? Object.fromEntries(Object.entries(source.errors).map(([name, error]) => {
+            const emitted = { type: error.type };
+            const schemaRef = resolveErrorSchemaRef(source.schemas, name, error);
+            if (schemaRef) {
+                emitted.schema = { ...schemaRef };
+            }
+            return [name, emitted];
+        }))
+        : undefined;
+    const jobs = emitJobs(source.jobs);
+    const state = emitState(source.state);
+    const resources = emitResources(source.resources);
+    const uses = emitUses(source.uses);
+    return {
+        format: CONTRACT_FORMAT_V1,
+        id: source.id,
+        displayName: source.displayName,
+        description: source.description,
+        kind: source.kind,
+        ...(source.schemas ? { schemas: cloneSchemas(source.schemas) } : {}),
+        ...(source.exports
+            ? { exports: cloneContractExports(source.exports) }
+            : {}),
+        ...(state ? { state } : {}),
+        ...(uses ? { uses } : {}),
+        ...(rpc ? { rpc } : {}),
+        ...(operations ? { operations } : {}),
+        ...(events ? { events } : {}),
+        ...(errors ? { errors } : {}),
+        ...(jobs ? { jobs } : {}),
+        ...(resources ? { resources } : {}),
+    };
+}
+function buildOwnedApi(source) {
+    const localRuntimeErrors = {};
+    for (const [name, errorDecl] of Object.entries(source.errors ?? {})) {
+        const errorClass = getContractErrorRuntimeClass(errorDecl);
+        if (!errorClass) {
+            continue;
+        }
+        const errorSchemaRef = resolveErrorSchemaRef(source.schemas, name, errorDecl);
+        localRuntimeErrors[name] = {
+            type: errorDecl.type,
+            ...(errorSchemaRef
+                ? {
+                    schema: schema(resolveSchemaRef(source.schemas, errorSchemaRef, `error '${name}' schema`)),
+                }
+                : {}),
+            fromSerializable(data) {
+                if (!isSerializableErrorData(data)) {
+                    throw new Error(`Transport error '${errorDecl.type}' is missing base error fields`);
+                }
+                return errorClass.fromSerializable(data);
+            },
+        };
+    }
+    const rpc = {};
+    for (const [name, method] of Object.entries(source.rpc ?? {})) {
+        rpc[name] = {
+            subject: method.subject ?? rpcSubject(name, method.version),
+            input: schema(resolveSchemaRef(source.schemas, method.input, `rpc '${name}' input`)),
+            output: schema(resolveSchemaRef(source.schemas, method.output, `rpc '${name}' output`)),
+            callerCapabilities: method.capabilities?.call ?? [],
+            transfer: method.transfer ? { ...method.transfer } : undefined,
+            authRequired: method.authRequired ?? true,
+            errors: method.errors,
+            declaredErrorTypes: method.errors?.map((errorName) => source.errors?.[errorName]?.type ?? errorName),
+            runtimeErrors: method.errors?.flatMap((errorName) => {
+                const runtimeError = localRuntimeErrors[errorName];
+                return runtimeError ? [runtimeError] : [];
+            }),
+        };
+    }
+    const operations = Object.fromEntries(Object.entries(source.operations ?? {}).map(([name, operation]) => [
+        name,
+        {
+            subject: operation.subject ?? operationSubject(name, operation.version),
+            input: schema(resolveSchemaRef(source.schemas, operation.input, `operation '${name}' input`)),
+            progress: operation.progress
+                ? schema(resolveSchemaRef(source.schemas, operation.progress, `operation '${name}' progress`))
+                : undefined,
+            output: operation.output
+                ? schema(resolveSchemaRef(source.schemas, operation.output, `operation '${name}' output`))
+                : undefined,
+            transfer: operation.transfer
+                ? { ...operation.transfer, direction: "send" }
+                : undefined,
+            callerCapabilities: operation.capabilities?.call ?? [],
+            readCapabilities: operation.capabilities?.read ?? [],
+            cancelCapabilities: operation.capabilities?.cancel ?? [],
+            cancel: operation.cancel,
+        },
+    ]));
+    const events = Object.fromEntries(Object.entries(source.events ?? {}).map(([name, event]) => {
+        if (event.params && event.params.length > 0) {
+            assertDataPointersExistAndAreTokenable(name, resolveSchemaRef(source.schemas, event.event, `event '${name}'`), event.params);
+        }
+        return [
+            name,
+            {
+                subject: event.subject ??
+                    eventSubject(name, event.version, event.params),
+                params: event.params,
+                event: schema(resolveSchemaRef(source.schemas, event.event, `event '${name}'`)),
+                publishCapabilities: event.capabilities?.publish ?? [],
+                subscribeCapabilities: event.capabilities?.subscribe ?? [],
+            },
+        ];
+    }));
+    return { rpc, operations, events, subjects: {} };
+}
+function mergeRecord(kind, out, next) {
+    for (const [key, value] of Object.entries(next)) {
+        if (Object.hasOwn(out, key)) {
+            throw new Error(`Duplicate ${kind} key '${key}' while deriving contract API`);
+        }
+        out[key] = value;
+    }
+}
+function assertSelectedKeysExist(contractId, kind, keys, api) {
+    if (!keys) {
+        return;
+    }
+    for (const key of keys) {
+        if (!Object.hasOwn(api, key)) {
+            throw new Error(`Contract '${contractId}' does not expose ${kind} key '${key}'`);
+        }
+    }
+}
+function assertValidUseSpec(contractId, spec, api) {
+    assertSelectedKeysExist(contractId, "rpc", spec.rpc?.call, api.rpc);
+    assertSelectedKeysExist(contractId, "operations", spec.operations?.call, api.operations);
+    assertSelectedKeysExist(contractId, "events", spec.events?.publish, api.events);
+    assertSelectedKeysExist(contractId, "events", spec.events?.subscribe, api.events);
+}
+function attachContractModuleMetadata(value, contractModule) {
+    Object.defineProperty(value, CONTRACT_MODULE_METADATA, {
+        value: contractModule,
+        enumerable: false,
+    });
+    return value;
+}
+function attachContractErrorRuntimeMetadata(value, errorClass) {
+    Object.defineProperty(value, CONTRACT_ERROR_RUNTIME_METADATA, {
+        value: errorClass,
+        enumerable: false,
+    });
+    return value;
+}
+function getContractErrorRuntimeClass(errorDecl) {
+    const value = Object.getOwnPropertyDescriptor(errorDecl, CONTRACT_ERROR_RUNTIME_METADATA)?.value;
+    if (isErrorClass(value)) {
+        return value;
+    }
+    return undefined;
+}
+function resolveErrorSchemaRef(schemas, errorName, errorDecl) {
+    if (errorDecl.schema) {
+        return errorDecl.schema;
+    }
+    const runtimeSchema = getErrorRuntimeSchema(errorDecl);
+    if (!runtimeSchema) {
+        return undefined;
+    }
+    const schemaName = findMatchingSchemaName(schemas, runtimeSchema);
+    if (schemaName) {
+        return { schema: schemaName };
+    }
+    throw new Error(`error '${errorName}' schema must be declared in contract.schemas`);
+}
+/**
+ * Define a transportable Trellis error class from a payload-object schema.
+ *
+ * The returned value is a real runtime error class that carries the wire schema
+ * and reconstruction logic needed by `defineServiceContract(...)`.
+ */
+export function defineError(options) {
+    var _a;
+    assertNoReservedDefinedErrorFieldNames(options.fields);
+    const errorSchema = createDefinedErrorSchema(options.type, options.fields);
+    const fieldNames = definedErrorPayloadFieldNames(options.fields);
+    class DefinedErrorImpl extends TrellisError {
+        constructor(payload) {
+            const customPayload = pickDefinedErrorPayload(fieldNames, payload);
+            const message = typeof options.message === "function"
+                ? options.message(customPayload)
+                : options.message;
+            super(message, definedErrorBaseOptions(payload));
+            Object.defineProperty(this, "name", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: options.type
+            });
+            Object.defineProperty(this, _a, {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            this[DEFINED_ERROR_PAYLOAD] = customPayload;
+            Object.assign(this, customPayload);
+        }
+        static fromSerializable(data) {
+            const customPayload = pickDefinedErrorPayload(fieldNames, data);
+            const ErrorCtor = DefinedErrorImpl;
+            const error = new ErrorCtor({
+                ...customPayload,
+                id: data.id,
+                context: data.context,
+                traceId: data.traceId,
+            });
+            error[DEFINED_ERROR_PAYLOAD] = customPayload;
+            return Object.assign(error, customPayload);
+        }
+        toSerializable() {
+            return {
+                ...this.baseSerializable(),
+                type: this.name,
+                ...this[DEFINED_ERROR_PAYLOAD],
+            };
+        }
+    }
+    _a = DEFINED_ERROR_PAYLOAD;
+    Object.defineProperty(DefinedErrorImpl, "type", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: options.type
+    });
+    Object.defineProperty(DefinedErrorImpl, "schema", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: errorSchema
+    });
+    // @ts-expect-error TypeScript cannot model the dynamically assigned payload
+    // fields on the generated class instance constructor return type.
+    return DefinedErrorImpl;
+}
+function createUseHelper(getContractModule) {
+    return ((spec) => {
+        const contractModule = getContractModule();
+        assertValidUseSpec(contractModule.CONTRACT_ID, spec, contractModule.API.owned);
+        const dependencyUse = {
+            contract: contractModule.CONTRACT_ID,
+            ...(spec.rpc?.call ? { rpc: { call: [...spec.rpc.call] } } : {}),
+            ...(spec.operations?.call
+                ? { operations: { call: [...spec.operations.call] } }
+                : {}),
+            ...((spec.events?.publish || spec.events?.subscribe)
+                ? {
+                    events: {
+                        ...(spec.events.publish
+                            ? { publish: [...spec.events.publish] }
+                            : {}),
+                        ...(spec.events.subscribe
+                            ? { subscribe: [...spec.events.subscribe] }
+                            : {}),
+                    },
+                }
+                : {}),
+        };
+        return attachContractModuleMetadata(dependencyUse, contractModule);
+    });
+}
+function getContractModuleFromUse(alias, useValue) {
+    const contractModule = Object.getOwnPropertyDescriptor(useValue, CONTRACT_MODULE_METADATA)?.value;
+    if (!contractModule) {
+        throw new Error(`Contract use '${alias}' must be created with contractModule.use(...) from @qlever-llc/trellis/contracts`);
+    }
+    return contractModule;
+}
+function normalizeUses(uses) {
+    if (!uses) {
+        return {
+            manifestUses: undefined,
+            usedApi: { rpc: {}, operations: {}, events: {}, subjects: {} },
+        };
+    }
+    const manifestUses = {};
+    const usedApi = {
+        rpc: {},
+        operations: {},
+        events: {},
+        subjects: {},
+    };
+    for (const [alias, useValue] of Object.entries(uses)) {
+        const contractModule = getContractModuleFromUse(alias, useValue);
+        const rpcCall = useValue.rpc?.call;
+        const operationsCall = useValue.operations?.call;
+        const eventsPublish = useValue.events?.publish;
+        const eventsSubscribe = useValue.events?.subscribe;
+        if (useValue.contract !== contractModule.CONTRACT_ID) {
+            throw new Error(`Contract use '${alias}' references '${useValue.contract}' but module id is '${contractModule.CONTRACT_ID}'`);
+        }
+        assertValidUseSpec(contractModule.CONTRACT_ID, {
+            ...(rpcCall ? { rpc: { call: rpcCall } } : {}),
+            ...(operationsCall ? { operations: { call: operationsCall } } : {}),
+            ...((eventsPublish || eventsSubscribe)
+                ? {
+                    events: {
+                        ...(eventsPublish ? { publish: eventsPublish } : {}),
+                        ...(eventsSubscribe ? { subscribe: eventsSubscribe } : {}),
+                    },
+                }
+                : {}),
+        }, contractModule.API.owned);
+        manifestUses[alias] = {
+            contract: contractModule.CONTRACT_ID,
+            ...(rpcCall ? { rpc: { call: [...rpcCall] } } : {}),
+            ...(operationsCall ? { operations: { call: [...operationsCall] } } : {}),
+            ...((eventsPublish || eventsSubscribe)
+                ? {
+                    events: {
+                        ...(eventsPublish ? { publish: [...eventsPublish] } : {}),
+                        ...(eventsSubscribe ? { subscribe: [...eventsSubscribe] } : {}),
+                    },
+                }
+                : {}),
+        };
+        const rpcKeys = selectedKeys(rpcCall);
+        if (rpcKeys.length > 0) {
+            mergeRecord("rpc", usedApi.rpc, Object.fromEntries(rpcKeys.map((key) => [key, contractModule.API.owned.rpc[key]])));
+        }
+        const operationKeys = selectedKeys(operationsCall);
+        if (operationKeys.length > 0) {
+            mergeRecord("operations", usedApi.operations, Object.fromEntries(operationKeys.map((key) => [key, contractModule.API.owned.operations[key]])));
+        }
+        const eventKeys = new Set([
+            ...selectedKeys(eventsPublish),
+            ...selectedKeys(eventsSubscribe),
+        ]);
+        if (eventKeys.size > 0) {
+            mergeRecord("events", usedApi.events, Object.fromEntries([...eventKeys].map((key) => [key, contractModule.API.owned.events[key]])));
+        }
+    }
+    return { manifestUses, usedApi };
+}
+function emptyApi() {
+    return { rpc: {}, operations: {}, events: {}, subjects: {} };
+}
+function addUniqueStrings(target, values) {
+    for (const value of values) {
+        if (!target.includes(value)) {
+            target.push(value);
+        }
+    }
+}
+function mergeUseIntoManifest(manifestUses, alias, use) {
+    const existing = manifestUses[alias];
+    if (!existing) {
+        manifestUses[alias] = use;
+        return;
+    }
+    if (existing.contract !== use.contract) {
+        throw new Error(`Contract use '${alias}' references both '${existing.contract}' and '${use.contract}'`);
+    }
+    const rpcCall = [...(existing.rpc?.call ?? [])];
+    addUniqueStrings(rpcCall, use.rpc?.call ?? []);
+    const operationsCall = [...(existing.operations?.call ?? [])];
+    addUniqueStrings(operationsCall, use.operations?.call ?? []);
+    const eventsPublish = [...(existing.events?.publish ?? [])];
+    addUniqueStrings(eventsPublish, use.events?.publish ?? []);
+    const eventsSubscribe = [...(existing.events?.subscribe ?? [])];
+    addUniqueStrings(eventsSubscribe, use.events?.subscribe ?? []);
+    manifestUses[alias] = {
+        contract: existing.contract,
+        ...(rpcCall.length > 0 ? { rpc: { call: rpcCall } } : {}),
+        ...(operationsCall.length > 0
+            ? { operations: { call: operationsCall } }
+            : {}),
+        ...((eventsPublish.length > 0 || eventsSubscribe.length > 0)
+            ? {
+                events: {
+                    ...(eventsPublish.length > 0 ? { publish: eventsPublish } : {}),
+                    ...(eventsSubscribe.length > 0 ? { subscribe: eventsSubscribe } : {}),
+                },
+            }
+            : {}),
+    };
+}
+function mergeApiAllowDuplicateSubject(kind, out, next) {
+    for (const [key, value] of Object.entries(next)) {
+        const existing = out[key];
+        if (existing !== undefined) {
+            const existingSubject = typeof existing === "object" && existing !== null
+                ? existing.subject
+                : undefined;
+            const nextSubject = typeof value === "object" && value !== null
+                ? value.subject
+                : undefined;
+            if (typeof existingSubject === "string" && existingSubject === nextSubject) {
+                continue;
+            }
+            throw new Error(`Duplicate ${kind} key '${key}' while deriving contract API`);
+        }
+        out[key] = value;
+    }
+}
+function mergeUseIntoApi(target, api) {
+    mergeApiAllowDuplicateSubject("rpc", target.rpc, api.rpc);
+    mergeApiAllowDuplicateSubject("operations", target.operations, api.operations);
+    mergeApiAllowDuplicateSubject("events", target.events, api.events);
+    mergeApiAllowDuplicateSubject("subjects", target.subjects, api.subjects);
+}
+function baselineUse(contract, use, api) {
+    return { manifestUse: { contract, ...use }, api };
+}
+function deriveImplicitTrellisUses(source) {
+    const uses = {};
+    if (source.kind === "app" || source.kind === "agent" || source.kind === "device") {
+        uses.auth = baselineUse(TRELLIS_AUTH_CONTRACT_ID, { rpc: { call: [...BASELINE_AUTH_RPC_CALL] } }, BASELINE_AUTH_API);
+    }
+    if (source.state) {
+        uses.state = baselineUse(TRELLIS_STATE_CONTRACT_ID, { rpc: { call: [...BASELINE_STATE_RPC_CALL] } }, BASELINE_STATE_API);
+    }
+    return uses;
+}
+function normalizeContractUses(source) {
+    const explicit = normalizeUses(source.uses);
+    const manifestUses = {
+        ...(explicit.manifestUses ?? {}),
+    };
+    const usedApi = emptyApi();
+    mergeUseIntoApi(usedApi, explicit.usedApi);
+    for (const [alias, use] of Object.entries(deriveImplicitTrellisUses(source))) {
+        mergeUseIntoManifest(manifestUses, alias, use.manifestUse);
+        mergeUseIntoApi(usedApi, use.api);
+    }
+    return {
+        manifestUses: Object.keys(manifestUses).length > 0
+            ? manifestUses
+            : undefined,
+        usedApi,
+    };
+}
+function selectedKeys(keys) {
+    return keys ?? [];
+}
+function mergeApiSection(kind, usedEntries, ownedEntries) {
+    const merged = {};
+    mergeRecord(kind, merged, usedEntries);
+    mergeRecord(kind, merged, ownedEntries);
+    return merged;
+}
+function mergeDerivedApis(ownedApi, usedApi) {
+    return {
+        rpc: mergeApiSection("rpc", usedApi.rpc, ownedApi.rpc),
+        operations: mergeApiSection("operations", usedApi.operations, ownedApi.operations),
+        events: mergeApiSection("events", usedApi.events, ownedApi.events),
+        subjects: mergeApiSection("subjects", usedApi.subjects, ownedApi.subjects),
+    };
+}
+function defineContract(registry, build) {
+    assertRegistryDoesNotDeclareExports(registry);
+    const errorClasses = getErrorClassRegistry(registry.errors);
+    const normalizedErrors = normalizeErrorRegistry(registry.errors);
+    const body = build(createContractRefBuilder({
+        ...(registry.schemas ? { schemas: registry.schemas } : {}),
+        ...(errorClasses ? { errors: errorClasses } : {}),
+    }));
+    const materializedSchemas = materializeErrorSchemas(registry.schemas, normalizedErrors);
+    const source = {
+        ...body,
+        ...(materializedSchemas ? { schemas: materializedSchemas } : {}),
+        ...(normalizedErrors ? { errors: normalizedErrors } : {}),
+    };
+    assertExportedSchemasExist(source.schemas, source.exports);
+    const { manifestUses, usedApi } = normalizeContractUses(source);
+    const emittedSource = {
+        id: source.id,
+        displayName: source.displayName,
+        description: source.description,
+        kind: source.kind,
+        ...(source.schemas ? { schemas: source.schemas } : {}),
+        ...(source.exports ? { exports: source.exports } : {}),
+        ...(source.state ? { state: source.state } : {}),
+        ...(manifestUses ? { uses: manifestUses } : {}),
+        ...(source.rpc ? { rpc: source.rpc } : {}),
+        ...(source.operations ? { operations: source.operations } : {}),
+        ...(source.events ? { events: source.events } : {}),
+        ...(source.errors ? { errors: source.errors } : {}),
+        ...(source.jobs ? { jobs: source.jobs } : {}),
+        ...(source.resources ? { resources: source.resources } : {}),
+    };
+    const ownedApi = buildOwnedApi(emittedSource);
+    const trellisApi = mergeDerivedApis(ownedApi, usedApi);
+    const CONTRACT = emitContract(emittedSource);
+    const CONTRACT_DIGEST = digestContractManifest(CONTRACT);
+    let contract;
+    contract = {
+        CONTRACT_ID: source.id,
+        CONTRACT,
+        CONTRACT_DIGEST,
+        API: {
+            owned: ownedApi,
+            used: usedApi,
+            trellis: trellisApi,
+        },
+        use: createUseHelper(() => contract),
+        [CONTRACT_JOBS_METADATA]: buildContractJobsMetadata(source.jobs),
+        [CONTRACT_KV_METADATA]: buildContractKvMetadata(source.resources, source.schemas),
+        [CONTRACT_STATE_METADATA]: buildContractStateMetadata(source.state, source.schemas),
+    };
+    return contract;
+}
+export function defineServiceContract(registry, build) {
+    return defineContract(registry, (ref) => ({
+        ...build(ref),
+        kind: "service",
+    }));
+}
+function defineClientContract(kind, registry, build) {
+    return defineContract(registry, (ref) => ({ ...build(ref), kind }));
+}
+export function defineAppContract(...args) {
+    const [registryOrBuild, maybeBuild] = args;
+    if (typeof registryOrBuild === "function") {
+        return defineClientContract("app", {}, () => registryOrBuild());
+    }
+    return defineClientContract("app", registryOrBuild, maybeBuild);
+}
+export function defineAgentContract(...args) {
+    const [registryOrBuild, maybeBuild] = args;
+    if (typeof registryOrBuild === "function") {
+        return defineClientContract("agent", {}, () => registryOrBuild());
+    }
+    return defineClientContract("agent", registryOrBuild, maybeBuild);
+}
+export function defineDeviceContract(...args) {
+    const [registryOrBuild, maybeBuild] = args;
+    if (typeof registryOrBuild === "function") {
+        return defineClientContract("device", {}, () => registryOrBuild());
+    }
+    return defineClientContract("device", registryOrBuild, maybeBuild);
+}
+export { canonicalizeJson, digestJson, isJsonValue, schema, unwrapSchema };