@qlever-llc/trellis 0.10.2 → 0.10.3-rc.4

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

@@ -1,2182 +0,0 @@
-import Type from "typebox";
-import { Value } from "typebox/value";
-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";
-import { ContractEventConsumersSchema, ContractJobQueueSchema, ContractResourcesSchema, ContractSchemaRefSchema, ContractStateSchema, } from "./protocol.js";
-export { ContractEventConsumerEventSchema, ContractEventConsumerGroupSchema, ContractEventConsumersSchema, ContractJobQueueSchema, ContractJobsSchema, ContractKvResourceSchema, ContractResourceBindingsSchema, ContractResourcesSchema, ContractSchemaRefSchema, ContractStateSchema, ContractStateStoreSchema, ContractStoreResourceSchema, EventConsumerResourceBindingSchema, EventHeaderSchema, InstalledServiceContractSchema, IsoDateSchema, JobsQueueBindingSchema, JobsResourceBindingSchema, KvResourceBindingSchema, PageRequestSchema, PageResponseSchema, StoreResourceBindingSchema, } from "./protocol.js";
-export const CONTRACT_FORMAT_V1 = "trellis.contract.v1";
-export const CATALOG_FORMAT_V1 = "trellis.catalog.v1";
-const NonEmptyStringSchema = Type.String({ minLength: 1 });
-const VersionSchema = Type.String({ pattern: "^v[0-9]+$" });
-const PointerStringSchema = Type.String({ pattern: "^/.*" });
-const CapabilityListSchema = Type.Array(NonEmptyStringSchema);
-const JsonSchemaValueSchema = Type.Union([
-    Type.Object({}, { additionalProperties: true }),
-    Type.Boolean(),
-]);
-export const ContractDocsSchema = Type.Object({
-    summary: Type.Optional(Type.String()),
-    markdown: Type.String(),
-});
-export const ContractCapabilityMetadataSchema = Type.Object({
-    displayName: NonEmptyStringSchema,
-    description: NonEmptyStringSchema,
-    consequence: Type.Optional(NonEmptyStringSchema),
-});
-export const ContractCapabilitiesSchema = Type.Record(NonEmptyStringSchema, ContractCapabilityMetadataSchema);
-export const ContractExportsSchema = Type.Object({
-    schemas: Type.Optional(Type.Array(NonEmptyStringSchema, { uniqueItems: true })),
-});
-const ContractUseRpcSchema = Type.Object({
-    call: Type.Optional(CapabilityListSchema),
-});
-const ContractUsePubSubSchema = Type.Object({
-    publish: Type.Optional(CapabilityListSchema),
-    subscribe: Type.Optional(CapabilityListSchema),
-});
-const ContractUseFeedSchema = Type.Object({
-    subscribe: Type.Optional(CapabilityListSchema),
-});
-const ContractUseSchema = Type.Object({
-    contract: NonEmptyStringSchema,
-    rpc: Type.Optional(ContractUseRpcSchema),
-    operations: Type.Optional(ContractUseRpcSchema),
-    events: Type.Optional(ContractUsePubSubSchema),
-    feeds: Type.Optional(ContractUseFeedSchema),
-});
-const ContractUsesFlatSchema = Type.Record(NonEmptyStringSchema, ContractUseSchema);
-export const ContractUsesSchema = Type.Object({
-    required: Type.Optional(ContractUsesFlatSchema),
-    optional: Type.Optional(ContractUsesFlatSchema),
-});
-const ContractErrorDeclSchema = Type.Object({
-    type: NonEmptyStringSchema,
-    schema: Type.Optional(ContractSchemaRefSchema),
-});
-const ContractErrorRefSchema = Type.Object({
-    type: NonEmptyStringSchema,
-});
-const ContractOperationSignalSchema = Type.Object({
-    input: ContractSchemaRefSchema,
-    docs: Type.Optional(ContractDocsSchema),
-});
-const RpcCapabilitiesSchema = Type.Object({
-    call: Type.Optional(CapabilityListSchema),
-});
-const OperationCapabilitiesSchema = Type.Object({
-    call: Type.Optional(CapabilityListSchema),
-    observe: Type.Optional(CapabilityListSchema),
-    cancel: Type.Optional(CapabilityListSchema),
-    control: Type.Optional(CapabilityListSchema),
-});
-const PubSubCapabilitiesSchema = Type.Object({
-    publish: Type.Optional(CapabilityListSchema),
-    subscribe: Type.Optional(CapabilityListSchema),
-});
-const FeedCapabilitiesSchema = Type.Object({
-    subscribe: Type.Optional(CapabilityListSchema),
-});
-const RpcTransferSchema = Type.Object({
-    direction: Type.Literal("receive"),
-});
-const OperationTransferSchema = Type.Object({
-    direction: Type.Literal("send"),
-    store: NonEmptyStringSchema,
-    key: PointerStringSchema,
-    contentType: Type.Optional(PointerStringSchema),
-    metadata: Type.Optional(PointerStringSchema),
-    expiresInMs: Type.Optional(Type.Integer({ minimum: 1 })),
-    maxBytes: Type.Optional(Type.Integer({ minimum: 1 })),
-});
-const ContractRpcMethodSchema = Type.Object({
-    version: VersionSchema,
-    subject: NonEmptyStringSchema,
-    input: ContractSchemaRefSchema,
-    output: ContractSchemaRefSchema,
-    capabilities: Type.Optional(RpcCapabilitiesSchema),
-    errors: Type.Optional(Type.Array(ContractErrorRefSchema)),
-    transfer: Type.Optional(RpcTransferSchema),
-    internal: Type.Optional(Type.Boolean()),
-    docs: Type.Optional(ContractDocsSchema),
-});
-const ContractOperationSchema = Type.Object({
-    version: VersionSchema,
-    subject: NonEmptyStringSchema,
-    input: ContractSchemaRefSchema,
-    progress: Type.Optional(ContractSchemaRefSchema),
-    output: ContractSchemaRefSchema,
-    transfer: Type.Optional(OperationTransferSchema),
-    capabilities: Type.Optional(OperationCapabilitiesSchema),
-    signals: Type.Optional(Type.Record(NonEmptyStringSchema, ContractOperationSignalSchema)),
-    cancel: Type.Optional(Type.Boolean()),
-    docs: Type.Optional(ContractDocsSchema),
-});
-const ContractEventSchema = Type.Object({
-    version: VersionSchema,
-    subject: NonEmptyStringSchema,
-    params: Type.Optional(Type.Array(PointerStringSchema)),
-    event: ContractSchemaRefSchema,
-    capabilities: Type.Optional(PubSubCapabilitiesSchema),
-    docs: Type.Optional(ContractDocsSchema),
-});
-const ContractFeedSchema = Type.Object({
-    version: VersionSchema,
-    subject: NonEmptyStringSchema,
-    input: ContractSchemaRefSchema,
-    event: ContractSchemaRefSchema,
-    capabilities: Type.Optional(FeedCapabilitiesSchema),
-    docs: Type.Optional(ContractDocsSchema),
-});
-export const TrellisContractV1Schema = Type.Object({
-    format: Type.Literal(CONTRACT_FORMAT_V1),
-    id: NonEmptyStringSchema,
-    displayName: NonEmptyStringSchema,
-    description: NonEmptyStringSchema,
-    docs: Type.Optional(ContractDocsSchema),
-    kind: Type.Union([
-        Type.Literal("service"),
-        Type.Literal("app"),
-        Type.Literal("device"),
-        Type.Literal("agent"),
-    ]),
-    capabilities: Type.Optional(ContractCapabilitiesSchema),
-    schemas: Type.Optional(Type.Record(NonEmptyStringSchema, JsonSchemaValueSchema)),
-    exports: Type.Optional(ContractExportsSchema),
-    uses: Type.Optional(ContractUsesSchema),
-    state: Type.Optional(ContractStateSchema),
-    rpc: Type.Optional(Type.Record(NonEmptyStringSchema, ContractRpcMethodSchema)),
-    operations: Type.Optional(Type.Record(NonEmptyStringSchema, ContractOperationSchema)),
-    events: Type.Optional(Type.Record(NonEmptyStringSchema, ContractEventSchema)),
-    feeds: Type.Optional(Type.Record(NonEmptyStringSchema, ContractFeedSchema)),
-    errors: Type.Optional(Type.Record(NonEmptyStringSchema, ContractErrorDeclSchema)),
-    jobs: Type.Optional(Type.Record(NonEmptyStringSchema, ContractJobQueueSchema)),
-    eventConsumers: Type.Optional(ContractEventConsumersSchema),
-    resources: Type.Optional(ContractResourcesSchema),
-});
-export const TrellisCatalogV1Schema = Type.Object({
-    format: Type.Literal(CATALOG_FORMAT_V1),
-    contracts: Type.Array(Type.Object({
-        id: NonEmptyStringSchema,
-        digest: Type.String({ pattern: "^[A-Za-z0-9_-]+$" }),
-        displayName: NonEmptyStringSchema,
-        description: NonEmptyStringSchema,
-    })),
-});
-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 TRELLIS_HEALTH_CONTRACT_ID = "trellis.health@v1";
-const BASELINE_AUTH_RPC_CALL = [
-    "Auth.Sessions.Me",
-    "Auth.Sessions.Logout",
-];
-const BASELINE_STATE_RPC_CALL = [
-    "State.Get",
-    "State.Put",
-    "State.Delete",
-    "State.List",
-];
-const BASELINE_HEALTH_EVENTS_PUBLISH = ["Health.Heartbeat"];
-const UnknownRuntimeSchema = schema(Type.Unknown());
-function typedUnknownRuntimeSchema() {
-    return UnknownRuntimeSchema;
-}
-function trellisRpcDesc(name) {
-    return {
-        subject: rpcSubject(name, "v1"),
-        input: typedUnknownRuntimeSchema(),
-        output: typedUnknownRuntimeSchema(),
-        callerCapabilities: [],
-    };
-}
-function trellisEventDesc(name) {
-    return {
-        subject: eventSubject(name, "v1", undefined),
-        event: typedUnknownRuntimeSchema(),
-        publishCapabilities: [],
-        subscribeCapabilities: [],
-    };
-}
-const BASELINE_AUTH_API = {
-    rpc: {
-        "Auth.Sessions.Me": trellisRpcDesc("Auth.Sessions.Me"),
-        "Auth.Sessions.Logout": trellisRpcDesc("Auth.Sessions.Logout"),
-    },
-    operations: {},
-    events: {},
-    feeds: {},
-    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: {},
-    feeds: {},
-    subjects: {},
-};
-const BASELINE_HEALTH_API = {
-    rpc: {},
-    operations: {},
-    events: {
-        "Health.Heartbeat": trellisEventDesc("Health.Heartbeat"),
-    },
-    feeds: {},
-    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;
-        },
-        capability(capabilityName) {
-            return capabilityName;
-        },
-    };
-}
-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 assertRegistryDoesNotDeclareCapabilities(registry) {
-    if (Object.hasOwn(registry, "capabilities")) {
-        throw new Error("contract capabilities must be declared in the callback body, not the registry argument");
-    }
-}
-function resolveSchemaRef(schemas, ref, context) {
-    assertSchemaRefExists(schemas, ref, context);
-    const schema = schemas?.[ref.schema];
-    if (!schema) {
-        throw new Error(`${context} references missing schema '${ref.schema}'`);
-    }
-    return cloneSchema(schema);
-}
-function digestCanonicalJson(value) {
-    return sha256Base64urlSync(canonicalizeJson(value));
-}
-function sortedUnique(values) {
-    return [...new Set(values)].sort();
-}
-/** Return the global capability namespace for a contract id. */
-export function contractCapabilityNamespace(contractId) {
-    return contractId.replace(/@v\d+$/, "");
-}
-/** Return the globally qualified name for a contract-local capability. */
-export function globalCapabilityName(contractId, localCapability) {
-    assertLocalCapabilityDoesNotDuplicateNamespace(contractId, localCapability);
-    return `${contractCapabilityNamespace(contractId)}::${localCapability}`;
-}
-function assertLocalCapabilityDoesNotDuplicateNamespace(contractId, localCapability) {
-    for (const prefix of localCapabilityNamespacePrefixes(contractId)) {
-        if (localCapability.startsWith(prefix)) {
-            throw new Error(`local capability '${localCapability}' must not start with contract namespace prefix '${prefix}'`);
-        }
-    }
-}
-function localCapabilityNamespacePrefixes(contractId) {
-    const namespace = contractCapabilityNamespace(contractId);
-    const prefixes = [`${namespace}.`];
-    const namespaceSegments = namespace.split(".");
-    const leaf = namespaceSegments[namespaceSegments.length - 1];
-    if (leaf && leaf !== namespace)
-        prefixes.push(`${leaf}.`);
-    return prefixes;
-}
-function projectCapabilities(capabilities, contractId, declaredCapabilities, context) {
-    if (!capabilities) {
-        return undefined;
-    }
-    return sortedUnique(capabilities.map((capability) => {
-        if (declaredCapabilities && Object.hasOwn(declaredCapabilities, capability)) {
-            return globalCapabilityName(contractId, capability);
-        }
-        if (capability === "admin" || capability === "service" ||
-            capability.includes("::")) {
-            return capability;
-        }
-        throw new Error(`${context} references undeclared local capability '${capability}'`);
-    }));
-}
-function emitCapabilities(contractId, capabilities) {
-    if (!capabilities) {
-        return undefined;
-    }
-    const entries = Object.entries(capabilities)
-        .map(([localCapability, metadata]) => [
-        globalCapabilityName(contractId, localCapability),
-        { ...metadata },
-    ]);
-    entries.sort(([left], [right]) => left.localeCompare(right));
-    return Object.fromEntries(entries);
-}
-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 signal of Object.values(operation.signals ?? {})) {
-            collectSchemaRef(reachableSchemas, signal.input);
-        }
-    }
-    for (const event of Object.values(contract.events ?? {})) {
-        collectSchemaRef(reachableSchemas, event.event);
-    }
-    for (const feed of Object.values(contract.feeds ?? {})) {
-        collectSchemaRef(reachableSchemas, feed.input);
-        collectSchemaRef(reachableSchemas, feed.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: mapValues(resources.kv, omitDocs),
-            }
-            : {}),
-        ...(resources.store
-            ? {
-                store: mapValues(resources.store, omitDocs),
-            }
-            : {}),
-    };
-}
-function projectDigestState(state) {
-    return state ? mapValues(state, omitDocs) : undefined;
-}
-function projectDigestJobs(jobs) {
-    return jobs ? mapValues(jobs, omitDocs) : undefined;
-}
-function projectDigestEventConsumers(eventConsumers) {
-    return eventConsumers ? mapValues(eventConsumers, omitDocs) : undefined;
-}
-function projectDigestUsesFlat(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) }
-                            : {}),
-                    },
-                }
-                : {}),
-            ...(use.feeds?.subscribe
-                ? { feeds: { subscribe: sortedUnique(use.feeds.subscribe) } }
-                : {}),
-        },
-    ]));
-}
-function omitRequiredUseAliases(optional, required) {
-    if (!optional) {
-        return undefined;
-    }
-    if (!required) {
-        return optional;
-    }
-    const requiredAliases = new Set(Object.keys(required));
-    const entries = Object.entries(optional).filter(([alias]) => !requiredAliases.has(alias));
-    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
-}
-function projectDigestUses(uses) {
-    if (!uses) {
-        return undefined;
-    }
-    const required = projectDigestUsesFlat(uses.required);
-    const optional = omitRequiredUseAliases(projectDigestUsesFlat(uses.optional), required);
-    if (!required && !optional) {
-        return undefined;
-    }
-    return {
-        ...(required ? { required } : {}),
-        ...(optional ? { optional } : {}),
-    };
-}
-function projectDigestRpc(rpc) {
-    if (!rpc) {
-        return undefined;
-    }
-    return Object.fromEntries(Object.entries(rpc).map(([name, method]) => {
-        const projected = omitDocs(method);
-        return [
-            name,
-            {
-                ...projected,
-                ...(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]) => {
-        const projected = omitDocs(operation);
-        return [
-            name,
-            {
-                ...projected,
-                ...(operation.signals
-                    ? {
-                        signals: mapValues(operation.signals, omitDocs),
-                    }
-                    : {}),
-                ...((operation.capabilities?.call ||
-                    operation.capabilities?.observe ||
-                    operation.capabilities?.cancel || operation.capabilities?.control)
-                    ? {
-                        capabilities: {
-                            ...(operation.capabilities.call
-                                ? { call: sortedUnique(operation.capabilities.call) }
-                                : {}),
-                            ...(operation.capabilities.observe
-                                ? { observe: sortedUnique(operation.capabilities.observe) }
-                                : {}),
-                            ...(operation.capabilities.cancel
-                                ? { cancel: sortedUnique(operation.capabilities.cancel) }
-                                : {}),
-                            ...(operation.capabilities.control
-                                ? { control: sortedUnique(operation.capabilities.control) }
-                                : {}),
-                        },
-                    }
-                    : {}),
-            },
-        ];
-    }));
-}
-function projectDigestEvents(events) {
-    if (!events) {
-        return undefined;
-    }
-    return Object.fromEntries(Object.entries(events).map(([name, event]) => {
-        const projected = omitDocs(event);
-        return [
-            name,
-            {
-                ...projected,
-                ...((event.capabilities?.publish || event.capabilities?.subscribe)
-                    ? {
-                        capabilities: {
-                            ...(event.capabilities.publish
-                                ? { publish: sortedUnique(event.capabilities.publish) }
-                                : {}),
-                            ...(event.capabilities.subscribe
-                                ? { subscribe: sortedUnique(event.capabilities.subscribe) }
-                                : {}),
-                        },
-                    }
-                    : {}),
-            },
-        ];
-    }));
-}
-function projectDigestFeeds(feeds) {
-    if (!feeds) {
-        return undefined;
-    }
-    return Object.fromEntries(Object.entries(feeds).map(([name, feed]) => {
-        const projected = omitDocs(feed);
-        return [
-            name,
-            {
-                ...projected,
-                ...(feed.capabilities?.subscribe
-                    ? {
-                        capabilities: {
-                            subscribe: sortedUnique(feed.capabilities.subscribe),
-                        },
-                    }
-                    : {}),
-            },
-        ];
-    }));
-}
-function mapValues(values, map) {
-    if (!values)
-        return undefined;
-    return Object.fromEntries(Object.entries(values).map(([key, value]) => [key, map(value)]));
-}
-function omitDocs(value) {
-    const projected = { ...value };
-    delete projected.docs;
-    return projected;
-}
-function contractDocs(docs) {
-    if (!docs)
-        return undefined;
-    return {
-        ...(docs.summary !== undefined ? { summary: docs.summary } : {}),
-        markdown: docs.markdown,
-    };
-}
-function schemaRef(ref) {
-    return { schema: ref.schema };
-}
-function capabilityMetadata(metadata) {
-    return {
-        displayName: metadata.displayName,
-        description: metadata.description,
-        ...(metadata.consequence ? { consequence: metadata.consequence } : {}),
-    };
-}
-function useRpc(use) {
-    if (!use)
-        return undefined;
-    return {
-        ...(use.call ? { call: [...use.call] } : {}),
-    };
-}
-function usePubSub(use) {
-    if (!use)
-        return undefined;
-    return {
-        ...(use.publish ? { publish: [...use.publish] } : {}),
-        ...(use.subscribe ? { subscribe: [...use.subscribe] } : {}),
-    };
-}
-function contractUse(use) {
-    return {
-        contract: use.contract,
-        ...(use.rpc ? { rpc: useRpc(use.rpc) } : {}),
-        ...(use.operations ? { operations: useRpc(use.operations) } : {}),
-        ...(use.events ? { events: usePubSub(use.events) } : {}),
-        ...(use.feeds
-            ? {
-                feeds: {
-                    ...(use.feeds.subscribe
-                        ? { subscribe: [...use.feeds.subscribe] }
-                        : {}),
-                },
-            }
-            : {}),
-    };
-}
-function contractUses(uses) {
-    if (!uses)
-        return undefined;
-    return {
-        ...(uses.required
-            ? { required: mapValues(uses.required, contractUse) }
-            : {}),
-        ...(uses.optional
-            ? { optional: mapValues(uses.optional, contractUse) }
-            : {}),
-    };
-}
-function stateStore(store) {
-    return {
-        kind: store.kind,
-        schema: schemaRef(store.schema),
-        ...(store.stateVersion ? { stateVersion: store.stateVersion } : {}),
-        ...(store.acceptedVersions
-            ? { acceptedVersions: mapValues(store.acceptedVersions, schemaRef) }
-            : {}),
-        ...(store.docs ? { docs: contractDocs(store.docs) } : {}),
-    };
-}
-function rpcMethod(method) {
-    return {
-        version: method.version,
-        subject: method.subject,
-        input: schemaRef(method.input),
-        output: schemaRef(method.output),
-        ...(method.transfer
-            ? { transfer: { direction: method.transfer.direction } }
-            : {}),
-        ...(method.capabilities?.call
-            ? { capabilities: { call: [...method.capabilities.call] } }
-            : {}),
-        ...(method.errors
-            ? { errors: method.errors.map((error) => ({ type: error.type })) }
-            : {}),
-        ...(method.docs ? { docs: contractDocs(method.docs) } : {}),
-    };
-}
-function operation(operation) {
-    return {
-        version: operation.version,
-        subject: operation.subject,
-        input: schemaRef(operation.input),
-        ...(operation.progress ? { progress: schemaRef(operation.progress) } : {}),
-        output: schemaRef(operation.output),
-        ...(operation.transfer
-            ? {
-                transfer: {
-                    direction: operation.transfer.direction,
-                    store: operation.transfer.store,
-                    key: operation.transfer.key,
-                    ...(operation.transfer.contentType
-                        ? { contentType: operation.transfer.contentType }
-                        : {}),
-                    ...(operation.transfer.metadata
-                        ? { metadata: operation.transfer.metadata }
-                        : {}),
-                    ...(operation.transfer.expiresInMs !== undefined
-                        ? { expiresInMs: operation.transfer.expiresInMs }
-                        : {}),
-                    ...(operation.transfer.maxBytes !== undefined
-                        ? { maxBytes: operation.transfer.maxBytes }
-                        : {}),
-                },
-            }
-            : {}),
-        ...(operation.capabilities
-            ? {
-                capabilities: {
-                    ...(operation.capabilities.call
-                        ? { call: [...operation.capabilities.call] }
-                        : {}),
-                    ...(operation.capabilities.observe
-                        ? { observe: [...operation.capabilities.observe] }
-                        : {}),
-                    ...(operation.capabilities.cancel
-                        ? { cancel: [...operation.capabilities.cancel] }
-                        : {}),
-                    ...(operation.capabilities.control
-                        ? { control: [...operation.capabilities.control] }
-                        : {}),
-                },
-            }
-            : {}),
-        ...(operation.signals
-            ? {
-                signals: mapValues(operation.signals, (signal) => ({
-                    input: schemaRef(signal.input),
-                    ...(signal.docs ? { docs: contractDocs(signal.docs) } : {}),
-                })),
-            }
-            : {}),
-        ...(operation.cancel !== undefined ? { cancel: operation.cancel } : {}),
-        ...(operation.docs ? { docs: contractDocs(operation.docs) } : {}),
-    };
-}
-function event(event) {
-    return {
-        version: event.version,
-        subject: event.subject,
-        ...(event.params ? { params: [...event.params] } : {}),
-        event: schemaRef(event.event),
-        ...(event.capabilities
-            ? {
-                capabilities: {
-                    ...(event.capabilities.publish
-                        ? { publish: [...event.capabilities.publish] }
-                        : {}),
-                    ...(event.capabilities.subscribe
-                        ? { subscribe: [...event.capabilities.subscribe] }
-                        : {}),
-                },
-            }
-            : {}),
-        ...(event.docs ? { docs: contractDocs(event.docs) } : {}),
-    };
-}
-function feed(feed) {
-    return {
-        version: feed.version,
-        subject: feed.subject,
-        input: schemaRef(feed.input),
-        event: schemaRef(feed.event),
-        ...(feed.capabilities?.subscribe
-            ? { capabilities: { subscribe: [...feed.capabilities.subscribe] } }
-            : {}),
-        ...(feed.docs ? { docs: contractDocs(feed.docs) } : {}),
-    };
-}
-function eventConsumerEvent(event) {
-    return { use: event.use, event: event.event };
-}
-function sortEventConsumerEvents(events) {
-    return events.map(eventConsumerEvent).sort((left, right) => left.use.localeCompare(right.use) || left.event.localeCompare(right.event));
-}
-function eventConsumerGroup(group) {
-    return {
-        events: sortEventConsumerEvents(group.events),
-        replay: group.replay ?? "new",
-        ordering: group.ordering ?? "strict",
-        concurrency: group.concurrency ?? 1,
-        ...(group.ackWaitMs !== undefined ? { ackWaitMs: group.ackWaitMs } : {}),
-        ...(group.maxDeliver !== undefined ? { maxDeliver: group.maxDeliver } : {}),
-        ...(group.backoffMs ? { backoffMs: [...group.backoffMs] } : {}),
-        ...(group.docs ? { docs: contractDocs(group.docs) } : {}),
-    };
-}
-function errorDecl(error) {
-    return {
-        type: error.type,
-        ...(error.schema ? { schema: schemaRef(error.schema) } : {}),
-    };
-}
-function jobQueue(queue) {
-    return {
-        payload: schemaRef(queue.payload),
-        ...(queue.result ? { result: schemaRef(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 }
-            : {}),
-        ...(queue.docs ? { docs: contractDocs(queue.docs) } : {}),
-    };
-}
-function kvResource(resource) {
-    return {
-        purpose: resource.purpose,
-        schema: schemaRef(resource.schema),
-        ...(resource.required !== undefined ? { required: resource.required } : {}),
-        ...(resource.history !== undefined ? { history: resource.history } : {}),
-        ...(resource.ttlMs !== undefined ? { ttlMs: resource.ttlMs } : {}),
-        ...(resource.maxValueBytes !== undefined
-            ? { maxValueBytes: resource.maxValueBytes }
-            : {}),
-        ...(resource.docs ? { docs: contractDocs(resource.docs) } : {}),
-    };
-}
-function storeResource(resource) {
-    return {
-        purpose: resource.purpose,
-        ...(resource.required !== undefined ? { required: resource.required } : {}),
-        ...(resource.ttlMs !== undefined ? { ttlMs: resource.ttlMs } : {}),
-        ...(resource.maxObjectBytes !== undefined
-            ? { maxObjectBytes: resource.maxObjectBytes }
-            : {}),
-        ...(resource.maxTotalBytes !== undefined
-            ? { maxTotalBytes: resource.maxTotalBytes }
-            : {}),
-        ...(resource.docs ? { docs: contractDocs(resource.docs) } : {}),
-    };
-}
-/**
- * Return the canonical manifest shape used by Trellis runtimes before
- * validation, persistence, and digesting.
- *
- * This is not the digest projection: human-facing fields such as
- * `displayName` and `description` are preserved here even though they are not
- * part of contract identity. Unknown extension fields are intentionally omitted
- * until the runtime explicitly supports them.
- */
-export function normalizeContractManifest(contract) {
-    return {
-        format: contract.format,
-        id: contract.id,
-        displayName: contract.displayName,
-        description: contract.description,
-        ...(contract.docs ? { docs: contractDocs(contract.docs) } : {}),
-        kind: contract.kind,
-        ...(contract.capabilities
-            ? { capabilities: mapValues(contract.capabilities, capabilityMetadata) }
-            : {}),
-        ...(contract.schemas ? { schemas: contract.schemas } : {}),
-        ...(contract.exports
-            ? {
-                exports: {
-                    ...(contract.exports.schemas
-                        ? { schemas: [...contract.exports.schemas] }
-                        : {}),
-                },
-            }
-            : {}),
-        ...(contract.uses ? { uses: contractUses(contract.uses) } : {}),
-        ...(contract.state ? { state: mapValues(contract.state, stateStore) } : {}),
-        ...(contract.rpc ? { rpc: mapValues(contract.rpc, rpcMethod) } : {}),
-        ...(contract.operations
-            ? { operations: mapValues(contract.operations, operation) }
-            : {}),
-        ...(contract.events ? { events: mapValues(contract.events, event) } : {}),
-        ...(contract.feeds ? { feeds: mapValues(contract.feeds, feed) } : {}),
-        ...(contract.jobs ? { jobs: mapValues(contract.jobs, jobQueue) } : {}),
-        ...(contract.eventConsumers
-            ? {
-                eventConsumers: mapValues(contract.eventConsumers, eventConsumerGroup),
-            }
-            : {}),
-        ...(contract.resources
-            ? {
-                resources: {
-                    ...(contract.resources.kv
-                        ? { kv: mapValues(contract.resources.kv, kvResource) }
-                        : {}),
-                    ...(contract.resources.store
-                        ? { store: mapValues(contract.resources.store, storeResource) }
-                        : {}),
-                },
-            }
-            : {}),
-        ...(contract.errors
-            ? { errors: mapValues(contract.errors, errorDecl) }
-            : {}),
-    };
-}
-/**
- * Parse untrusted contract JSON into the current Trellis v1 manifest shape.
- *
- * Unknown extension fields are accepted for forward compatibility but are not
- * returned. Callers must use the returned value for persistence and digesting.
- */
-export function parseContractManifest(value) {
-    let parsed;
-    try {
-        parsed = Value.Parse(TrellisContractV1Schema, value);
-    }
-    catch (error) {
-        const details = [...Value.Errors(TrellisContractV1Schema, value)].map((entry) => `${entry.instancePath || "#"}: ${entry.message}`);
-        throw new TypeError(`Invalid contract${details.length > 0 ? `:\n${details.join("\n")}` : ""}`, { cause: error });
-    }
-    const contract = normalizeContractManifest(parsed);
-    assertValidEventConsumers(contract.eventConsumers, contract.uses);
-    return contract;
-}
-/**
- * Build the normalized runtime/interface projection used for contract identity.
- */
-export function projectContractDigestManifest(contract) {
-    const schemas = projectReachableSchemas(contract);
-    const errors = projectRpcDeclaredErrors(contract);
-    const state = projectDigestState(contract.state);
-    const resources = projectDigestResources(contract.resources);
-    const jobs = projectDigestJobs(contract.jobs);
-    const eventConsumers = projectDigestEventConsumers(contract.eventConsumers);
-    const uses = projectDigestUses(contract.uses);
-    const rpc = projectDigestRpc(contract.rpc);
-    const operations = projectDigestOperations(contract.operations);
-    const events = projectDigestEvents(contract.events);
-    const feeds = projectDigestFeeds(contract.feeds);
-    return {
-        format: contract.format,
-        id: contract.id,
-        kind: contract.kind,
-        ...(contract.capabilities ? { capabilities: contract.capabilities } : {}),
-        ...(schemas ? { schemas } : {}),
-        ...(state ? { state } : {}),
-        ...(uses ? { uses } : {}),
-        ...(rpc ? { rpc } : {}),
-        ...(operations ? { operations } : {}),
-        ...(events ? { events } : {}),
-        ...(feeds ? { feeds } : {}),
-        ...(errors ? { errors } : {}),
-        ...(jobs ? { jobs } : {}),
-        ...(eventConsumers ? { eventConsumers } : {}),
-        ...(resources ? { resources } : {}),
-    };
-}
-/** Compute the v1 contract digest from the normalized digest projection. */
-export function digestContractManifest(contract) {
-    return digestCanonicalJson(projectContractDigestManifest(normalizeContractManifest(contract)));
-}
-function rpcSubject(name, version) {
-    return `rpc.${version}.${name}`;
-}
-function operationSubject(name, version) {
-    return `operations.${version}.${name}`;
-}
-function feedSubject(name, version) {
-    return `feeds.${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 }
-                            : {}),
-                        ...(resource.docs ? { docs: contractDocs(resource.docs) } : {}),
-                    },
-                ])),
-            }
-            : {}),
-        ...(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 }
-                            : {}),
-                        ...(resource.docs ? { docs: contractDocs(resource.docs) } : {}),
-                    },
-                ])),
-            }
-            : {}),
-    };
-}
-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 }
-                : {}),
-            ...(queue.docs ? { docs: contractDocs(queue.docs) } : {}),
-        },
-    ]));
-}
-function emitEventConsumers(eventConsumers) {
-    if (!eventConsumers) {
-        return undefined;
-    }
-    return Object.fromEntries(Object.entries(eventConsumers).map(([groupName, group]) => [
-        groupName,
-        {
-            events: sortEventConsumerEvents(group.events),
-            replay: group.replay ?? "new",
-            ordering: group.ordering ?? "strict",
-            concurrency: group.concurrency ?? 1,
-            ...(group.ackWaitMs !== undefined
-                ? { ackWaitMs: group.ackWaitMs }
-                : {}),
-            ...(group.maxDeliver !== undefined
-                ? { maxDeliver: group.maxDeliver }
-                : {}),
-            ...(group.backoffMs ? { backoffMs: [...group.backoffMs] } : {}),
-            ...(group.docs ? { docs: contractDocs(group.docs) } : {}),
-        },
-    ]));
-}
-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}'`);
-        const schema = schemas?.[resource.schema.schema];
-        if (!schema) {
-            throw new Error(`kv resource '${alias}' references missing schema '${resource.schema.schema}'`);
-        }
-        metadata[alias] = {
-            required: resource.required ?? true,
-            value: undefined,
-            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 }),
-            ...(store.docs ? { docs: contractDocs(store.docs) } : {}),
-        },
-    ]));
-}
-function emitUsesFlat(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) }
-                            : {}),
-                    },
-                }
-                : {}),
-            ...(use.feeds?.subscribe
-                ? { feeds: { subscribe: sortedUnique(use.feeds.subscribe) } }
-                : {}),
-        },
-    ]));
-}
-function emitUses(uses) {
-    if (!uses) {
-        return undefined;
-    }
-    const required = emitUsesFlat(uses.required);
-    const optional = omitRequiredUseAliases(emitUsesFlat(uses.optional), required);
-    if (!required && !optional) {
-        return undefined;
-    }
-    return {
-        ...(required ? { required } : {}),
-        ...(optional ? { optional } : {}),
-    };
-}
-function emitContract(source) {
-    const capabilities = emitCapabilities(source.id, source.capabilities);
-    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: projectCapabilities(method.capabilities.call, source.id, source.capabilities, `rpc '${name}' call capabilities`) ?? [],
-                };
-            }
-            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 }));
-            }
-            if (method.internal) {
-                emitted.internal = true;
-            }
-            if (method.docs) {
-                emitted.docs = contractDocs(method.docs);
-            }
-            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?.observe ||
-                operation.capabilities?.cancel || operation.capabilities?.control) {
-                emitted.capabilities = {
-                    ...(operation.capabilities.call
-                        ? {
-                            call: projectCapabilities(operation.capabilities.call, source.id, source.capabilities, `operation '${name}' call capabilities`) ?? [],
-                        }
-                        : {}),
-                    ...(operation.capabilities.observe
-                        ? {
-                            observe: projectCapabilities(operation.capabilities.observe, source.id, source.capabilities, `operation '${name}' observe capabilities`) ?? [],
-                        }
-                        : {}),
-                    ...(operation.capabilities.cancel
-                        ? {
-                            cancel: projectCapabilities(operation.capabilities.cancel, source.id, source.capabilities, `operation '${name}' cancel capabilities`) ?? [],
-                        }
-                        : {}),
-                    ...(operation.capabilities.control
-                        ? {
-                            control: projectCapabilities(operation.capabilities.control, source.id, source.capabilities, `operation '${name}' control capabilities`) ?? [],
-                        }
-                        : {}),
-                };
-            }
-            if (operation.signals) {
-                emitted.signals = Object.fromEntries(Object.entries(operation.signals).map(([signalName, signal]) => [
-                    signalName,
-                    {
-                        input: { ...signal.input },
-                        ...(signal.docs ? { docs: contractDocs(signal.docs) } : {}),
-                    },
-                ]));
-            }
-            if (operation.cancel !== undefined) {
-                emitted.cancel = operation.cancel;
-            }
-            if (operation.docs) {
-                emitted.docs = contractDocs(operation.docs);
-            }
-            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: projectCapabilities(event.capabilities.publish, source.id, source.capabilities, `event '${name}' publish capabilities`) ?? [],
-                        }
-                        : {}),
-                    ...(event.capabilities.subscribe
-                        ? {
-                            subscribe: projectCapabilities(event.capabilities.subscribe, source.id, source.capabilities, `event '${name}' subscribe capabilities`) ?? [],
-                        }
-                        : {}),
-                };
-            }
-            if (event.docs) {
-                emitted.docs = contractDocs(event.docs);
-            }
-            return [name, emitted];
-        }))
-        : undefined;
-    const feeds = source.feeds
-        ? Object.fromEntries(Object.entries(source.feeds).map(([name, feed]) => {
-            const emitted = {
-                version: feed.version,
-                subject: feed.subject ?? feedSubject(name, feed.version),
-                input: { ...feed.input },
-                event: { ...feed.event },
-            };
-            if (feed.capabilities?.subscribe) {
-                emitted.capabilities = {
-                    subscribe: projectCapabilities(feed.capabilities.subscribe, source.id, source.capabilities, `feed '${name}' subscribe capabilities`) ?? [],
-                };
-            }
-            if (feed.docs) {
-                emitted.docs = contractDocs(feed.docs);
-            }
-            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 eventConsumers = emitEventConsumers(source.eventConsumers);
-    const state = emitState(source.state);
-    const resources = emitResources(source.resources);
-    const uses = emitUses(source.uses);
-    assertValidEventConsumers(eventConsumers, uses);
-    return {
-        format: CONTRACT_FORMAT_V1,
-        id: source.id,
-        displayName: source.displayName,
-        description: source.description,
-        ...(source.docs ? { docs: contractDocs(source.docs) } : {}),
-        kind: source.kind,
-        ...(capabilities ? { capabilities } : {}),
-        ...(source.schemas ? { schemas: cloneSchemas(source.schemas) } : {}),
-        ...(source.exports
-            ? { exports: cloneContractExports(source.exports) }
-            : {}),
-        ...(state ? { state } : {}),
-        ...(uses ? { uses } : {}),
-        ...(rpc ? { rpc } : {}),
-        ...(operations ? { operations } : {}),
-        ...(events ? { events } : {}),
-        ...(feeds ? { feeds } : {}),
-        ...(errors ? { errors } : {}),
-        ...(jobs ? { jobs } : {}),
-        ...(eventConsumers ? { eventConsumers } : {}),
-        ...(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: projectCapabilities(method.capabilities?.call, source.id, source.capabilities, `rpc '${name}' call capabilities`) ?? [],
-            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,
-            signals: operation.signals
-                ? Object.fromEntries(Object.entries(operation.signals).map(([signalName, signal]) => [
-                    signalName,
-                    {
-                        input: schema(resolveSchemaRef(source.schemas, signal.input, `operation '${name}' signal '${signalName}' input`)),
-                    },
-                ]))
-                : undefined,
-            callerCapabilities: projectCapabilities(operation.capabilities?.call, source.id, source.capabilities, `operation '${name}' call capabilities`) ?? [],
-            observeCapabilities: projectCapabilities(operation.capabilities?.observe, source.id, source.capabilities, `operation '${name}' observe capabilities`) ?? [],
-            cancelCapabilities: projectCapabilities(operation.capabilities?.cancel, source.id, source.capabilities, `operation '${name}' cancel capabilities`) ?? [],
-            controlCapabilities: projectCapabilities(operation.capabilities?.control, source.id, source.capabilities, `operation '${name}' control capabilities`) ?? [],
-            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: projectCapabilities(event.capabilities?.publish, source.id, source.capabilities, `event '${name}' publish capabilities`) ?? [],
-                subscribeCapabilities: projectCapabilities(event.capabilities?.subscribe, source.id, source.capabilities, `event '${name}' subscribe capabilities`) ?? [],
-            },
-        ];
-    }));
-    const feeds = Object.fromEntries(Object.entries(source.feeds ?? {}).map(([name, feed]) => [
-        name,
-        {
-            subject: feed.subject ?? feedSubject(name, feed.version),
-            input: schema(resolveSchemaRef(source.schemas, feed.input, `feed '${name}' input`)),
-            event: schema(resolveSchemaRef(source.schemas, feed.event, `feed '${name}' event`)),
-            subscribeCapabilities: projectCapabilities(feed.capabilities?.subscribe, source.id, source.capabilities, `feed '${name}' subscribe capabilities`) ?? [],
-        },
-    ]));
-    return { rpc, operations, events, feeds, 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);
-    assertSelectedKeysExist(contractId, "feeds", spec.feeds?.subscribe, api.feeds ?? {});
-}
-function contractUseByAlias(uses, alias) {
-    return uses?.required?.[alias] ?? uses?.optional?.[alias];
-}
-function assertValidEventConsumers(eventConsumers, uses) {
-    if (!eventConsumers) {
-        return;
-    }
-    for (const [groupName, group] of Object.entries(eventConsumers)) {
-        if (group.events.length === 0) {
-            throw new Error(`event consumer group '${groupName}' must declare events`);
-        }
-        if ((group.ordering ?? "strict") === "strict" && group.concurrency !== 1) {
-            throw new Error(`event consumer group '${groupName}' with strict ordering requires concurrency 1`);
-        }
-        for (const eventRef of group.events) {
-            const use = contractUseByAlias(uses, eventRef.use);
-            if (!use) {
-                throw new Error(`event consumer group '${groupName}' references unknown use '${eventRef.use}'`);
-            }
-            if (!use.events?.subscribe?.includes(eventRef.event)) {
-                throw new Error(`event consumer group '${groupName}' references event '${eventRef.event}' that use '${eventRef.use}' does not subscribe to`);
-            }
-        }
-    }
-}
-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] }
-                            : {}),
-                    },
-                }
-                : {}),
-            ...(spec.feeds?.subscribe
-                ? { feeds: { subscribe: [...spec.feeds.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 normalizeUseEntries(uses) {
-    if (!uses) {
-        return {
-            manifestUses: undefined,
-            usedApi: { rpc: {}, operations: {}, events: {}, feeds: {}, subjects: {} },
-        };
-    }
-    const manifestUses = {};
-    const usedApi = {
-        rpc: {},
-        operations: {},
-        events: {},
-        feeds: {},
-        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;
-        const feedsSubscribe = useValue.feeds?.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 } : {}),
-                    },
-                }
-                : {}),
-            ...(feedsSubscribe ? { feeds: { subscribe: feedsSubscribe } } : {}),
-        }, 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] } : {}),
-                    },
-                }
-                : {}),
-            ...(feedsSubscribe ? { feeds: { subscribe: [...feedsSubscribe] } } : {}),
-        };
-        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]])));
-        }
-        const feedKeys = selectedKeys(feedsSubscribe);
-        if (feedKeys.length > 0) {
-            mergeRecord("feeds", usedApi.feeds ?? {}, Object.fromEntries(feedKeys.map((key) => [key, contractModule.API.owned.feeds?.[key]])));
-        }
-    }
-    return { manifestUses, usedApi };
-}
-function normalizeUses(uses) {
-    if (!uses) {
-        return {
-            manifestUses: undefined,
-            usedApi: emptyApi(),
-        };
-    }
-    const required = normalizeUseEntries(uses.required);
-    const optional = normalizeUseEntries(omitRequiredUseAliases(uses.optional, uses.required));
-    const usedApi = emptyApi();
-    mergeUseIntoApi(usedApi, required.usedApi);
-    mergeUseIntoApi(usedApi, optional.usedApi);
-    return {
-        manifestUses: {
-            ...(required.manifestUses ? { required: required.manifestUses } : {}),
-            ...(optional.manifestUses ? { optional: optional.manifestUses } : {}),
-        },
-        usedApi,
-    };
-}
-function emptyApi() {
-    return { rpc: {}, operations: {}, events: {}, feeds: {}, 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 ?? []);
-    const feedsSubscribe = [...(existing.feeds?.subscribe ?? [])];
-    addUniqueStrings(feedsSubscribe, use.feeds?.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 } : {}),
-                },
-            }
-            : {}),
-        ...(feedsSubscribe.length > 0
-            ? { feeds: { subscribe: feedsSubscribe } }
-            : {}),
-    };
-}
-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("feeds", target.feeds ?? {}, api.feeds ?? {});
-    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);
-    }
-    if ((source.kind === "service" || source.kind === "device") &&
-        source.id !== TRELLIS_HEALTH_CONTRACT_ID) {
-        uses.health = baselineUse(TRELLIS_HEALTH_CONTRACT_ID, { events: { publish: [...BASELINE_HEALTH_EVENTS_PUBLISH] } }, BASELINE_HEALTH_API);
-    }
-    return uses;
-}
-function normalizeContractUses(source) {
-    const explicit = normalizeUses(source.uses);
-    const usedApi = emptyApi();
-    mergeUseIntoApi(usedApi, explicit.usedApi);
-    const required = {
-        ...(explicit.manifestUses?.required ?? {}),
-    };
-    const optional = explicit.manifestUses?.optional
-        ? { ...explicit.manifestUses.optional }
-        : undefined;
-    for (const [alias, use] of Object.entries(deriveImplicitTrellisUses(source))) {
-        mergeUseIntoManifest(required, alias, use.manifestUse);
-        mergeUseIntoApi(usedApi, use.api);
-    }
-    return {
-        manifestUses: Object.keys(required).length > 0 ||
-            (optional && Object.keys(optional).length > 0)
-            ? {
-                ...(Object.keys(required).length > 0 ? { required } : {}),
-                ...(optional && Object.keys(optional).length > 0 ? { optional } : {}),
-            }
-            : 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),
-        feeds: mergeApiSection("feeds", usedApi.feeds ?? {}, ownedApi.feeds ?? {}),
-        subjects: mergeApiSection("subjects", usedApi.subjects, ownedApi.subjects),
-    };
-}
-function defineContract(registry, build) {
-    assertRegistryDoesNotDeclareExports(registry);
-    assertRegistryDoesNotDeclareCapabilities(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,
-        ...(source.docs ? { docs: source.docs } : {}),
-        kind: source.kind,
-        ...(source.capabilities ? { capabilities: source.capabilities } : {}),
-        ...(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.feeds ? { feeds: source.feeds } : {}),
-        ...(source.errors ? { errors: source.errors } : {}),
-        ...(source.jobs ? { jobs: source.jobs } : {}),
-        ...(source.eventConsumers ? { eventConsumers: source.eventConsumers } : {}),
-        ...(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 };