@relkit/cli 0.0.0

package/dist/commands/build-server-runtime.js

@@ -0,0 +1,187 @@
+import { GENERATOR_VERSION, GRAPH_VERSION, MANIFEST_VERSION } from "@relkit/contracts";
+export const SERVER_RUNTIME_SOURCE = `
+function bindAgents() {
+  for (const node of plan.agents) {
+    const agent = runtimeManifest.agents?.[node.id];
+    if (agent === undefined) throw new Error(\`Agent descriptor "\${node.id}" is unavailable.\`);
+    const functionId = \`relkit.agent.\${node.id}.invoke\`;
+    executableManifest.functions[functionId] = createGeneratedAgentFunction(
+      node.id,
+      (input, context) => invokeBoundAgent(node, agent, input, context),
+    );
+  }
+}
+function routeMiddlewareContext({ middlewareId, signal }) {
+  const time = Object.freeze({
+    now: () => new Date(),
+    sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+  });
+  const write = (level, message, fields = {}) => {
+    const record = telemetry.collect({
+      version: 1,
+      signal: "log",
+      timestamp: time.now().toISOString(),
+      level,
+      component: middlewareId,
+      message,
+      fields,
+    });
+    if (record?.signal === "log") consoleHumanSink.write(formatHumanLog(record), record);
+  };
+  const logger = (level) => (message, fields) => write(level, message, fields);
+  return {
+    signal,
+    env: values,
+    time,
+    log: Object.freeze({
+      trace: logger("trace"),
+      debug: logger("debug"),
+      info: logger("info"),
+      warn: logger("warn"),
+      error: logger("error"),
+    }),
+  };
+}
+async function invokeBoundAgent(node, agent, input, context) {
+  const providerRegistry = await providerStartup;
+  if (providerRegistry === undefined) throw new Error("Provider registry unavailable.");
+  const modelRegistry = provider(providerRegistry, "models", node.profile);
+  if (modelRegistry === undefined)
+    throw new Error("Model provider registry unavailable.");
+  return invokeAgent({
+    agent,
+    input,
+    modelRegistry,
+    tools: runtimeManifest.tools ?? {},
+    engine: { invoke: invokeHttp },
+    invocationId: context.invocation.id,
+    traceId: context.invocation.traceId,
+    signal: context.signal,
+    timeoutMs: agent.limits.timeoutMs,
+    hooks: { observability: telemetry },
+  });
+}
+function targetFor(functionId) {
+  const target = executableManifest.targets?.[functionId];
+  return target !== null && typeof target === "object" && typeof target.handler === "function"
+    ? target
+    : undefined;
+}
+function createDependencySources(providerRegistry) {
+  return {
+    agents: Object.fromEntries(plan.agents.map((node) => [node.id, registry.get(\`relkit.agent.\${node.id}.invoke\`)])),
+    buckets: Object.fromEntries(plan.buckets.map((node) => [node.id, provider(providerRegistry, "buckets", node.profile)])),
+    cache: Object.fromEntries(plan.caches.map((node) => [node.id, provider(providerRegistry, "cache", node.profile)])),
+    jobs: Object.fromEntries(plan.queues.filter((node) => node.kind === "job").map((node) => [node.id, materializedJobs?.jobs.get(node.id)])),
+    events: Object.fromEntries((plan.events ?? []).map((node) => [node.id, provider(providerRegistry, "events", node.profile)])),
+  };
+}
+function provider(providerRegistry, capability, profile) {
+  return providerRegistry.resolve(capability, profile).value;
+}
+async function supportsInspector(capability, nodes, id, ...operations) {
+  try {
+    const inspector = await resourceInspector(capability, nodes, id);
+    return operations.every((operation) => typeof inspector[operation] === "function");
+  } catch {
+    return false;
+  }
+}
+async function resourceInspector(capability, nodes, id) {
+  const node = nodes.find((candidate) => candidate.id === id);
+  if (node === undefined) throw new Error(\`Resource "\${id}" is unavailable.\`);
+  const providerRegistry = await providerStartup;
+  if (providerRegistry === undefined) throw new Error("Provider registry unavailable.");
+  const value = provider(providerRegistry, capability, node.profile);
+  if (value === null || typeof value !== "object" || value.inspector === undefined)
+    throw new Error(\`Resource "\${id}" does not support inspector access.\`);
+  return value.inspector;
+}
+async function resolveRateLimitStore(storeId) {
+  const cache = plan.caches.find((node) => node.id === storeId);
+  if (cache === undefined) throw new Error(\`Rate-limit cache "\${storeId}" is unavailable.\`);
+  const providerRegistry = await providerStartup;
+  if (providerRegistry === undefined) throw new Error("Provider registry unavailable.");
+  return provider(providerRegistry, "cache", cache.profile);
+}
+function queueProvider(providerRegistry, context) {
+  const value = provider(providerRegistry, "jobs", context.profile);
+  if (value === null || typeof value !== "object" || typeof value.createQueue !== "function")
+    throw new Error(\`Job provider profile "\${context.profile}" cannot materialize queues.\`);
+  return value.createQueue(context);
+}
+function startJobWorker(jobs) {
+  let running = false;
+  const worker = setInterval(async () => {
+    if (running || stopping) return;
+    running = true;
+    try {
+      await jobs.tick(new Date());
+      await Promise.all([...jobs.jobs.keys()].map((jobId) => jobs.runNext(jobId)));
+    } catch (error) {
+      recordRuntimeFailure("runtime.job-worker", "Job worker failed", error, "job");
+    } finally {
+      running = false;
+    }
+  }, environment === "production" ? 1_000 : 100);
+  worker.unref?.();
+  return worker;
+}
+function errorCode(error) {
+  if (error !== null && typeof error === "object" && typeof error.code === "string") return error.code;
+  if (error !== null && typeof error === "object" && error.name === "EnvResolutionError") return "RELKIT_ENVIRONMENT_INVALID";
+  return error instanceof Error ? error.name : "unknown";
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function recordRuntimeFailure(component, message, error, source) {
+  captureRuntimeError(error);
+  const record = telemetry.collect({
+    version: 1,
+    signal: "log",
+    timestamp: new Date().toISOString(),
+    level: "error",
+    component,
+    message,
+    fields: { code: errorCode(error), detail: errorMessage(error) },
+    generationId,
+    graphHash,
+    source,
+  });
+  if (record?.signal === "log") consoleHumanSink.write(formatHumanLog(record), record);
+}
+function healthResponse(status, code = 200) {
+  return Response.json({ protocol: "relkit.inspector", version: 1, status, graphHash, manifestGraphHash: runtimeManifest.graphHash, graphContractVersion: ${GRAPH_VERSION}, manifestContractVersion: ${MANIFEST_VERSION}, manifestGeneratorVersion: ${GENERATOR_VERSION}, environmentReady: true, providerReady: providerReady && !stopping, ...(sourceToken === undefined ? {} : { sourceToken }), ...(generationToken === undefined ? {} : { generationToken }) }, { status: code, headers: { "x-relkit-api-version": "1" } });
+}
+function tokenFrom(value) {
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) ? parsed : undefined;
+}
+function resolveEnvironment(value, nodeEnvironment) {
+  if (value === "development" || value === "test" || value === "production") return value;
+  return nodeEnvironment === "production" ? "production" : "development";
+}
+function resolveRuntimeEnvironment(definition, environment, source) {
+  try {
+    const resolved = resolveEnv(definition, { environment, source });
+    const values = { ...source };
+    for (const [name, value] of Object.entries(resolved)) {
+      if (source[name] !== undefined || value === undefined) continue;
+      values[name] = runtimeEnvironmentValue(value);
+    }
+    return { values, error: undefined };
+  } catch (error) {
+    return { values: source, error };
+  }
+}
+function runtimeEnvironmentValue(value) {
+  return value;
+}
+function waitForProviderReady() {
+  const milliseconds = timeoutFrom(process.env.RELKIT_PROVIDER_READY_DELAY_MS, 0);
+  if (milliseconds === 0) return Promise.resolve();
+  return new Promise((resolve, reject) => { const timer = setTimeout(resolve, milliseconds); shutdownController.signal.addEventListener("abort", () => { clearTimeout(timer); reject(shutdownController.signal.reason ?? new Error("Provider startup was aborted.")); }, { once: true }); });
+}
+`;
+//# sourceMappingURL=build-server-runtime.js.map

package/dist/commands/build-server-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-server-runtime.js","sourceRoot":"","sources":["../../src/commands/build-server-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACvF,MAAM,CAAC,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4JAyJuH,aAAa,8BAA8B,gBAAgB,+BAA+B,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BtQ,CAAC"}

package/dist/commands/build-server-shutdown.d.ts

@@ -0,0 +1,2 @@
+export declare const SERVER_SHUTDOWN_SOURCE = "\nfunction timeoutFrom(value, fallback) {\n  const parsed = Number(value);\n  return Number.isSafeInteger(parsed) && parsed >= 0 ? Math.min(parsed, 30_000) : fallback;\n}\n\nfunction bounded(task, milliseconds) {\n  return new Promise((resolve) => {\n    let settled = false;\n    const timer = setTimeout(() => { settled = true; resolve(false); }, milliseconds);\n    Promise.resolve(task).then(() => {\n      if (!settled) { settled = true; clearTimeout(timer); resolve(true); }\n    }, () => {\n      if (!settled) { settled = true; clearTimeout(timer); resolve(true); }\n    });\n  });\n}\n\nfunction flushTelemetry() {\n  const flush = globalThis[\"__relkit_flush_telemetry\"];\n  return typeof flush === \"function\" ? Promise.resolve(flush()) : Promise.resolve();\n}\n\nfunction flushSentry() {\n  const flush = globalThis[\"__relkit_flush_sentry\"];\n  return typeof flush === \"function\" ? Promise.resolve(flush()) : Promise.resolve();\n}\n\nasync function shutdown() {\n  if (stopping) return;\n  stopping = true;\n  if (jobWorker !== undefined) clearInterval(jobWorker);\n  shutdownController.abort(new Error(\"Runtime is stopping.\"));\n  const drainTimeoutMs = timeoutFrom(process.env.RELKIT_DRAIN_TIMEOUT_MS, 10_000);\n  const telemetryTimeoutMs = timeoutFrom(process.env.RELKIT_TELEMETRY_FLUSH_TIMEOUT_MS, 1_000);\n  await bounded(Promise.allSettled(activeInvocations), drainTimeoutMs);\n  await bounded(flushTelemetry(), telemetryTimeoutMs);\n  await bounded(flushSentry(), telemetryTimeoutMs);\n  await bounded(providerStartup, drainTimeoutMs);\n  if (providers !== undefined) await providers.dispose().catch(() => undefined);\n  await bounded(telemetry.close(), telemetryTimeoutMs);\n  await server.stop(true);\n  process.exit(0);\n}\n\nprocess.once(\"SIGINT\", () => void shutdown());\nprocess.once(\"SIGTERM\", () => void shutdown());\n";
+//# sourceMappingURL=build-server-shutdown.d.ts.map

package/dist/commands/build-server-shutdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-server-shutdown.d.ts","sourceRoot":"","sources":["../../src/commands/build-server-shutdown.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,s0DA+ClC,CAAC"}

package/dist/commands/build-server-shutdown.js

@@ -0,0 +1,49 @@
+export const SERVER_SHUTDOWN_SOURCE = `
+function timeoutFrom(value, fallback) {
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? Math.min(parsed, 30_000) : fallback;
+}
+
+function bounded(task, milliseconds) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const timer = setTimeout(() => { settled = true; resolve(false); }, milliseconds);
+    Promise.resolve(task).then(() => {
+      if (!settled) { settled = true; clearTimeout(timer); resolve(true); }
+    }, () => {
+      if (!settled) { settled = true; clearTimeout(timer); resolve(true); }
+    });
+  });
+}
+
+function flushTelemetry() {
+  const flush = globalThis["__relkit_flush_telemetry"];
+  return typeof flush === "function" ? Promise.resolve(flush()) : Promise.resolve();
+}
+
+function flushSentry() {
+  const flush = globalThis["__relkit_flush_sentry"];
+  return typeof flush === "function" ? Promise.resolve(flush()) : Promise.resolve();
+}
+
+async function shutdown() {
+  if (stopping) return;
+  stopping = true;
+  if (jobWorker !== undefined) clearInterval(jobWorker);
+  shutdownController.abort(new Error("Runtime is stopping."));
+  const drainTimeoutMs = timeoutFrom(process.env.RELKIT_DRAIN_TIMEOUT_MS, 10_000);
+  const telemetryTimeoutMs = timeoutFrom(process.env.RELKIT_TELEMETRY_FLUSH_TIMEOUT_MS, 1_000);
+  await bounded(Promise.allSettled(activeInvocations), drainTimeoutMs);
+  await bounded(flushTelemetry(), telemetryTimeoutMs);
+  await bounded(flushSentry(), telemetryTimeoutMs);
+  await bounded(providerStartup, drainTimeoutMs);
+  if (providers !== undefined) await providers.dispose().catch(() => undefined);
+  await bounded(telemetry.close(), telemetryTimeoutMs);
+  await server.stop(true);
+  process.exit(0);
+}
+
+process.once("SIGINT", () => void shutdown());
+process.once("SIGTERM", () => void shutdown());
+`;
+//# sourceMappingURL=build-server-shutdown.js.map

package/dist/commands/build-server-shutdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-server-shutdown.js","sourceRoot":"","sources":["../../src/commands/build-server-shutdown.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CrC,CAAC"}

package/dist/commands/build-server.d.ts

@@ -0,0 +1,13 @@
+import type { JsonValue } from "@relkit/contracts";
+import type { ApplicationGraph } from "@relkit/graph";
+/** Emits the one Bun entrypoint used by dev, start, and the production container. */
+export declare function serverSource(graph: ApplicationGraph, graphHash: string, openapi?: JsonValue, clientContract?: JsonValue, configuration?: {
+    readonly maxBodyBytes: number;
+    readonly apiDocs: {
+        readonly enabledInProduction: boolean;
+    };
+    readonly clientContract: boolean;
+    readonly mcp: boolean;
+    readonly maxPreviewBytes: number;
+}): string;
+//# sourceMappingURL=build-server.d.ts.map

package/dist/commands/build-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-server.d.ts","sourceRoot":"","sources":["../../src/commands/build-server.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAItD,qFAAqF;AACrF,wBAAgB,YAAY,CAC1B,KAAK,EAAE,gBAAgB,EACvB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,SAAc,EACvB,cAAc,GAAE,SAAc,EAC9B,aAAa,GAAE;IACb,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAA;KAAE,CAAC;IAC5D,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAOlC,GACA,MAAM,CAyKR"}

package/dist/commands/build-server.js

@@ -0,0 +1,182 @@
+import { canonicalJson, GENERATOR_VERSION, GRAPH_VERSION, MANIFEST_VERSION, } from "@relkit/contracts";
+import { SERVER_INVOCATION_SOURCE } from "./build-server-invocation.js";
+import { SERVER_RUNTIME_SOURCE } from "./build-server-runtime.js";
+import { SERVER_SHUTDOWN_SOURCE } from "./build-server-shutdown.js";
+/** Emits the one Bun entrypoint used by dev, start, and the production container. */
+export function serverSource(graph, graphHash, openapi = {}, clientContract = {}, configuration = {
+    maxBodyBytes: 1_048_576,
+    apiDocs: { enabledInProduction: false },
+    clientContract: true,
+    mcp: true,
+    maxPreviewBytes: 1_048_576,
+}) {
+    return `import { AsyncLocalStorage } from "node:async_hooks";
+import { createGeneratedAgentFunction, invokeAgent } from "@relkit/agents";
+import { createApplicationContextResolver } from "@relkit/app";
+import { resolveEnv } from "@relkit/config";
+import { awsProviderFactories } from "@relkit/cloud-aws/runtime";
+import { createFunctionRegistry, createProviderRegistry, invoke, materializeEvents, materializeJobs } from "@relkit/engine";
+import { createRegistrationPlan } from "@relkit/graph";
+import { installInspectorEndpoints } from "@relkit/inspector-api";
+import { createObservabilityRuntime } from "@relkit/observability";
+import { standardProviderFactories } from "@relkit/providers-standard";
+import { consoleHumanSink, formatHumanLog, redactFailureDetail } from "@relkit/runtime-effect";
+import { createApp, createHttpAuthRuntime } from "@relkit/runtime-hono";
+import { runtimeManifest } from "./runtime.manifest.ts";
+
+const graph = ${canonicalJson(graph)};
+const graphHash = ${JSON.stringify(graphHash)};
+const openapiDocument = ${canonicalJson(openapi)};
+const clientContractDocument = ${canonicalJson(clientContract)};
+const plan = createRegistrationPlan(graph);
+if (plan.graphHash !== graphHash) throw new Error("Runtime graph hash verification failed.");
+const environment = resolveEnvironment(process.env.RELKIT_ENV, process.env.NODE_ENV);
+const generationId = process.env.RELKIT_GENERATION_ID ?? "generation.runtime";
+const sourceToken = tokenFrom(process.env.RELKIT_SOURCE_TOKEN);
+const generationToken = tokenFrom(process.env.RELKIT_GENERATION_TOKEN);
+const sourceValues = Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== undefined));
+const shutdownController = new AbortController();
+const telemetry = await createObservabilityRuntime({ root: process.env.RELKIT_OBSERVABILITY_ROOT ?? ".relkit/observability" });
+globalThis["__relkit_flush_telemetry"] = telemetry.flush;
+const executableManifest = { ...runtimeManifest, functions: { ...runtimeManifest.functions } };
+const application = runtimeManifest.application;
+if (application === undefined) throw new Error("Runtime application metadata is unavailable.");
+const authRequestStorage = new AsyncLocalStorage();
+const authRuntime = createAuthRegistration(graph, runtimeManifest.routes);
+const environmentResolution = resolveRuntimeEnvironment(application.env, environment, sourceValues);
+const values = environmentResolution.values;
+const sentry = await createSentry(application.sentry, values);
+globalThis["__relkit_flush_sentry"] = () => sentry?.flush(1_000);
+const contextResolver = createApplicationContextResolver({
+  constants: runtimeManifest.constants,
+  prompts: runtimeManifest.prompts,
+  env: values,
+});
+const databaseContext = createDatabaseRegistration(runtimeManifest.dataModel);
+bindAgents();
+const registry = createFunctionRegistry(graph, executableManifest);
+const providerFactories = { ...standardProviderFactories, ...awsProviderFactories };
+let materializedJobs;
+let jobWorker;
+const providerStartup = (environmentResolution.error === undefined
+  ? createProviderRegistry({ generationId, environment, providers: { buckets: application.buckets, cache: application.caches, jobs: application.jobs, events: application.events, models: application.models, observability: application.observability }, graph, values, environmentMetadata: application.env.metadata, signal: shutdownController.signal, factories: providerFactories })
+  : Promise.reject(environmentResolution.error)).then(async (value) => {
+  await materializeEvents({ plan, providerRegistry: value, engine: { invoke: invokeHttp } });
+  materializedJobs = await materializeJobs({ plan, engine: { invoke: invokeHttp }, createQueue: (context) => queueProvider(value, context) });
+  jobWorker = startJobWorker(materializedJobs);
+  await waitForProviderReady();
+  providerReady = true;
+  providers = value;
+  return value;
+}).catch((error) => {
+  recordRuntimeFailure("runtime.provider", "Provider startup failed", error, "direct");
+  providerFailed = true;
+  return undefined;
+});
+let providers;
+let providerReady = false;
+let providerFailed = false;
+const activeInvocations = new Set();
+let stopping = false;
+const internalEndpointsEnabled = environment !== "production" || process.env.RELKIT_INTERNAL_ENDPOINTS === "1";
+const app = createApp({
+  plan,
+  manifest: executableManifest,
+  engine: { invoke: invokeHttp },
+  observability: telemetry,
+  responseMapping: { mode: environment },
+  middlewareContext: routeMiddlewareContext,
+  middleware: { generationId, observability: telemetry, maxBodyBytes: ${configuration.maxBodyBytes} },
+  apiDocs: {
+    mode: environment,
+    document: openapiDocument,
+    enabledInProduction: ${String(configuration.apiDocs.enabledInProduction)},
+    ...(process.env.RELKIT_INTERNAL_ENDPOINT_TOKEN === undefined
+      ? {}
+      : { bearerToken: process.env.RELKIT_INTERNAL_ENDPOINT_TOKEN }),
+  },
+  clientContract: {
+    enabled: ${String(configuration.clientContract)},
+    document: clientContractDocument,
+  },
+  mcp: { enabled: ${String(configuration.mcp)} },
+  staticFiles: { root: process.env.RELKIT_PUBLIC_ROOT ?? new URL("../public", import.meta.url).pathname },
+  rateLimitRuntime: { resolveStore: resolveRateLimitStore },
+  ...(authRuntime === undefined ? {} : { auth: authRuntime }),
+  internalEndpoints: {
+    mode: environment,
+    enabled: internalEndpointsEnabled,
+    graph: {
+      generationId,
+      graphHash,
+      manifestGraphHash: runtimeManifest.graphHash,
+      graphContractVersion: ${GRAPH_VERSION},
+      manifestContractVersion: ${MANIFEST_VERSION},
+      manifestGeneratorVersion: ${GENERATOR_VERSION},
+      graph,
+    },
+    ...(process.env.RELKIT_INTERNAL_ENDPOINT_TOKEN === undefined
+      ? {}
+      : { bearerToken: process.env.RELKIT_INTERNAL_ENDPOINT_TOKEN }),
+    readiness: () => ({
+      ready: providerReady && !stopping,
+      ...(stopping ? { reason: "stopping" } : providerFailed ? { reason: "unavailable" } : {}),
+    }),
+  },
+});
+installInspectorEndpoints(app, {
+  mode: environment,
+  enabled: internalEndpointsEnabled,
+  ...(process.env.RELKIT_INTERNAL_ENDPOINT_TOKEN === undefined
+    ? {}
+    : { bearerToken: process.env.RELKIT_INTERNAL_ENDPOINT_TOKEN }),
+  activeGeneration: {
+    generationId,
+    graphHash,
+    graph,
+    diagnostics: [],
+    actions: {
+      functions: {
+        exists: (functionId) => registry.has(functionId),
+        invoke: (request) => invokeHttp({ functionId: request.functionId, input: request.input, source: "direct", ...(request.signal === undefined ? {} : { signal: request.signal }) }),
+      },
+    },
+    resources: {
+      buckets: {
+        supports: (bucketId) => supportsInspector("buckets", plan.buckets, bucketId, "list", "preview"),
+        list: async ({ bucketId, ...request }) => (await resourceInspector("buckets", plan.buckets, bucketId)).list(request),
+        preview: async ({ bucketId, ...request }) => (await resourceInspector("buckets", plan.buckets, bucketId)).preview(request),
+      },
+      cache: {
+        supports: (cacheId) => supportsInspector("cache", plan.caches, cacheId, "scan", "value"),
+        scan: async ({ cacheId, ...request }) => (await resourceInspector("cache", plan.caches, cacheId)).scan(request),
+        value: async ({ cacheId, ...request }) => (await resourceInspector("cache", plan.caches, cacheId)).value(request),
+      },
+    },
+  },
+  maxPreviewBytes: ${configuration.maxPreviewBytes},
+  query: telemetry.query,
+  stream: telemetry.stream,
+});
+const server = Bun.serve({
+  hostname: "0.0.0.0",
+  port: Number(process.env.PORT ?? 3000),
+  fetch: async (request) => {
+    const path = new URL(request.url).pathname;
+    if (path === "/_relkit/v1/health/live") return healthResponse("ok");
+    if (path === "/_relkit/v1/health/ready")
+      return healthResponse(providerReady && !stopping ? "ready" : "not-ready", providerReady && !stopping ? 200 : 503);
+    if (stopping) return Response.json({ error: "draining" }, { status: 503 });
+    try {
+      return await app.fetch(request);
+    } catch {
+      return Response.json({ error: "internal-error" }, { status: 500 });
+    }
+  },
+});
+${SERVER_INVOCATION_SOURCE}
+${SERVER_RUNTIME_SOURCE}
+${SERVER_SHUTDOWN_SOURCE}
+`;
+}
+//# sourceMappingURL=build-server.js.map

package/dist/commands/build-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-server.js","sourceRoot":"","sources":["../../src/commands/build-server.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,gBAAgB,GACjB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,qFAAqF;AACrF,MAAM,UAAU,YAAY,CAC1B,KAAuB,EACvB,SAAiB,EACjB,UAAqB,EAAE,EACvB,iBAA4B,EAAE,EAC9B,gBAMI;IACF,YAAY,EAAE,SAAS;IACvB,OAAO,EAAE,EAAE,mBAAmB,EAAE,KAAK,EAAE;IACvC,cAAc,EAAE,IAAI;IACpB,GAAG,EAAE,IAAI;IACT,eAAe,EAAE,SAAS;CAC3B;IAED,OAAO;;;;;;;;;;;;;;gBAcO,aAAa,CAAC,KAAK,CAAC;oBAChB,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC;0BACnB,aAAa,CAAC,OAAO,CAAC;iCACf,aAAa,CAAC,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wEA2DU,aAAa,CAAC,YAAY;;;;2BAIvE,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,mBAAmB,CAAC;;;;;;eAM7D,MAAM,CAAC,aAAa,CAAC,cAAc,CAAC;;;oBAG/B,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC;;;;;;;;;;;8BAWf,aAAa;iCACV,gBAAgB;kCACf,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0C9B,aAAa,CAAC,eAAe;;;;;;;;;;;;;;;;;;;;EAoBhD,wBAAwB;EACxB,qBAAqB;EACrB,sBAAsB;CACvB,CAAC;AACF,CAAC"}

package/dist/commands/build-support.d.ts

@@ -0,0 +1,6 @@
+export declare function dockerfile(): string;
+export declare function dockerignore(): string;
+export declare function bundleServer(serverDirectory: string, projectRoot: string): Promise<void>;
+export declare function rebaseManifest(source: string, projectRoot: string, sourceDirectory: string, targetDirectory: string): string;
+export declare function errorMessage(error: unknown): string;
+//# sourceMappingURL=build-support.d.ts.map

package/dist/commands/build-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-support.d.ts","sourceRoot":"","sources":["../../src/commands/build-support.ts"],"names":[],"mappings":"AAIA,wBAAgB,UAAU,IAAI,MAAM,CAcnC;AAED,wBAAgB,YAAY,IAAI,MAAM,CAgBrC;AAED,wBAAsB,YAAY,CAAC,eAAe,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA8B9F;AAED,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,MAAM,EACvB,eAAe,EAAE,MAAM,GACtB,MAAM,CAIR;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEnD"}

package/dist/commands/build-support.js

@@ -0,0 +1,77 @@
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { symlink, unlink } from "node:fs/promises";
+export function dockerfile() {
+    return `FROM oven/bun:1.3.10
+ARG SOURCE_DATE_EPOCH=0
+WORKDIR /app
+COPY server/index.js ./server/index.js
+COPY application.graph.json manifest.json openapi.json ./
+COPY public/ ./public/
+RUN mkdir -p .relkit/state .relkit/observability && chown -R bun:bun .relkit
+USER bun
+ENV NODE_ENV=production
+EXPOSE 3000
+STOPSIGNAL SIGTERM
+CMD ["bun", "run", "--no-env-file", "server/index.js"]
+`;
+}
+export function dockerignore() {
+    return `*
+!Dockerfile
+!.dockerignore
+!manifest.json
+!application.graph.json
+!openapi.json
+!public/
+!public/**
+!server/
+!server/index.js
+.env
+.env.*
+.relkit/state
+.relkit/observability
+`;
+}
+export async function bundleServer(serverDirectory, projectRoot) {
+    const runtimeModules = resolve(dirname(fileURLToPath(import.meta.url)), "../../node_modules");
+    const moduleLink = join(serverDirectory, "node_modules");
+    await symlink(runtimeModules, moduleLink, "dir");
+    try {
+        const child = Bun.spawn([
+            process.execPath,
+            "build",
+            "--target=bun",
+            "--format=esm",
+            "--minify",
+            "--sourcemap=none",
+            "--env=disable",
+            `--outfile=${join(serverDirectory, "index.js")}`,
+            join(serverDirectory, "index.ts"),
+        ], { cwd: projectRoot, stdout: "pipe", stderr: "pipe" });
+        const [exitCode, output, error] = await Promise.all([
+            child.exited,
+            new Response(child.stdout).text(),
+            new Response(child.stderr).text(),
+        ]);
+        if (exitCode !== 0) {
+            throw new Error(error.trim() || output.trim() || "Unable to bundle the production server.");
+        }
+    }
+    finally {
+        await unlink(moduleLink);
+    }
+}
+export function rebaseManifest(source, projectRoot, sourceDirectory, targetDirectory) {
+    const sourcePrefix = manifestImportPrefix(sourceDirectory, projectRoot);
+    const targetPrefix = manifestImportPrefix(targetDirectory, projectRoot);
+    return source.replaceAll(`from "${sourcePrefix}`, `from "${targetPrefix}`);
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function manifestImportPrefix(directory, projectRoot) {
+    const rootPath = relative(directory, projectRoot).replaceAll("\\", "/");
+    return rootPath === "" ? "./" : `${rootPath}/`;
+}
+//# sourceMappingURL=build-support.js.map

package/dist/commands/build-support.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-support.js","sourceRoot":"","sources":["../../src/commands/build-support.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAEnD,MAAM,UAAU,UAAU;IACxB,OAAO;;;;;;;;;;;;CAYR,CAAC;AACF,CAAC;AAED,MAAM,UAAU,YAAY;IAC1B,OAAO;;;;;;;;;;;;;;CAcR,CAAC;AACF,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,eAAuB,EAAE,WAAmB;IAC7E,MAAM,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAAC;IAC9F,MAAM,UAAU,GAAG,IAAI,CAAC,eAAe,EAAE,cAAc,CAAC,CAAC;IACzD,MAAM,OAAO,CAAC,cAAc,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;IACjD,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CACrB;YACE,OAAO,CAAC,QAAQ;YAChB,OAAO;YACP,cAAc;YACd,cAAc;YACd,UAAU;YACV,kBAAkB;YAClB,eAAe;YACf,aAAa,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,EAAE;YAChD,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC;SAClC,EACD,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,CACrD,CAAC;QACF,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YAClD,KAAK,CAAC,MAAM;YACZ,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE;YACjC,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE;SAClC,CAAC,CAAC;QACH,IAAI,QAAQ,KAAK,CAAC,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,MAAM,CAAC,IAAI,EAAE,IAAI,yCAAyC,CAAC,CAAC;QAC9F,CAAC;IACH,CAAC;YAAS,CAAC;QACT,MAAM,MAAM,CAAC,UAAU,CAAC,CAAC;IAC3B,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc,CAC5B,MAAc,EACd,WAAmB,EACnB,eAAuB,EACvB,eAAuB;IAEvB,MAAM,YAAY,GAAG,oBAAoB,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;IACxE,MAAM,YAAY,GAAG,oBAAoB,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;IACxE,OAAO,MAAM,CAAC,UAAU,CAAC,SAAS,YAAY,EAAE,EAAE,SAAS,YAAY,EAAE,CAAC,CAAC;AAC7E,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,OAAO,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAChE,CAAC;AAED,SAAS,oBAAoB,CAAC,SAAiB,EAAE,WAAmB;IAClE,MAAM,QAAQ,GAAG,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IACxE,OAAO,QAAQ,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,QAAQ,GAAG,CAAC;AACjD,CAAC"}

package/dist/commands/build.d.ts

@@ -0,0 +1,18 @@
+import { type Diagnostic } from "@relkit/diagnostics";
+import { type CheckOptions, type CheckResult } from "./check.js";
+export interface BuildOptions extends CheckOptions {
+    readonly buildDirectory?: string;
+    readonly check?: (options: CheckOptions) => Promise<CheckResult>;
+}
+export interface BuildResult {
+    readonly ok: boolean;
+    readonly projectRoot: string;
+    readonly buildDirectory: string;
+    readonly graphHash?: string;
+    readonly diagnostics: readonly Diagnostic[];
+    readonly artifacts: readonly string[];
+}
+/** Builds a deterministic production directory from a successful compiler result. */
+export declare function buildProject(options?: BuildOptions): Promise<BuildResult>;
+export declare const runBuild: typeof buildProject;
+//# sourceMappingURL=build.d.ts.map

package/dist/commands/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/commands/build.ts"],"names":[],"mappings":"AAYA,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,EAAgB,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAU/E,MAAM,WAAW,YAAa,SAAQ,YAAY;IAChD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;CAClE;AACD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;IAC5C,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED,qFAAqF;AACrF,wBAAsB,YAAY,CAAC,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,WAAW,CAAC,CAgGnF;AAED,eAAO,MAAM,QAAQ,qBAAe,CAAC"}