@logixjs/core 0.0.1 → 1.0.0

package/dist/chunk-PBIUCQY3.js

@@ -0,0 +1,696 @@
+import {
+  ProcessRuntimeTag,
+  layer
+} from "./chunk-MYB2B5WX.js";
+import {
+  make
+} from "./chunk-ZBBMZMA6.js";
+import {
+  RootContextTag,
+  makeRootContext,
+  mergeRootContext,
+  readyRootContext
+} from "./chunk-YZDJMAKL.js";
+import {
+  ConcurrencyPolicyTag,
+  HostSchedulerTag,
+  ReadQueryStrictGateConfigTag,
+  SchedulingPolicySurfaceTag,
+  StateTransactionConfigTag,
+  declarativeLinkRuntimeLayer,
+  hostSchedulerLayer,
+  runtimeStoreLayer,
+  tickSchedulerLayer
+} from "./chunk-S4S5N4BJ.js";
+
+// src/internal/runtime/core/runner/ProgramRunner.errors.ts
+var summarizeCause = (cause) => {
+  if (cause instanceof Error) {
+    return { name: cause.name, message: cause.message };
+  }
+  return { message: typeof cause === "string" ? cause : void 0 };
+};
+var ProgramRunnerErrorBase = class extends Error {
+  constructor(params) {
+    super(params.message);
+    this.moduleId = params.identity.moduleId;
+    this.instanceId = params.identity.instanceId;
+    this.entrypoint = params.entrypoint;
+    this.hint = params.hint;
+  }
+  toJSON() {
+    return {
+      _tag: this._tag,
+      name: this.name,
+      message: this.message,
+      moduleId: this.moduleId,
+      instanceId: this.instanceId,
+      entrypoint: this.entrypoint,
+      hint: this.hint
+    };
+  }
+};
+var BootError = class extends ProgramRunnerErrorBase {
+  constructor(identity, cause) {
+    super({
+      message: "[Logix] Program boot failed",
+      identity,
+      entrypoint: "boot",
+      hint: "Check that options.layer / imports / providers are complete, and that no dependencies are missing during assembly."
+    });
+    this._tag = "BootError";
+    this.name = "BootError";
+    this.cause = summarizeCause(cause);
+  }
+  toJSON() {
+    return { ...super.toJSON(), cause: this.cause };
+  }
+};
+var MainError = class extends ProgramRunnerErrorBase {
+  constructor(identity, cause) {
+    super({
+      message: "[Logix] Program main failed",
+      identity,
+      entrypoint: "main",
+      hint: "Main failed: ensure main handles domain errors explicitly, and check for interruption or missing dependencies."
+    });
+    this._tag = "MainError";
+    this.name = "MainError";
+    this.cause = summarizeCause(cause);
+  }
+  toJSON() {
+    return { ...super.toJSON(), cause: this.cause };
+  }
+};
+var DisposeError = class extends ProgramRunnerErrorBase {
+  constructor(identity, cause) {
+    super({
+      message: "[Logix] Program dispose failed",
+      identity,
+      entrypoint: "dispose",
+      hint: "Dispose failed: a finalizer may have thrown, or scope/resource handles may be invalid; check onError/logs."
+    });
+    this._tag = "DisposeError";
+    this.name = "DisposeError";
+    this.cause = summarizeCause(cause);
+  }
+  toJSON() {
+    return { ...super.toJSON(), cause: this.cause };
+  }
+};
+var DisposeTimeoutError = class extends ProgramRunnerErrorBase {
+  constructor(identity, params) {
+    super({
+      message: "[Logix] Program dispose timed out",
+      identity,
+      entrypoint: "dispose",
+      hint: "Dispose timed out: if the program cannot exit naturally, resources may not be released or background fibers are still running."
+    });
+    this._tag = "DisposeTimeout";
+    this.name = "DisposeTimeoutError";
+    this.timeoutMs = params.timeoutMs;
+    this.elapsedMs = params.elapsedMs;
+    this.suggestions = [
+      "Check for event listeners that were not unregistered (e.g. process.on / emitter.on).",
+      "Check for fibers that were not joined/interrupt (long-lived watchers / Stream.run*).",
+      "Check for resource handles that were not closed (timer / socket / file handle)."
+    ];
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      timeoutMs: this.timeoutMs,
+      elapsedMs: this.elapsedMs,
+      suggestions: this.suggestions
+    };
+  }
+};
+
+// src/internal/runtime/AppRuntime.ts
+import { Effect, Exit, Layer, ManagedRuntime, ServiceMap } from "effect";
+
+// src/internal/runtime/core/AppAssemblyGraph.ts
+var STAGE_DEFINITIONS = [
+  { stageId: "validate.modules", dependsOn: [] },
+  { stageId: "validate.tags", dependsOn: ["validate.modules"] },
+  { stageId: "build.baseLayer", dependsOn: ["validate.tags"] },
+  { stageId: "build.baseEnv", dependsOn: ["build.baseLayer"] },
+  { stageId: "build.moduleEnvs", dependsOn: ["build.baseEnv"] },
+  { stageId: "merge.env", dependsOn: ["build.moduleEnvs"] },
+  { stageId: "rootContext.merge", dependsOn: ["merge.env"] },
+  { stageId: "rootContext.ready", dependsOn: ["rootContext.merge"] },
+  { stageId: "process.install", dependsOn: ["rootContext.ready"] }
+];
+var toSlimMessage = (error) => {
+  if (error instanceof Error && typeof error.message === "string" && error.message.length > 0) {
+    return error.message;
+  }
+  const message = error?.message;
+  if (typeof message === "string" && message.length > 0) {
+    return message;
+  }
+  if (typeof error === "string" && error.length > 0) {
+    return error;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+};
+var AppAssemblyGraph = class {
+  constructor(appId) {
+    this.appId = appId;
+    this.rootContextLifecycle = { state: "uninitialized" };
+    const mutableNodes = STAGE_DEFINITIONS.map((stage, index) => ({
+      stageId: stage.stageId,
+      stageSeq: index + 1,
+      dependsOn: stage.dependsOn,
+      status: "pending"
+    }));
+    this.nodes = mutableNodes;
+    this.nodeIndex = new Map(mutableNodes.map((node) => [node.stageId, node]));
+  }
+  reset() {
+    for (const node of this.nodes) {
+      node.status = "pending";
+      node.startedAtMs = void 0;
+      node.durationMs = void 0;
+      node.reasonCode = void 0;
+      node.message = void 0;
+    }
+    this.rootContextLifecycle = { state: "uninitialized" };
+    this.failure = void 0;
+  }
+  beginStage(stageId) {
+    const node = this.getNode(stageId);
+    if (node.status === "pending") {
+      node.status = "running";
+      node.startedAtMs = Date.now();
+    }
+  }
+  completeStage(stageId) {
+    const node = this.getNode(stageId);
+    node.status = "succeeded";
+    node.durationMs = this.computeDurationMs(node);
+  }
+  failStage(stageId, reasonCode, error) {
+    const node = this.getNode(stageId);
+    node.status = "failed";
+    node.durationMs = this.computeDurationMs(node);
+    node.reasonCode = reasonCode;
+    node.message = toSlimMessage(error);
+    this.failure = {
+      stageId,
+      stageSeq: node.stageSeq,
+      reasonCode,
+      message: node.message,
+      upstreamStages: node.dependsOn
+    };
+    if (stageId === "rootContext.merge" || stageId === "rootContext.ready") {
+      this.markRootContextFailed(reasonCode);
+    }
+    for (const currentNode of this.nodes) {
+      if (currentNode.stageSeq > node.stageSeq && currentNode.status === "pending") {
+        currentNode.status = "skipped";
+      }
+    }
+  }
+  ensureFailure(reasonCode, error) {
+    if (this.failure) {
+      return;
+    }
+    const fallbackNode = this.nodes.find((node) => node.status === "running") ?? this.nodes.find((node) => node.status === "pending") ?? this.nodes[this.nodes.length - 1];
+    if (!fallbackNode) {
+      return;
+    }
+    this.failStage(fallbackNode.stageId, reasonCode, error);
+  }
+  markRootContextMerged() {
+    const mergeStageSeq = this.getNode("rootContext.merge").stageSeq;
+    this.rootContextLifecycle = {
+      state: this.rootContextLifecycle.state === "ready" ? "ready" : "merged",
+      mergedAtStageSeq: mergeStageSeq,
+      readyAtStageSeq: this.rootContextLifecycle.readyAtStageSeq,
+      reasonCode: this.rootContextLifecycle.reasonCode
+    };
+  }
+  markRootContextReady() {
+    const readyStageSeq = this.getNode("rootContext.ready").stageSeq;
+    this.rootContextLifecycle = {
+      state: "ready",
+      mergedAtStageSeq: this.rootContextLifecycle.mergedAtStageSeq,
+      readyAtStageSeq: readyStageSeq,
+      reasonCode: void 0
+    };
+  }
+  buildReport(success) {
+    return {
+      version: 1,
+      appId: this.appId,
+      success,
+      nodes: this.nodes.map((node) => ({
+        stageId: node.stageId,
+        stageSeq: node.stageSeq,
+        dependsOn: node.dependsOn,
+        status: node.status,
+        durationMs: node.durationMs,
+        reasonCode: node.reasonCode,
+        message: node.message
+      })),
+      rootContextLifecycle: { ...this.rootContextLifecycle },
+      failure: this.failure ? { ...this.failure } : void 0
+    };
+  }
+  markRootContextFailed(reasonCode) {
+    this.rootContextLifecycle = {
+      state: "failed",
+      mergedAtStageSeq: this.rootContextLifecycle.mergedAtStageSeq,
+      readyAtStageSeq: this.rootContextLifecycle.readyAtStageSeq,
+      reasonCode
+    };
+  }
+  getNode(stageId) {
+    const node = this.nodeIndex.get(stageId);
+    if (!node) {
+      throw new Error(`[Logix] Unknown assembly stage: ${stageId}`);
+    }
+    return node;
+  }
+  computeDurationMs(node) {
+    if (node.startedAtMs === void 0) {
+      return void 0;
+    }
+    return Math.max(0, Date.now() - node.startedAtMs);
+  }
+};
+
+// src/internal/runtime/AppRuntime.ts
+var getTagKey = (tag) => {
+  const anyTag = tag;
+  if (typeof anyTag.key === "string") {
+    return anyTag.key;
+  }
+  if (typeof anyTag._id === "string") {
+    return anyTag._id;
+  }
+  if (typeof anyTag.toString === "function") {
+    return anyTag.toString();
+  }
+  return "[unknown-tag]";
+};
+var buildTagIndex = (entries) => {
+  const index = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const ownerId = String(entry.module.id);
+    const moduleTag = entry.module;
+    const moduleKey = getTagKey(moduleTag);
+    const moduleInfo = {
+      key: moduleKey,
+      tag: moduleTag,
+      ownerModuleId: ownerId,
+      source: "module"
+    };
+    const existingModuleInfos = index.get(moduleKey);
+    if (existingModuleInfos) {
+      existingModuleInfos.push(moduleInfo);
+    } else {
+      index.set(moduleKey, [moduleInfo]);
+    }
+    if (entry.serviceTags && entry.serviceTags.length > 0) {
+      for (const tag of entry.serviceTags) {
+        const key = getTagKey(tag);
+        const info = {
+          key,
+          tag,
+          ownerModuleId: ownerId,
+          source: "service"
+        };
+        const existingInfos = index.get(key);
+        if (existingInfos) {
+          existingInfos.push(info);
+        } else {
+          index.set(key, [info]);
+        }
+      }
+    }
+  }
+  return index;
+};
+var validateTags = (entries) => {
+  const index = buildTagIndex(entries);
+  const collisions = [];
+  for (const [key, infos] of index) {
+    if (infos.length <= 1) {
+      continue;
+    }
+    const owners = /* @__PURE__ */ new Set();
+    for (const info of infos) {
+      owners.add(info.ownerModuleId);
+    }
+    if (owners.size > 1) {
+      collisions.push({ key, conflicts: infos });
+    }
+  }
+  if (collisions.length === 0) {
+    return;
+  }
+  const message = "[Logix] Tag collision detected:\n" + collisions.map((c) => {
+    const header = `- key: ${c.key}`;
+    const lines = c.conflicts.map((i) => `  - owner: ${i.ownerModuleId}, source: ${i.source}`);
+    return [header, ...lines].join("\n");
+  }).join("\n");
+  const error = Object.assign(new Error(message), {
+    _tag: "TagCollisionError",
+    collisions
+  });
+  throw error;
+};
+var makeApp = (config) => {
+  const appModuleIds = config.modules.map((entry) => String(entry.module.id));
+  const appId = appModuleIds.length === 1 ? appModuleIds[0] : appModuleIds.slice().sort().join("~");
+  const assemblyGraph = new AppAssemblyGraph(appId);
+  let latestAssemblyReport;
+  const failAndThrow = (stageId, reasonCode, error) => {
+    assemblyGraph.failStage(stageId, reasonCode, error);
+    latestAssemblyReport = assemblyGraph.buildReport(false);
+    throw error;
+  };
+  assemblyGraph.beginStage("validate.modules");
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const entry of config.modules) {
+    const id = String(entry.module.id);
+    if (seenIds.has(id)) {
+      const error = new Error(
+        `[Logix] Duplicate Module ID/Tag detected: "${id}". 
+Ensure all modules in the application Runtime have unique IDs.`
+      );
+      failAndThrow("validate.modules", "boot::module_duplicate", error);
+    }
+    seenIds.add(id);
+  }
+  assemblyGraph.completeStage("validate.modules");
+  assemblyGraph.beginStage("validate.tags");
+  try {
+    validateTags(config.modules);
+    assemblyGraph.completeStage("validate.tags");
+  } catch (error) {
+    failAndThrow("validate.tags", "boot::tag_collision", error);
+  }
+  const stateTxnLayer = config.stateTransaction ? Layer.succeed(StateTransactionConfigTag, config.stateTransaction) : Layer.empty;
+  const resolvedSchedulingPolicy = config.schedulingPolicy ?? config.concurrencyPolicy;
+  const schedulingPolicyLayer = resolvedSchedulingPolicy ? Layer.succeed(SchedulingPolicySurfaceTag, resolvedSchedulingPolicy) : Layer.empty;
+  const readQueryStrictGateLayer = config.readQueryStrictGate ? Layer.succeed(ReadQueryStrictGateConfigTag, config.readQueryStrictGate) : Layer.empty;
+  const pinnedHostSchedulerLayer = config.hostScheduler !== void 0 ? Layer.succeed(HostSchedulerTag, config.hostScheduler) : void 0;
+  const tickServicesLayer = Layer.provideMerge(pinnedHostSchedulerLayer ?? hostSchedulerLayer)(
+    Layer.provideMerge(runtimeStoreLayer)(Layer.provideMerge(declarativeLinkRuntimeLayer)(tickSchedulerLayer()))
+  );
+  const appLayer = config.layer.pipe(Layer.provide(tickServicesLayer));
+  assemblyGraph.beginStage("build.baseLayer");
+  const baseLayer = Layer.mergeAll(
+    tickServicesLayer,
+    appLayer,
+    // If a HostScheduler override is requested, pin it as the final HostSchedulerTag value to avoid accidental divergence.
+    // (Build-time capture is handled above by injecting it into tickServicesLayer.)
+    pinnedHostSchedulerLayer ?? Layer.empty,
+    stateTxnLayer,
+    schedulingPolicyLayer,
+    // Keep explicit legacy alias provisioning in the Env merge path so older callsites that reference
+    // ConcurrencyPolicyTag keep identical behavior during phase-1 migration.
+    resolvedSchedulingPolicy ? Layer.succeed(ConcurrencyPolicyTag, resolvedSchedulingPolicy) : Layer.empty,
+    readQueryStrictGateLayer,
+    layer(),
+    Layer.effect(
+      RootContextTag,
+      makeRootContext({ appId, appModuleIds })
+    )
+  );
+  assemblyGraph.completeStage("build.baseLayer");
+  const runStage = (stageId, reasonCode, effect) => Effect.gen(function* () {
+    assemblyGraph.beginStage(stageId);
+    const exit = yield* Effect.exit(effect);
+    if (Exit.isSuccess(exit)) {
+      assemblyGraph.completeStage(stageId);
+      return exit.value;
+    }
+    assemblyGraph.failStage(stageId, reasonCode, exit.cause);
+    latestAssemblyReport = assemblyGraph.buildReport(false);
+    return yield* Effect.failCause(exit.cause);
+  });
+  const finalLayer = Layer.unwrap(
+    Effect.gen(function* () {
+      assemblyGraph.reset();
+      assemblyGraph.beginStage("validate.modules");
+      assemblyGraph.completeStage("validate.modules");
+      assemblyGraph.beginStage("validate.tags");
+      assemblyGraph.completeStage("validate.tags");
+      assemblyGraph.beginStage("build.baseLayer");
+      assemblyGraph.completeStage("build.baseLayer");
+      const scope = yield* Effect.scope;
+      const env = yield* Effect.gen(function* () {
+        const baseEnv = yield* runStage(
+          "build.baseEnv",
+          "boot::base_layer_build_failed",
+          Layer.buildWithScope(baseLayer, scope)
+        );
+        const moduleEnv = yield* runStage(
+          "build.moduleEnvs",
+          "boot::module_layer_build_failed",
+          config.modules.length > 0 ? Effect.provide(
+            Layer.buildWithScope(
+              config.modules.length === 1 ? config.modules[0].layer : config.modules.slice(1).reduce((acc, entry) => Layer.merge(acc, entry.layer), config.modules[0].layer),
+              scope
+            ),
+            baseEnv
+          ) : Effect.succeed(void 0)
+        );
+        const mergedEnv = yield* runStage(
+          "merge.env",
+          "boot::env_merge_failed",
+          Effect.sync(() => moduleEnv ? ServiceMap.merge(baseEnv, moduleEnv) : baseEnv)
+        );
+        const rootContext = yield* runStage(
+          "rootContext.merge",
+          "boot::root_context_merge_failed",
+          Effect.flatMap(
+            Effect.sync(() => ServiceMap.get(mergedEnv, RootContextTag)),
+            (root) => mergeRootContext(root, mergedEnv)
+          )
+        );
+        assemblyGraph.markRootContextMerged();
+        yield* runStage(
+          "rootContext.ready",
+          "boot::root_context_ready_failed",
+          readyRootContext(rootContext)
+        );
+        assemblyGraph.markRootContextReady();
+        const processRuntime = ServiceMap.get(
+          mergedEnv,
+          ProcessRuntimeTag
+        );
+        yield* runStage(
+          "process.install",
+          "boot::process_install_failed",
+          Effect.forEach(
+            config.processes,
+            (process) => Effect.gen(function* () {
+              const installation = yield* Effect.provide(
+                processRuntime.install(process, {
+                  scope: { type: "app", appId },
+                  enabled: true,
+                  installedAt: "appRuntime"
+                }),
+                mergedEnv
+              );
+              if (installation === void 0) {
+                yield* Effect.provide(
+                  config.onError ? Effect.catchCause(process, config.onError) : process,
+                  mergedEnv
+                ).pipe(Effect.forkScoped());
+              }
+            }),
+            { discard: true }
+          )
+        );
+        return mergedEnv;
+      });
+      latestAssemblyReport = assemblyGraph.buildReport(true);
+      return Layer.effectServices(Effect.succeed(env));
+    }).pipe(
+      Effect.catchCause(
+        (cause) => Effect.gen(function* () {
+          assemblyGraph.ensureFailure("boot::unknown", cause);
+          latestAssemblyReport = assemblyGraph.buildReport(false);
+          return yield* Effect.failCause(cause);
+        })
+      )
+    )
+  );
+  return {
+    definition: config,
+    layer: finalLayer,
+    makeRuntime: () => ManagedRuntime.make(finalLayer),
+    getAssemblyReport: () => latestAssemblyReport
+  };
+};
+var provide = (module, resource) => {
+  const layer2 = isLayer(resource) ? resource : Layer.succeed(module, resource);
+  return { module, layer: layer2 };
+};
+var isLayer = (value) => Layer.isLayer(value);
+
+// src/internal/runtime/core/runner/ProgramRunner.closeScope.ts
+import { Cause, Effect as Effect2, Exit as Exit2, Scope } from "effect";
+var closeProgramScope = (params) => {
+  return Effect2.gen(function* () {
+    const start = Date.now();
+    const result = yield* Effect2.promise(
+      () => new Promise((resolve) => {
+        const timer = setTimeout(() => resolve({ _tag: "Timeout" }), params.timeoutMs);
+        void Effect2.runPromiseExit(Scope.close(params.scope, Exit2.void)).then((exit2) => {
+          clearTimeout(timer);
+          resolve(exit2);
+        });
+      })
+    );
+    if (result._tag === "Timeout") {
+      const error = new DisposeTimeoutError(params.identity, {
+        timeoutMs: params.timeoutMs,
+        elapsedMs: Date.now() - start
+      });
+      if (typeof params.onError === "function") {
+        yield* params.onError(Cause.die(error)).pipe(Effect2.catchCause(() => Effect2.void));
+      }
+      return yield* Effect2.die(error);
+    }
+    const exit = result;
+    if (Exit2.isSuccess(exit)) {
+      return;
+    }
+    return yield* Effect2.die(new DisposeError(params.identity, exit.cause));
+  });
+};
+
+// src/internal/runtime/core/runner/ProgramRunner.signals.ts
+import { Effect as Effect3, Exit as Exit3, Scope as Scope2 } from "effect";
+var getProcess = () => globalThis.process;
+var isNodeProcess = (value) => typeof value === "object" && value !== null && typeof value.on === "function";
+var removeListener = (proc, event, handler) => {
+  if (typeof proc.off === "function") {
+    proc.off(event, handler);
+    return;
+  }
+  if (typeof proc.removeListener === "function") {
+    proc.removeListener(event, handler);
+  }
+};
+var installGracefulShutdownHandlers = (params) => {
+  if (!params.enabled) {
+    return Effect3.void;
+  }
+  const proc = getProcess();
+  if (!isNodeProcess(proc)) {
+    return Effect3.void;
+  }
+  const handler = () => {
+    const effect = params.onSignal ? params.onSignal() : Scope2.close(params.scope, Exit3.void).pipe(Effect3.asVoid);
+    void Effect3.runPromise(effect);
+  };
+  return Effect3.gen(function* () {
+    yield* Scope2.addFinalizer(
+      params.scope,
+      Effect3.sync(() => {
+        removeListener(proc, "SIGINT", handler);
+        removeListener(proc, "SIGTERM", handler);
+      })
+    );
+    yield* Effect3.sync(() => {
+      proc.on("SIGINT", handler);
+      proc.on("SIGTERM", handler);
+    });
+  });
+};
+
+// src/internal/runtime/core/runner/ProgramRunner.kernel.ts
+import { Cause as Cause2, Effect as Effect4, Exit as Exit4, Scope as Scope3 } from "effect";
+var makeProgramRunnerKernel = (makeRuntime, rootImpl, options) => Effect4.gen(function* () {
+  const identity = {
+    moduleId: String(rootImpl.module.id),
+    instanceId: "unknown"
+  };
+  const scope = yield* Scope3.make();
+  const runtime = makeRuntime(rootImpl, options);
+  const setInstanceId = (value) => {
+    identity.instanceId = typeof value === "string" && value.length > 0 ? value : String(value ?? "unknown");
+  };
+  const close = (params) => Effect4.gen(function* () {
+    const exit = yield* Effect4.exit(
+      closeProgramScope({
+        scope,
+        timeoutMs: params.timeoutMs,
+        identity,
+        onError: params.onError
+      })
+    );
+    if (Exit4.isSuccess(exit)) {
+      const disposeResult = yield* Effect4.promise(
+        () => new Promise((resolve) => {
+          const timer = setTimeout(() => resolve({ _tag: "Timeout" }), params.timeoutMs);
+          void runtime.dispose().then(
+            () => {
+              clearTimeout(timer);
+              resolve({ _tag: "Success" });
+            },
+            (error) => {
+              clearTimeout(timer);
+              resolve({ _tag: "Failure", error });
+            }
+          );
+        })
+      );
+      if (disposeResult._tag === "Timeout") {
+        return yield* Effect4.die(
+          new DisposeTimeoutError(identity, {
+            timeoutMs: params.timeoutMs,
+            elapsedMs: params.timeoutMs
+          })
+        );
+      }
+      if (disposeResult._tag === "Failure") {
+        return yield* Effect4.die(new DisposeError(identity, Cause2.die(disposeResult.error)));
+      }
+      return;
+    }
+    void runtime.dispose();
+    return yield* Effect4.failCause(exit.cause);
+  });
+  const installSignals = (enabled) => installGracefulShutdownHandlers({ scope, enabled });
+  const toContext = (moduleRuntime) => ({
+    scope,
+    runtime,
+    module: moduleRuntime,
+    $: make(rootImpl.module.shape, moduleRuntime)
+  });
+  return {
+    scope,
+    runtime,
+    identity,
+    installSignals,
+    close,
+    setInstanceId,
+    toContext
+  };
+});
+
+export {
+  BootError,
+  MainError,
+  DisposeError,
+  DisposeTimeoutError,
+  closeProgramScope,
+  installGracefulShutdownHandlers,
+  makeProgramRunnerKernel,
+  makeApp,
+  provide
+};
+//# sourceMappingURL=chunk-PBIUCQY3.js.map