@qlever-llc/trellis 0.7.0-rc.5 → 0.7.0

package/script/js/packages/trellis/npm/src/server/service.js

@@ -0,0 +1,654 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _KVHandle_nc, _StoreHandle_nc, _TrellisService_operationTransfer, _TrellisService_stopHealthPublishing, _TrellisService_stopConnectionLogging;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrellisService = exports.StoreHandle = exports.KVHandle = void 0;
+const nats_core_1 = require("@nats-io/nats-core");
+const trellis_1 = require("@qlever-llc/trellis");
+const auth_1 = require("@qlever-llc/trellis-sdk/auth");
+const server_js_1 = require("../server.js");
+const auth_2 = require("@qlever-llc/trellis/auth");
+const contracts_1 = require("@qlever-llc/trellis/contracts");
+const result_1 = require("@qlever-llc/result");
+const typebox_1 = require("typebox");
+const value_1 = require("typebox/value");
+const health_js_1 = require("./health.js");
+const health_rpc_js_1 = require("./health_rpc.js");
+const transfer_js_1 = require("./transfer.js");
+const globals_js_1 = require("../globals.js");
+const runtime_transport_js_1 = require("../runtime_transport.js");
+const runtime_transport_js_2 = require("../runtime_transport.js");
+const server_logger_js_1 = require("../server_logger.js");
+const ClientTransportEndpointsSchema = typebox_1.Type.Object({
+    natsServers: typebox_1.Type.Array(typebox_1.Type.String({ minLength: 1 }), { minItems: 1 }),
+});
+const ClientTransportsSchema = typebox_1.Type.Object({
+    native: typebox_1.Type.Optional(ClientTransportEndpointsSchema),
+    websocket: typebox_1.Type.Optional(ClientTransportEndpointsSchema),
+});
+function resolveServiceLogger(log) {
+    if (log === false) {
+        return globals_js_1.logger;
+    }
+    return log ?? server_logger_js_1.serverLogger;
+}
+function normalizeNatsError(error) {
+    const record = error;
+    return {
+        name: error.name,
+        message: error.message,
+        ...(typeof record.operation === "string"
+            ? { operation: record.operation }
+            : {}),
+        ...(typeof record.subject === "string" ? { subject: record.subject } : {}),
+        ...(typeof record.queue === "string" ? { queue: record.queue } : {}),
+    };
+}
+function normalizeNatsStatus(status) {
+    if (!status || typeof status !== "object") {
+        return { status };
+    }
+    const record = status;
+    return {
+        ...(typeof record.type === "string" ? { type: record.type } : {}),
+        ...(record.error instanceof Error
+            ? { error: normalizeNatsError(record.error) }
+            : {}),
+        ...(typeof record.data === "string" ? { data: record.data } : {}),
+        ...(record.data && typeof record.data === "object"
+            ? { data: record.data }
+            : {}),
+    };
+}
+function isImportantNatsStatus(status) {
+    if (!status || typeof status !== "object") {
+        return false;
+    }
+    const type = status.type;
+    return type === "disconnect" || type === "forceReconnect" ||
+        type === "staleConnection" || type === "error";
+}
+function startNatsConnectionLogging(args) {
+    let stopped = false;
+    const statusFn = args.nc.status;
+    if (typeof statusFn === "function") {
+        void (async () => {
+            try {
+                for await (const status of statusFn.call(args.nc)) {
+                    if (stopped)
+                        return;
+                    const logConnectionStatus = isImportantNatsStatus(status)
+                        ? args.log.info.bind(args.log)
+                        : args.log.debug.bind(args.log);
+                    logConnectionStatus({
+                        service: args.name,
+                        connection: normalizeNatsStatus(status),
+                    }, "Service NATS connection status");
+                }
+            }
+            catch (error) {
+                if (!stopped) {
+                    args.log.warn({ service: args.name, error }, "Service NATS status watcher failed");
+                }
+            }
+        })();
+    }
+    void args.nc.closed().then((error) => {
+        if (stopped)
+            return;
+        if (error) {
+            args.log.error({ service: args.name, error }, "Service NATS connection closed with error");
+            return;
+        }
+        args.log.warn({ service: args.name }, "Service NATS connection closed");
+    });
+    return () => {
+        stopped = true;
+    };
+}
+function getErrorCauseMessage(error) {
+    if (error && typeof error === "object") {
+        const context = error.context;
+        if (typeof context?.causeMessage === "string" &&
+            context.causeMessage.length > 0) {
+            return context.causeMessage;
+        }
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+function bootstrapContractStateError(args) {
+    const base = `Service '${args.serviceName}' could not bootstrap contract '${args.contractId}' (${args.contractDigest}) during ${args.step}. ` +
+        "This usually means Trellis has stale or incomplete state for this service session. " +
+        "Re-run the service profile apply or instance provisioning flow so Trellis records the allowed digest, permissions, and resource bindings for this instance key.";
+    const cause = args.cause
+        ? ` Underlying error: ${getErrorCauseMessage(args.cause)}`
+        : "";
+    return new Error(base + cause);
+}
+function runtimeImport(specifier) {
+    const load = new Function("specifier", "return import(specifier);");
+    return load(specifier);
+}
+async function loadDefaultServiceRuntimeDeps() {
+    const transport = await (0, runtime_transport_js_1.loadDefaultRuntimeTransport)();
+    return {
+        connect: (opts) => transport.connect({
+            servers: opts.servers,
+            ...(opts.token ? { token: opts.token } : {}),
+            ...(opts.authenticator
+                ? { authenticator: opts.authenticator }
+                : {}),
+            ...(opts.inboxPrefix ? { inboxPrefix: opts.inboxPrefix } : {}),
+        }),
+    };
+}
+const ServiceBootstrapReadySchema = typebox_1.Type.Object({
+    status: typebox_1.Type.Literal("ready"),
+    connectInfo: typebox_1.Type.Object({
+        sessionKey: typebox_1.Type.String({ minLength: 1 }),
+        contractId: typebox_1.Type.String({ minLength: 1 }),
+        contractDigest: typebox_1.Type.String({ minLength: 1 }),
+        transports: ClientTransportsSchema,
+        transport: typebox_1.Type.Object({
+            sentinel: auth_2.SentinelCredsSchema,
+        }),
+        auth: typebox_1.Type.Object({
+            mode: typebox_1.Type.Literal("service_identity"),
+            iatSkewSeconds: typebox_1.Type.Integer({ minimum: 1 }),
+        }),
+    }),
+    binding: typebox_1.Type.Object({
+        contractId: typebox_1.Type.String({ minLength: 1 }),
+        digest: typebox_1.Type.String({ minLength: 1 }),
+        resources: contracts_1.ContractResourceBindingsSchema,
+    }),
+}, { additionalProperties: true });
+const ServiceBootstrapFailureSchema = typebox_1.Type.Object({
+    reason: typebox_1.Type.String({ minLength: 1 }),
+    message: typebox_1.Type.Optional(typebox_1.Type.String({ minLength: 1 })),
+}, { additionalProperties: true });
+async function fetchServiceBootstrapInfo(args) {
+    const iat = Math.floor(Date.now() / 1_000);
+    const response = await fetch(new URL("/bootstrap/service", args.trellisUrl), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            sessionKey: args.auth.sessionKey,
+            contractId: args.contractId,
+            contractDigest: args.contractDigest,
+            iat,
+            sig: await args.auth.natsConnectSigForIat(iat),
+        }),
+    });
+    const responseText = await response.text();
+    let payload;
+    try {
+        payload = JSON.parse(responseText);
+    }
+    catch {
+        payload = undefined;
+    }
+    if (!response.ok) {
+        if (payload !== undefined &&
+            value_1.Value.Check(ServiceBootstrapFailureSchema, payload)) {
+            const failure = payload;
+            throw new Error(`Service bootstrap failed: ${failure.message ?? failure.reason}`);
+        }
+        const detail = responseText.trim();
+        throw new Error(detail.length > 0
+            ? `Service bootstrap failed with HTTP ${response.status}: ${detail}`
+            : `Service bootstrap failed with HTTP ${response.status}`);
+    }
+    if (payload === undefined) {
+        throw new Error(`Service bootstrap returned invalid JSON: ${responseText.trim() || "<empty body>"}`);
+    }
+    return value_1.Value.Parse(ServiceBootstrapReadySchema, payload);
+}
+class KVHandle {
+    constructor(nc, binding) {
+        Object.defineProperty(this, "binding", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _KVHandle_nc.set(this, void 0);
+        __classPrivateFieldSet(this, _KVHandle_nc, nc, "f");
+        this.binding = binding;
+    }
+    open(schema) {
+        return trellis_1.TypedKV.open(__classPrivateFieldGet(this, _KVHandle_nc, "f"), this.binding.bucket, schema, {
+            history: this.binding.history,
+            ttl: this.binding.ttlMs,
+            maxValueBytes: this.binding.maxValueBytes,
+            bindOnly: true,
+        });
+    }
+}
+exports.KVHandle = KVHandle;
+_KVHandle_nc = new WeakMap();
+class StoreHandle {
+    constructor(nc, binding) {
+        Object.defineProperty(this, "binding", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _StoreHandle_nc.set(this, void 0);
+        __classPrivateFieldSet(this, _StoreHandle_nc, nc, "f");
+        this.binding = binding;
+    }
+    open() {
+        return trellis_1.TypedStore.open(__classPrivateFieldGet(this, _StoreHandle_nc, "f"), this.binding.name, {
+            ttlMs: this.binding.ttlMs,
+            maxObjectBytes: this.binding.maxObjectBytes,
+            maxTotalBytes: this.binding.maxTotalBytes,
+            bindOnly: true,
+        });
+    }
+    /**
+     * Waits for a staged object to appear in the bound store and returns its entry.
+     */
+    async waitFor(key, options = {}) {
+        const opened = await this.open();
+        const store = opened.take();
+        if ((0, result_1.isErr)(store)) {
+            return store;
+        }
+        return await store.waitFor(key, options);
+    }
+}
+exports.StoreHandle = StoreHandle;
+_StoreHandle_nc = new WeakMap();
+async function createConnectedService(args) {
+    const resolvedLog = resolveServiceLogger(args.server.log);
+    const stopConnectionLogging = startNatsConnectionLogging({
+        name: args.name,
+        nc: args.nc,
+        log: resolvedLog,
+    });
+    const currentApi = (args.server.trellisApi ?? args.server.api);
+    const runtimeApi = {
+        ...currentApi,
+        rpc: {
+            ...auth_1.auth.API.owned.rpc,
+            ...currentApi.rpc,
+        },
+    };
+    const server = server_js_1.TrellisServer.create(args.name, args.nc, { sessionKey: args.auth.sessionKey, sign: args.auth.sign }, {
+        log: resolvedLog,
+        timeout: args.server.timeout,
+        stream: args.server.stream,
+        noResponderRetry: args.server.noResponderRetry,
+        api: runtimeApi,
+        transferSupport: {
+            openOperationTransfer: (transferArgs) => getTransfer().createOperationUpload(transferArgs),
+        },
+        version: args.server.version,
+    });
+    const outbound = new trellis_1.Trellis(args.name, args.nc, { sessionKey: args.auth.sessionKey, sign: args.auth.sign }, {
+        log: resolvedLog,
+        timeout: args.server.timeout,
+        stream: args.server.stream,
+        noResponderRetry: args.server.noResponderRetry,
+        api: runtimeApi,
+    });
+    let transfer;
+    const getTransfer = () => {
+        if (!transfer) {
+            throw new Error("service transfer helper accessed before initialization");
+        }
+        return transfer;
+    };
+    let handlerResources;
+    const getHandlerResources = () => {
+        if (!handlerResources) {
+            throw new Error("service resource handles accessed before initialization");
+        }
+        return handlerResources;
+    };
+    const handlerTrellis = {
+        request: (method, input, opts) => outbound.request(method, input, opts),
+        requestOrThrow: (method, input, opts) => outbound.requestOrThrow(method, input, opts),
+        publish: (event, data) => outbound.publish(event, data),
+        event: (event, subjectData, fn) => outbound.event(event, subjectData, fn),
+        operation: (operation) => outbound.operation(operation),
+        get kv() {
+            return getHandlerResources().kv;
+        },
+        get store() {
+            return getHandlerResources().store;
+        },
+    };
+    const trellis = Object.assign(outbound, {
+        mount: (method, fn) => server.mount(method, async (input, context) => await Promise.resolve(fn(input, context, handlerTrellis))),
+    });
+    const health = new health_js_1.ServiceHealth({
+        serviceName: args.name,
+        contractId: args.contractId ?? "unknown",
+        contractDigest: args.contractDigest ?? "unknown",
+        publishIntervalMs: args.server.health?.publishIntervalMs ?? 30_000,
+        checks: args.server.healthChecks,
+    });
+    health.add("nats", () => ({
+        status: args.nc.isClosed() ? "failed" : "ok",
+        ...(args.nc.isClosed() ? { summary: "NATS connection closed" } : {}),
+    }));
+    await (0, health_rpc_js_1.mountStandardHealthRpc)(server, {
+        response: () => health.response(),
+    });
+    const heartbeatEventEnabled = Boolean(currentApi.events?.["Health.Heartbeat"]);
+    let healthPublishTimer;
+    let publishingHeartbeat = false;
+    const publishHealthHeartbeat = async () => {
+        if (!heartbeatEventEnabled || publishingHeartbeat) {
+            return;
+        }
+        publishingHeartbeat = true;
+        try {
+            const heartbeat = await health.heartbeat();
+            const published = await outbound.publish("Health.Heartbeat", heartbeat);
+            const value = published.take();
+            if ((0, result_1.isErr)(value)) {
+                resolvedLog.warn({ error: value.error }, "Failed to publish health heartbeat");
+            }
+        }
+        catch (error) {
+            resolvedLog.warn({ error }, "Failed to build or publish health heartbeat");
+        }
+        finally {
+            publishingHeartbeat = false;
+        }
+    };
+    const stopHealthPublishing = async () => {
+        if (healthPublishTimer !== undefined) {
+            clearInterval(healthPublishTimer);
+            healthPublishTimer = undefined;
+        }
+    };
+    if (heartbeatEventEnabled) {
+        await publishHealthHeartbeat();
+        healthPublishTimer = setInterval(() => {
+            void publishHealthHeartbeat();
+        }, health.publishIntervalMs);
+    }
+    const operationTransfer = new transfer_js_1.ServiceTransfer({
+        name: args.name,
+        nc: args.nc,
+        auth: args.auth,
+        stores: Object.fromEntries(Object.entries(args.bindings.store ?? {}).map(([alias, binding]) => [
+            alias,
+            new StoreHandle(args.nc, binding),
+        ])),
+    });
+    const service = new TrellisService(args.name, args.auth, args.nc, server, trellis, args.bindings, operationTransfer, health, stopHealthPublishing, stopConnectionLogging);
+    handlerResources = { kv: service.kv, store: service.store };
+    transfer = operationTransfer;
+    return service;
+}
+class TrellisService {
+    constructor(name, auth, nc, server, trellis, bindings, operationTransfer, health, stopHealthPublishing, stopConnectionLogging) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "auth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "nc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "server", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "operations", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "trellis", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "kv", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "streams", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "jobs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "health", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _TrellisService_operationTransfer.set(this, void 0);
+        _TrellisService_stopHealthPublishing.set(this, void 0);
+        _TrellisService_stopConnectionLogging.set(this, void 0);
+        const kvBindings = bindings.kv ?? {};
+        const storeBindings = bindings.store ?? {};
+        const streamBindings = bindings.streams ?? {};
+        this.name = name;
+        this.auth = auth;
+        this.nc = nc;
+        this.server = server;
+        this.operations = server.operations;
+        this.trellis = trellis;
+        this.kv = Object.fromEntries(Object.entries(kvBindings).map(([alias, binding]) => [alias, new KVHandle(nc, binding)]));
+        this.store = Object.fromEntries(Object.entries(storeBindings).map(([alias, binding]) => [alias, new StoreHandle(nc, binding)]));
+        __classPrivateFieldSet(this, _TrellisService_operationTransfer, operationTransfer, "f");
+        this.streams = streamBindings;
+        this.jobs = bindings.jobs;
+        this.health = health;
+        __classPrivateFieldSet(this, _TrellisService_stopHealthPublishing, stopHealthPublishing, "f");
+        __classPrivateFieldSet(this, _TrellisService_stopConnectionLogging, stopConnectionLogging, "f");
+    }
+    static async connect(args, deps) {
+        const runtimeDeps = {
+            ...(await loadDefaultServiceRuntimeDeps()),
+            ...deps,
+        };
+        const auth = await (0, auth_2.createAuth)({ sessionKeySeed: args.sessionKeySeed });
+        const bootstrap = await fetchServiceBootstrapInfo({
+            trellisUrl: args.trellisUrl,
+            contractId: args.contract.CONTRACT_ID,
+            contractDigest: args.contract.CONTRACT_DIGEST,
+            auth,
+        });
+        const { authenticator: authTokenAuthenticator, inboxPrefix } = await auth
+            .natsConnectOptions();
+        const nc = await runtimeDeps.connect({
+            servers: (0, runtime_transport_js_2.selectRuntimeTransportServers)(bootstrap.connectInfo.transports),
+            inboxPrefix,
+            authenticator: [
+                authTokenAuthenticator,
+                (0, nats_core_1.jwtAuthenticator)(bootstrap.connectInfo.transport.sentinel.jwt, new TextEncoder().encode(bootstrap.connectInfo.transport.sentinel.seed)),
+            ],
+        });
+        return await createConnectedService({
+            name: args.name,
+            auth,
+            nc,
+            contractId: args.contract.CONTRACT_ID,
+            contractDigest: args.contract.CONTRACT_DIGEST,
+            server: {
+                ...(args.server ?? {}),
+                api: args.contract.API.owned,
+                trellisApi: args.contract.API.trellis,
+            },
+            bindings: bootstrap.binding.resources,
+        });
+    }
+    static async connectInternal(name, opts, deps) {
+        const connectFn = deps.connect;
+        const readFileSync = deps.readFileSync;
+        const credsAuthenticator = deps.credsAuthenticator;
+        const auth = opts.auth ??
+            (opts.sessionKeySeed
+                ? await (0, auth_2.createAuth)({ sessionKeySeed: opts.sessionKeySeed })
+                : undefined);
+        if (!auth) {
+            throw new Error("TrellisService.connect requires either opts.auth or opts.sessionKeySeed");
+        }
+        const authenticator = opts.nats.authenticator ??
+            (() => {
+                if (opts.nats.sentinelCreds) {
+                    if (!credsAuthenticator) {
+                        throw new Error("TrellisService.connect requires a runtime creds authenticator when sentinel creds are provided");
+                    }
+                    return credsAuthenticator(opts.nats.sentinelCreds);
+                }
+                if (opts.nats.sentinelCredsPath) {
+                    if (!credsAuthenticator || !readFileSync) {
+                        throw new Error("TrellisService.connect requires runtime file and creds adapters when opts.nats.sentinelCredsPath is used");
+                    }
+                    return credsAuthenticator(readFileSync(opts.nats.sentinelCredsPath));
+                }
+                throw new Error("TrellisService.connect requires opts.nats.authenticator, opts.nats.sentinelCreds, or opts.nats.sentinelCredsPath");
+            })();
+        const { authenticator: authTokenAuthenticator, inboxPrefix } = await auth
+            .natsConnectOptions();
+        const nc = await connectFn({
+            servers: opts.nats.servers,
+            inboxPrefix,
+            authenticator: [authTokenAuthenticator, authenticator],
+            ...(opts.nats.options ?? {}),
+        });
+        let bindings = { kv: {}, store: {}, streams: {} };
+        if (opts.contractId && opts.contractDigest) {
+            const resolvedLog = resolveServiceLogger(opts.server.log);
+            const runtimeApi = (opts.server.trellisApi ?? opts.server.api);
+            const outbound = new trellis_1.Trellis(name, nc, { sessionKey: auth.sessionKey, sign: auth.sign }, {
+                log: resolvedLog,
+                timeout: opts.server.timeout,
+                stream: opts.server.stream,
+                noResponderRetry: opts.server.noResponderRetry,
+                api: runtimeApi,
+            });
+            const trellis = Object.assign(outbound, {
+                mount: () => {
+                    throw new Error("mount is unavailable during internal bootstrap probing");
+                },
+            });
+            const bootstrapRequest = trellis.request.bind(trellis);
+            const catalogResult = await bootstrapRequest("Trellis.Catalog", {});
+            const catalogValue = catalogResult.take();
+            if ((0, result_1.isErr)(catalogValue)) {
+                throw bootstrapContractStateError({
+                    serviceName: name,
+                    contractId: opts.contractId,
+                    contractDigest: opts.contractDigest,
+                    step: "catalog lookup",
+                    cause: catalogValue.error,
+                });
+            }
+            const catalog = catalogValue;
+            const isActive = catalog.catalog.contracts.some((c) => c.digest === opts.contractDigest);
+            if (!isActive) {
+                throw new Error(`Contract ${opts.contractId} (${opts.contractDigest}) is not active. Install it with the trellis CLI first.`);
+            }
+            const bindingsResult = await bootstrapRequest("Trellis.Bindings.Get", { contractId: opts.contractId });
+            const bindingsValue = bindingsResult.take();
+            if ((0, result_1.isErr)(bindingsValue)) {
+                throw bootstrapContractStateError({
+                    serviceName: name,
+                    contractId: opts.contractId,
+                    contractDigest: opts.contractDigest,
+                    step: "bindings lookup",
+                    cause: bindingsValue.error,
+                });
+            }
+            const resolved = bindingsValue;
+            if (!resolved.binding) {
+                throw bootstrapContractStateError({
+                    serviceName: name,
+                    contractId: opts.contractId,
+                    contractDigest: opts.contractDigest,
+                    step: "bindings lookup",
+                });
+            }
+            if (resolved.binding.contractId !== opts.contractId ||
+                resolved.binding.digest !== opts.contractDigest) {
+                throw new Error(`Service '${name}' received bindings for '${resolved.binding.contractId ?? "unknown"}' (${resolved.binding.digest ?? "unknown"}) ` +
+                    `while bootstrapping '${opts.contractId}' (${opts.contractDigest}). Re-run the service profile apply or instance provisioning flow so Trellis records the correct active contract for this instance key.`);
+            }
+            bindings = {
+                kv: resolved.binding?.resources?.kv ?? {},
+                store: resolved.binding?.resources?.store ?? {},
+                streams: resolved.binding?.resources?.streams ?? {},
+                ...(resolved.binding?.resources?.jobs
+                    ? { jobs: resolved.binding.resources.jobs }
+                    : {}),
+            };
+        }
+        return await createConnectedService({
+            name,
+            auth,
+            nc,
+            contractId: opts.contractId,
+            contractDigest: opts.contractDigest,
+            server: opts.server,
+            bindings,
+        });
+    }
+    async stop() {
+        __classPrivateFieldGet(this, _TrellisService_stopConnectionLogging, "f").call(this);
+        await __classPrivateFieldGet(this, _TrellisService_stopHealthPublishing, "f").call(this);
+        await __classPrivateFieldGet(this, _TrellisService_operationTransfer, "f").stop();
+        await this.server.stop();
+    }
+    request(method, input, opts) {
+        return this.trellis.request(method, input, opts);
+    }
+    requestOrThrow(method, input, opts) {
+        return this.trellis.requestOrThrow(method, input, opts);
+    }
+    operation(operation) {
+        return this.server.operation(operation);
+    }
+}
+exports.TrellisService = TrellisService;
+_TrellisService_operationTransfer = new WeakMap(), _TrellisService_stopHealthPublishing = new WeakMap(), _TrellisService_stopConnectionLogging = new WeakMap();