@qlever-llc/trellis 0.5.1 → 0.6.0

package/script/contracts/mod.js

@@ -0,0 +1,555 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapSchema = exports.schema = exports.isJsonValue = exports.digestJson = exports.canonicalizeJson = exports.CATALOG_FORMAT_V1 = exports.CONTRACT_FORMAT_V1 = exports.StreamResourceBindingSchema = exports.PaginatedSchema = exports.KvResourceBindingSchema = exports.JobsResourceBindingSchema = exports.JobsQueueBindingSchema = exports.IsoDateSchema = exports.InstalledServiceContractSchema = exports.EventHeaderSchema = exports.ContractStreamResourceSchema = exports.ContractSchemaRefSchema = exports.ContractResourcesSchema = exports.ContractResourceBindingsSchema = exports.ContractKvResourceSchema = exports.ContractJobsResourceSchema = exports.ContractJobQueueResourceSchema = void 0;
+exports.defineContract = defineContract;
+const canonical_ts_1 = require("./canonical.ts");
+Object.defineProperty(exports, "canonicalizeJson", { enumerable: true, get: function () { return canonical_ts_1.canonicalizeJson; } });
+Object.defineProperty(exports, "digestJson", { enumerable: true, get: function () { return canonical_ts_1.digestJson; } });
+Object.defineProperty(exports, "isJsonValue", { enumerable: true, get: function () { return canonical_ts_1.isJsonValue; } });
+const runtime_ts_1 = require("./runtime.ts");
+Object.defineProperty(exports, "schema", { enumerable: true, get: function () { return runtime_ts_1.schema; } });
+Object.defineProperty(exports, "unwrapSchema", { enumerable: true, get: function () { return runtime_ts_1.unwrapSchema; } });
+const schema_pointers_ts_1 = require("./schema_pointers.ts");
+var protocol_ts_1 = require("./protocol.ts");
+Object.defineProperty(exports, "ContractJobQueueResourceSchema", { enumerable: true, get: function () { return protocol_ts_1.ContractJobQueueResourceSchema; } });
+Object.defineProperty(exports, "ContractJobsResourceSchema", { enumerable: true, get: function () { return protocol_ts_1.ContractJobsResourceSchema; } });
+Object.defineProperty(exports, "ContractKvResourceSchema", { enumerable: true, get: function () { return protocol_ts_1.ContractKvResourceSchema; } });
+Object.defineProperty(exports, "ContractResourceBindingsSchema", { enumerable: true, get: function () { return protocol_ts_1.ContractResourceBindingsSchema; } });
+Object.defineProperty(exports, "ContractResourcesSchema", { enumerable: true, get: function () { return protocol_ts_1.ContractResourcesSchema; } });
+Object.defineProperty(exports, "ContractSchemaRefSchema", { enumerable: true, get: function () { return protocol_ts_1.ContractSchemaRefSchema; } });
+Object.defineProperty(exports, "ContractStreamResourceSchema", { enumerable: true, get: function () { return protocol_ts_1.ContractStreamResourceSchema; } });
+Object.defineProperty(exports, "EventHeaderSchema", { enumerable: true, get: function () { return protocol_ts_1.EventHeaderSchema; } });
+Object.defineProperty(exports, "InstalledServiceContractSchema", { enumerable: true, get: function () { return protocol_ts_1.InstalledServiceContractSchema; } });
+Object.defineProperty(exports, "IsoDateSchema", { enumerable: true, get: function () { return protocol_ts_1.IsoDateSchema; } });
+Object.defineProperty(exports, "JobsQueueBindingSchema", { enumerable: true, get: function () { return protocol_ts_1.JobsQueueBindingSchema; } });
+Object.defineProperty(exports, "JobsResourceBindingSchema", { enumerable: true, get: function () { return protocol_ts_1.JobsResourceBindingSchema; } });
+Object.defineProperty(exports, "KvResourceBindingSchema", { enumerable: true, get: function () { return protocol_ts_1.KvResourceBindingSchema; } });
+Object.defineProperty(exports, "PaginatedSchema", { enumerable: true, get: function () { return protocol_ts_1.PaginatedSchema; } });
+Object.defineProperty(exports, "StreamResourceBindingSchema", { enumerable: true, get: function () { return protocol_ts_1.StreamResourceBindingSchema; } });
+exports.CONTRACT_FORMAT_V1 = "trellis.contract.v1";
+exports.CATALOG_FORMAT_V1 = "trellis.catalog.v1";
+const CONTRACT_MODULE_METADATA = Symbol.for("@qlever-llc/trellis-contracts/contract-module");
+function cloneSchema(schemaValue) {
+    const cloned = JSON.parse(JSON.stringify(schemaValue));
+    if (!(0, canonical_ts_1.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 assertSchemaRefExists(schemas, ref, context) {
+    if (!schemas || !Object.hasOwn(schemas, ref.schema)) {
+        throw new Error(`${context} references unknown schema '${ref.schema}'`);
+    }
+}
+function resolveSchemaRef(schemas, ref, context) {
+    assertSchemaRefExists(schemas, ref, context);
+    return cloneSchema(schemas[ref.schema]);
+}
+function digestCanonicalJson(value) {
+    return (0, canonical_ts_1.sha256Base64urlSync)((0, canonical_ts_1.canonicalizeJson)(value));
+}
+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?.streams && !resources?.jobs) {
+        return undefined;
+    }
+    return {
+        ...(resources.kv
+            ? {
+                kv: Object.fromEntries(Object.entries(resources.kv).map(([alias, resource]) => [
+                    alias,
+                    {
+                        purpose: resource.purpose,
+                        required: resource.required ?? true,
+                        history: resource.history ?? 1,
+                        ttlMs: resource.ttlMs ?? 0,
+                        ...(resource.maxValueBytes
+                            ? { maxValueBytes: resource.maxValueBytes }
+                            : {}),
+                    },
+                ])),
+            }
+            : {}),
+        ...(resources.streams
+            ? {
+                streams: Object.fromEntries(Object.entries(resources.streams).map(([alias, resource]) => [
+                    alias,
+                    {
+                        purpose: resource.purpose,
+                        required: resource.required ?? true,
+                        subjects: [...resource.subjects],
+                    },
+                ])),
+            }
+            : {}),
+        ...(resources.jobs
+            ? {
+                jobs: {
+                    queues: Object.fromEntries(Object.entries(resources.jobs.queues).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 emitUses(uses) {
+    if (!uses) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(uses).map(([alias, use]) => [
+        alias,
+        {
+            contract: use.contract,
+            ...(use.rpc?.call ? { rpc: { call: [...use.rpc.call] } } : {}),
+            ...(use.operations?.call
+                ? { operations: { call: [...use.operations.call] } }
+                : {}),
+            ...((use.events?.publish || use.events?.subscribe)
+                ? {
+                    events: {
+                        ...(use.events.publish
+                            ? { publish: [...use.events.publish] }
+                            : {}),
+                        ...(use.events.subscribe
+                            ? { subscribe: [...use.events.subscribe] }
+                            : {}),
+                    },
+                }
+                : {}),
+            ...((use.subjects?.publish || use.subjects?.subscribe)
+                ? {
+                    subjects: {
+                        ...(use.subjects.publish
+                            ? { publish: [...use.subjects.publish] }
+                            : {}),
+                        ...(use.subjects.subscribe
+                            ? { subscribe: [...use.subjects.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: [...method.capabilities.call] };
+            }
+            if (method.errors && method.errors.length > 0) {
+                emitted.errors = method.errors.map((type) => ({ type }));
+            }
+            return [name, emitted];
+        }))
+        : undefined;
+    const operations = source.operations
+        ? Object.fromEntries(Object.entries(source.operations).map(([name, operation]) => {
+            const emitted = {
+                version: operation.version,
+                subject: operation.subject ?? operationSubject(name, operation.version),
+                input: { ...operation.input },
+            };
+            if (operation.progress) {
+                emitted.progress = { ...operation.progress };
+            }
+            if (operation.output) {
+                emitted.output = { ...operation.output };
+            }
+            if (operation.capabilities?.call || operation.capabilities?.read ||
+                operation.capabilities?.cancel) {
+                emitted.capabilities = {
+                    ...(operation.capabilities.call
+                        ? { call: [...operation.capabilities.call] }
+                        : {}),
+                    ...(operation.capabilities.read
+                        ? { read: [...operation.capabilities.read] }
+                        : {}),
+                    ...(operation.capabilities.cancel
+                        ? { cancel: [...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) {
+                (0, schema_pointers_ts_1.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: [...event.capabilities.publish] }
+                        : {}),
+                    ...(event.capabilities.subscribe
+                        ? { subscribe: [...event.capabilities.subscribe] }
+                        : {}),
+                };
+            }
+            return [name, emitted];
+        }))
+        : undefined;
+    const subjects = source.subjects
+        ? Object.fromEntries(Object.entries(source.subjects).map(([name, subject]) => {
+            const emitted = {
+                subject: subject.subject,
+            };
+            if (subject.message) {
+                emitted.message = { ...subject.message };
+            }
+            if (subject.capabilities?.publish || subject.capabilities?.subscribe) {
+                emitted.capabilities = {
+                    ...(subject.capabilities.publish
+                        ? { publish: [...subject.capabilities.publish] }
+                        : {}),
+                    ...(subject.capabilities.subscribe
+                        ? { subscribe: [...subject.capabilities.subscribe] }
+                        : {}),
+                };
+            }
+            return [name, emitted];
+        }))
+        : undefined;
+    const errors = source.errors
+        ? Object.fromEntries(Object.entries(source.errors).map(([name, error]) => {
+            const emitted = { type: error.type };
+            if (error.schema) {
+                emitted.schema = { ...error.schema };
+            }
+            return [name, emitted];
+        }))
+        : undefined;
+    const resources = emitResources(source.resources);
+    const uses = emitUses(source.uses);
+    return {
+        format: exports.CONTRACT_FORMAT_V1,
+        id: source.id,
+        displayName: source.displayName,
+        description: source.description,
+        ...(source.schemas ? { schemas: cloneSchemas(source.schemas) } : {}),
+        ...(uses ? { uses } : {}),
+        ...(rpc ? { rpc } : {}),
+        ...(operations ? { operations } : {}),
+        ...(events ? { events } : {}),
+        ...(subjects ? { subjects } : {}),
+        ...(errors ? { errors } : {}),
+        ...(resources ? { resources } : {}),
+    };
+}
+function buildOwnedApi(source) {
+    const rpc = Object.fromEntries(Object.entries(source.rpc ?? {}).map(([name, method]) => [
+        name,
+        {
+            subject: method.subject ?? rpcSubject(name, method.version),
+            input: (0, runtime_ts_1.schema)(resolveSchemaRef(source.schemas, method.input, `rpc '${name}' input`)),
+            output: (0, runtime_ts_1.schema)(resolveSchemaRef(source.schemas, method.output, `rpc '${name}' output`)),
+            callerCapabilities: method.capabilities?.call ?? [],
+            authRequired: method.authRequired ?? true,
+            errors: method.errors,
+        },
+    ]));
+    const operations = Object.fromEntries(Object.entries(source.operations ?? {}).map(([name, operation]) => [
+        name,
+        {
+            subject: operation.subject ?? operationSubject(name, operation.version),
+            input: (0, runtime_ts_1.schema)(resolveSchemaRef(source.schemas, operation.input, `operation '${name}' input`)),
+            progress: operation.progress
+                ? (0, runtime_ts_1.schema)(resolveSchemaRef(source.schemas, operation.progress, `operation '${name}' progress`))
+                : undefined,
+            output: operation.output
+                ? (0, runtime_ts_1.schema)(resolveSchemaRef(source.schemas, operation.output, `operation '${name}' output`))
+                : 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) {
+            (0, schema_pointers_ts_1.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: (0, runtime_ts_1.schema)(resolveSchemaRef(source.schemas, event.event, `event '${name}'`)),
+                publishCapabilities: event.capabilities?.publish ?? [],
+                subscribeCapabilities: event.capabilities?.subscribe ?? [],
+            },
+        ];
+    }));
+    const subjects = Object.fromEntries(Object.entries(source.subjects ?? {}).map(([name, subject]) => [
+        name,
+        {
+            subject: subject.subject,
+            schema: subject.message
+                ? (0, runtime_ts_1.schema)(resolveSchemaRef(source.schemas, subject.message, `subject '${name}'`))
+                : undefined,
+            publishCapabilities: subject.capabilities?.publish ?? [],
+            subscribeCapabilities: subject.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);
+    assertSelectedKeysExist(contractId, "subjects", spec.subjects?.publish, api.subjects);
+    assertSelectedKeysExist(contractId, "subjects", spec.subjects?.subscribe, api.subjects);
+}
+function attachContractModuleMetadata(value, contractModule) {
+    Object.defineProperty(value, CONTRACT_MODULE_METADATA, {
+        value: contractModule,
+        enumerable: false,
+    });
+    return value;
+}
+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.subjects?.publish || spec.subjects?.subscribe)
+                ? {
+                    subjects: {
+                        ...(spec.subjects.publish
+                            ? { publish: [...spec.subjects.publish] }
+                            : {}),
+                        ...(spec.subjects.subscribe
+                            ? { subscribe: [...spec.subjects.subscribe] }
+                            : {}),
+                    },
+                }
+                : {}),
+        };
+        return attachContractModuleMetadata(dependencyUse, contractModule);
+    });
+}
+function getContractModuleFromUse(alias, useValue) {
+    const contractModule = useValue[CONTRACT_MODULE_METADATA];
+    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);
+        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, useValue, contractModule.API.owned);
+        manifestUses[alias] = {
+            contract: contractModule.CONTRACT_ID,
+            ...(useValue.rpc?.call ? { rpc: { call: [...useValue.rpc.call] } } : {}),
+            ...(useValue.operations?.call
+                ? { operations: { call: [...useValue.operations.call] } }
+                : {}),
+            ...((useValue.events?.publish || useValue.events?.subscribe)
+                ? {
+                    events: {
+                        ...(useValue.events.publish
+                            ? { publish: [...useValue.events.publish] }
+                            : {}),
+                        ...(useValue.events.subscribe
+                            ? { subscribe: [...useValue.events.subscribe] }
+                            : {}),
+                    },
+                }
+                : {}),
+            ...((useValue.subjects?.publish || useValue.subjects?.subscribe)
+                ? {
+                    subjects: {
+                        ...(useValue.subjects.publish
+                            ? { publish: [...useValue.subjects.publish] }
+                            : {}),
+                        ...(useValue.subjects.subscribe
+                            ? { subscribe: [...useValue.subjects.subscribe] }
+                            : {}),
+                    },
+                }
+                : {}),
+        };
+        const rpcKeys = selectedKeys(useValue.rpc?.call);
+        if (rpcKeys.length > 0) {
+            mergeRecord("rpc", usedApi.rpc, Object.fromEntries(rpcKeys.map((key) => [key, contractModule.API.owned.rpc[key]])));
+        }
+        const operationKeys = selectedKeys(useValue.operations?.call);
+        if (operationKeys.length > 0) {
+            mergeRecord("operations", usedApi.operations, Object.fromEntries(operationKeys.map((key) => [key, contractModule.API.owned.operations[key]])));
+        }
+        const eventKeys = new Set([
+            ...selectedKeys(useValue.events?.publish),
+            ...selectedKeys(useValue.events?.subscribe),
+        ]);
+        if (eventKeys.size > 0) {
+            mergeRecord("events", usedApi.events, Object.fromEntries([...eventKeys].map((key) => [key, contractModule.API.owned.events[key]])));
+        }
+        const subjectKeys = new Set([
+            ...selectedKeys(useValue.subjects?.publish),
+            ...selectedKeys(useValue.subjects?.subscribe),
+        ]);
+        if (subjectKeys.size > 0) {
+            mergeRecord("subjects", usedApi.subjects, Object.fromEntries([...subjectKeys].map((key) => [key, contractModule.API.owned.subjects[key]])));
+        }
+    }
+    return { manifestUses, 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(source) {
+    const { manifestUses, usedApi } = normalizeUses(source.uses);
+    const emittedSource = {
+        id: source.id,
+        displayName: source.displayName,
+        description: source.description,
+        ...(source.schemas ? { schemas: source.schemas } : {}),
+        ...(manifestUses ? { uses: manifestUses } : {}),
+        ...(source.rpc ? { rpc: source.rpc } : {}),
+        ...(source.operations ? { operations: source.operations } : {}),
+        ...(source.events ? { events: source.events } : {}),
+        ...(source.subjects ? { subjects: source.subjects } : {}),
+        ...(source.errors ? { errors: source.errors } : {}),
+        ...(source.resources ? { resources: source.resources } : {}),
+    };
+    const ownedApi = buildOwnedApi(emittedSource);
+    const trellisApi = mergeDerivedApis(ownedApi, usedApi);
+    const CONTRACT = emitContract(emittedSource);
+    const CONTRACT_DIGEST = digestCanonicalJson(CONTRACT);
+    let contract;
+    contract = {
+        CONTRACT_ID: source.id,
+        CONTRACT,
+        CONTRACT_DIGEST,
+        API: {
+            owned: ownedApi,
+            used: usedApi,
+            trellis: trellisApi,
+        },
+        use: createUseHelper(() => contract),
+    };
+    return contract;
+}