@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/chunk-BUVHG3NJ.js

@@ -0,0 +1,439 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+import {
+  ProcessRuntimeTag,
+  layer
+} from "./chunk-KDJR27JV.js";
+import {
+  make
+} from "./chunk-RIWOEI3T.js";
+import {
+  RootContextTag
+} from "./chunk-UBMUY7WO.js";
+import {
+  ConcurrencyPolicyTag,
+  HostSchedulerTag,
+  ReadQueryStrictGateConfigTag,
+  StateTransactionConfigTag,
+  declarativeLinkRuntimeLayer,
+  hostSchedulerLayer,
+  runtimeStoreLayer,
+  tickSchedulerLayer
+} from "./chunk-YMVMZA3U.js";
+import {
+  getGlobalHostScheduler
+} from "./chunk-UJGVDFZN.js";
+
+// ../logix-core/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
+    };
+  }
+};
+
+// ../logix-core/src/internal/runtime/AppRuntime.ts
+import { Context, Deferred, Effect, Layer, ManagedRuntime } from "../effect.js";
+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 seenIds = /* @__PURE__ */ new Set();
+  for (const entry of config.modules) {
+    const id = String(entry.module.id);
+    if (seenIds.has(id)) {
+      throw new Error(
+        `[Logix] Duplicate Module ID/Tag detected: "${id}". 
+Ensure all modules in the application Runtime have unique IDs.`
+      );
+    }
+    seenIds.add(id);
+  }
+  validateTags(config.modules);
+  const stateTxnLayer = config.stateTransaction ? Layer.succeed(StateTransactionConfigTag, config.stateTransaction) : Layer.empty;
+  const concurrencyPolicyLayer = config.concurrencyPolicy ? Layer.succeed(ConcurrencyPolicyTag, config.concurrencyPolicy) : Layer.empty;
+  const readQueryStrictGateLayer = config.readQueryStrictGate ? Layer.succeed(ReadQueryStrictGateConfigTag, config.readQueryStrictGate) : Layer.empty;
+  const appModuleIds = config.modules.map((entry) => String(entry.module.id));
+  const appId = appModuleIds.length === 1 ? appModuleIds[0] : appModuleIds.slice().sort().join("~");
+  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));
+  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,
+    concurrencyPolicyLayer,
+    readQueryStrictGateLayer,
+    layer(),
+    Layer.effect(
+      RootContextTag,
+      Effect.gen(function* () {
+        const ready = yield* Deferred.make();
+        return { context: void 0, ready, appId, appModuleIds };
+      })
+    )
+  );
+  const finalLayer = Layer.unwrapScoped(
+    Effect.gen(function* () {
+      const scope = yield* Effect.scope;
+      const [patch, env] = yield* Effect.diffFiberRefs(
+        Effect.gen(function* () {
+          const baseEnv = yield* Layer.buildWithScope(baseLayer, scope);
+          const moduleEnv = config.modules.length > 0 ? yield* 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
+          ) : void 0;
+          const mergedEnv = moduleEnv ? Context.merge(baseEnv, moduleEnv) : baseEnv;
+          const rootContext = Context.get(mergedEnv, RootContextTag);
+          rootContext.context = mergedEnv;
+          yield* Deferred.succeed(rootContext.ready, mergedEnv);
+          const processRuntime = Context.get(
+            mergedEnv,
+            ProcessRuntimeTag
+          );
+          yield* 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.forkScoped(
+                  Effect.provide(
+                    config.onError ? Effect.catchAllCause(process, config.onError) : process,
+                    mergedEnv
+                  )
+                );
+              }
+            }),
+            { discard: true }
+          );
+          return mergedEnv;
+        })
+      );
+      const fiberRefsLayer = Layer.scopedDiscard(Effect.patchFiberRefs(patch));
+      return Layer.mergeAll(Layer.succeedContext(env), fiberRefsLayer);
+    })
+  );
+  return {
+    definition: config,
+    layer: finalLayer,
+    makeRuntime: () => ManagedRuntime.make(finalLayer)
+  };
+};
+var provide = (module, resource) => {
+  const layer2 = isLayer(resource) ? resource : Layer.succeed(module, resource);
+  return { module, layer: layer2 };
+};
+var isLayer = (value) => typeof value === "object" && value !== null && Layer.LayerTypeId in value;
+
+// ../logix-core/src/internal/runtime/core/runner/ProgramRunner.closeScope.ts
+import { Cause, Effect as Effect2, Exit, Fiber, Option, Scope } from "../effect.js";
+var closeProgramScope = (params) => {
+  return Effect2.gen(function* () {
+    const start = Date.now();
+    const hostSchedulerOpt = yield* Effect2.serviceOption(HostSchedulerTag);
+    const hostScheduler = Option.isSome(hostSchedulerOpt) ? hostSchedulerOpt.value : getGlobalHostScheduler();
+    const yieldMicrotask = Effect2.async((resume) => {
+      hostScheduler.scheduleMicrotask(() => resume(Effect2.void));
+    });
+    const fiber = yield* Effect2.forkDaemon(Scope.close(params.scope, Exit.void));
+    while (true) {
+      const exitOpt = yield* Fiber.poll(fiber);
+      if (Option.isSome(exitOpt)) {
+        const exit = exitOpt.value;
+        if (exit._tag === "Success") {
+          return;
+        }
+        return yield* Effect2.die(new DisposeError(params.identity, exit.cause));
+      }
+      const elapsedMs = Date.now() - start;
+      if (elapsedMs >= params.timeoutMs) {
+        const error = new DisposeTimeoutError(params.identity, {
+          timeoutMs: params.timeoutMs,
+          elapsedMs
+        });
+        if (typeof params.onError === "function") {
+          yield* params.onError(Cause.die(error)).pipe(Effect2.catchAllCause(() => Effect2.void));
+        }
+        yield* Fiber.interruptFork(fiber);
+        return yield* Effect2.die(error);
+      }
+      yield* yieldMicrotask;
+    }
+  });
+};
+
+// ../logix-core/src/internal/runtime/core/runner/ProgramRunner.signals.ts
+import { Effect as Effect3, Exit as Exit2, Scope as Scope2 } from "../effect.js";
+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 = () => {
+    void Effect3.runPromise(Scope2.close(params.scope, Exit2.void));
+  };
+  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);
+    });
+  });
+};
+
+// ../logix-core/src/internal/runtime/core/runner/ProgramRunner.kernel.ts
+import { Effect as Effect4, Scope as Scope3 } from "../effect.js";
+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);
+  yield* Scope3.addFinalizer(scope, Effect4.promise(() => runtime.dispose()).pipe(Effect4.asVoid));
+  const setInstanceId = (value) => {
+    identity.instanceId = typeof value === "string" && value.length > 0 ? value : String(value ?? "unknown");
+  };
+  const close = (params) => closeProgramScope({
+    scope,
+    timeoutMs: params.timeoutMs,
+    identity,
+    onError: params.onError
+  });
+  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=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/runner/ProgramRunner.errors.ts", "../../../../logix-core/src/internal/runtime/AppRuntime.ts", "../../../../logix-core/src/internal/runtime/core/runner/ProgramRunner.closeScope.ts", "../../../../logix-core/src/internal/runtime/core/runner/ProgramRunner.signals.ts", "../../../../logix-core/src/internal/runtime/core/runner/ProgramRunner.kernel.ts"],
  "sourcesContent": ["export type ProgramRunnerErrorTag = 'BootError' | 'MainError' | 'DisposeError' | 'DisposeTimeout'\n\nexport interface ProgramIdentity {\n  moduleId: string\n  instanceId: string\n}\n\nconst summarizeCause = (cause: unknown): { name?: string; message?: string } => {\n  if (cause instanceof Error) {\n    return { name: cause.name, message: cause.message }\n  }\n  return { message: typeof cause === 'string' ? cause : undefined }\n}\n\nabstract class ProgramRunnerErrorBase extends Error {\n  abstract readonly _tag: ProgramRunnerErrorTag\n  readonly moduleId: string\n  readonly instanceId: string\n  readonly entrypoint: 'boot' | 'main' | 'dispose'\n  readonly hint?: string\n\n  protected constructor(params: {\n    readonly message: string\n    readonly identity: ProgramIdentity\n    readonly entrypoint: 'boot' | 'main' | 'dispose'\n    readonly hint?: string\n  }) {\n    super(params.message)\n    this.moduleId = params.identity.moduleId\n    this.instanceId = params.identity.instanceId\n    this.entrypoint = params.entrypoint\n    this.hint = params.hint\n  }\n\n  toJSON(): Record<string, unknown> {\n    return {\n      _tag: this._tag,\n      name: this.name,\n      message: this.message,\n      moduleId: this.moduleId,\n      instanceId: this.instanceId,\n      entrypoint: this.entrypoint,\n      hint: this.hint,\n    }\n  }\n}\n\nexport class BootError extends ProgramRunnerErrorBase {\n  readonly _tag = 'BootError' as const\n  readonly cause?: { name?: string; message?: string }\n\n  constructor(identity: ProgramIdentity, cause: unknown) {\n    super({\n      message: '[Logix] Program boot failed',\n      identity,\n      entrypoint: 'boot',\n      hint: 'Check that options.layer / imports / providers are complete, and that no dependencies are missing during assembly.',\n    })\n    this.name = 'BootError'\n    this.cause = summarizeCause(cause)\n  }\n\n  override toJSON(): Record<string, unknown> {\n    return { ...super.toJSON(), cause: this.cause }\n  }\n}\n\nexport class MainError extends ProgramRunnerErrorBase {\n  readonly _tag = 'MainError' as const\n  readonly cause?: { name?: string; message?: string }\n\n  constructor(identity: ProgramIdentity, cause: unknown) {\n    super({\n      message: '[Logix] Program main failed',\n      identity,\n      entrypoint: 'main',\n      hint: 'Main failed: ensure main handles domain errors explicitly, and check for interruption or missing dependencies.',\n    })\n    this.name = 'MainError'\n    this.cause = summarizeCause(cause)\n  }\n\n  override toJSON(): Record<string, unknown> {\n    return { ...super.toJSON(), cause: this.cause }\n  }\n}\n\nexport class DisposeError extends ProgramRunnerErrorBase {\n  readonly _tag = 'DisposeError' as const\n  readonly cause?: { name?: string; message?: string }\n\n  constructor(identity: ProgramIdentity, cause: unknown) {\n    super({\n      message: '[Logix] Program dispose failed',\n      identity,\n      entrypoint: 'dispose',\n      hint: 'Dispose failed: a finalizer may have thrown, or scope/resource handles may be invalid; check onError/logs.',\n    })\n    this.name = 'DisposeError'\n    this.cause = summarizeCause(cause)\n  }\n\n  override toJSON(): Record<string, unknown> {\n    return { ...super.toJSON(), cause: this.cause }\n  }\n}\n\nexport class DisposeTimeoutError extends ProgramRunnerErrorBase {\n  readonly _tag = 'DisposeTimeout' as const\n  readonly timeoutMs: number\n  readonly elapsedMs: number\n  readonly suggestions: ReadonlyArray<string>\n\n  constructor(identity: ProgramIdentity, params: { readonly timeoutMs: number; readonly elapsedMs: number }) {\n    super({\n      message: '[Logix] Program dispose timed out',\n      identity,\n      entrypoint: 'dispose',\n      hint: 'Dispose timed out: if the program cannot exit naturally, resources may not be released or background fibers are still running.',\n    })\n    this.name = 'DisposeTimeoutError'\n    this.timeoutMs = params.timeoutMs\n    this.elapsedMs = params.elapsedMs\n    this.suggestions = [\n      'Check for event listeners that were not unregistered (e.g. process.on / emitter.on).',\n      'Check for fibers that were not joined/interrupt (long-lived watchers / Stream.run*).',\n      'Check for resource handles that were not closed (timer / socket / file handle).',\n    ]\n  }\n\n  override toJSON(): Record<string, unknown> {\n    return {\n      ...super.toJSON(),\n      timeoutMs: this.timeoutMs,\n      elapsedMs: this.elapsedMs,\n      suggestions: this.suggestions,\n    }\n  }\n}\n", "import { Context, Deferred, Effect, Layer, ManagedRuntime } from 'effect'\nimport {\n  ConcurrencyPolicyTag,\n  ReadQueryStrictGateConfigTag,\n  StateTransactionConfigTag,\n  declarativeLinkRuntimeLayer,\n  hostSchedulerLayer,\n  HostSchedulerTag,\n  runtimeStoreLayer,\n  tickSchedulerLayer,\n  type ConcurrencyPolicy,\n  type ReadQueryStrictGateRuntimeConfig,\n  type StateTransactionRuntimeConfig,\n} from './core/env.js'\nimport { RootContextTag, type RootContext } from './core/RootContext.js'\nimport type { HostScheduler } from './core/HostScheduler.js'\nimport * as ProcessRuntime from './core/process/ProcessRuntime.js'\nimport type { AnyModuleShape, ModuleTag, ModuleRuntime, StateOf, ActionOf } from './core/module.js'\n\n/**\n * AppModuleEntry: a module entry produced by Logix.provide.\n *\n * - module: the Module definition object (both a Tag and a carrier of shape info + factory capability).\n * - layer: the runtime Layer for the Module.\n */\nexport interface AppModuleEntry {\n  readonly module: ModuleTag<any, any>\n  readonly layer: Layer.Layer<any, any, any>\n  /**\n   * Optional: list of Service Tags provided by this module's layer.\n   *\n   * - Used only during app assembly for tag collision detection and Env topology analysis.\n   * - Internally, AppRuntime assembly can declare this explicitly via provideWithTags.\n   * - Does not affect runtime behavior; if omitted, the module layer is treated as \"no explicit service tags declared\".\n   */\n  readonly serviceTags?: ReadonlyArray<Context.Tag<any, any>>\n}\n\nexport interface LogixAppConfig<R> {\n  readonly layer: Layer.Layer<R, never, never>\n  readonly modules: ReadonlyArray<AppModuleEntry>\n  readonly processes: ReadonlyArray<Effect.Effect<void, any, any>>\n  readonly onError?: (cause: import('effect').Cause.Cause<unknown>) => Effect.Effect<void>\n  /**\n   * Optional HostScheduler override for this Runtime.\n   *\n   * IMPORTANT:\n   * - Services like TickScheduler capture HostScheduler at Layer build-time (073).\n   * - This option injects the override into the tick services build pipeline to avoid env-override pitfalls.\n   */\n  readonly hostScheduler?: HostScheduler\n  /**\n   * Runtime-level default StateTransaction config:\n   * - If not provided, each ModuleRuntime falls back to NODE_ENV-based default instrumentation.\n   * - If instrumentation is provided, it becomes the default instrumentation for modules under this Runtime;\n   *   individual modules may still override it via ModuleImpl.stateTransaction.\n   */\n  readonly stateTransaction?: StateTransactionRuntimeConfig\n  /**\n   * Runtime-level concurrency policy:\n   * - If not provided, each entrypoint falls back to builtin defaults (e.g. concurrencyLimit=16).\n   * - If provided, it becomes the default policy for modules under this Runtime;\n   *   individual modules may still override via runtime_module/provider (merged by ModuleRuntime resolver).\n   */\n  readonly concurrencyPolicy?: ConcurrencyPolicy\n  /**\n   * ReadQuery strict gate (057):\n   * - Used in CI/perf gates to upgrade dynamic fallbacks into failures or warnings.\n   * - Not provided by default (preserve usability).\n   */\n  readonly readQueryStrictGate?: ReadQueryStrictGateRuntimeConfig\n}\n\nexport interface AppDefinition<R> {\n  readonly definition: LogixAppConfig<R>\n  readonly layer: Layer.Layer<R, never, never>\n  readonly makeRuntime: () => ManagedRuntime.ManagedRuntime<R, never>\n}\n\ninterface TagInfo {\n  readonly key: string\n  readonly tag: Context.Tag<any, any>\n  readonly ownerModuleId: string\n  readonly source: 'module' | 'service'\n}\n\ninterface TagCollision {\n  readonly key: string\n  readonly conflicts: ReadonlyArray<TagInfo>\n}\n\ninterface TagCollisionError extends Error {\n  readonly _tag: 'TagCollisionError'\n  readonly collisions: ReadonlyArray<TagCollision>\n}\n\nconst getTagKey = (tag: Context.Tag<any, any>): string => {\n  const anyTag = tag as any\n  if (typeof anyTag.key === 'string') {\n    return anyTag.key\n  }\n  if (typeof anyTag._id === 'string') {\n    return anyTag._id\n  }\n  if (typeof anyTag.toString === 'function') {\n    return anyTag.toString()\n  }\n  return '[unknown-tag]'\n}\n\nconst buildTagIndex = (entries: ReadonlyArray<AppModuleEntry>): Map<string, TagInfo[]> => {\n  const index = new Map<string, TagInfo[]>()\n\n  for (const entry of entries) {\n    const ownerId = String(entry.module.id)\n\n    // Record the Module tag itself.\n    const moduleTag = entry.module as unknown as Context.Tag<any, any>\n    const moduleKey = getTagKey(moduleTag)\n    const moduleInfo: TagInfo = {\n      key: moduleKey,\n      tag: moduleTag,\n      ownerModuleId: ownerId,\n      source: 'module',\n    }\n    const existingModuleInfos = index.get(moduleKey)\n    if (existingModuleInfos) {\n      existingModuleInfos.push(moduleInfo)\n    } else {\n      index.set(moduleKey, [moduleInfo])\n    }\n\n    // Record explicitly declared service tags (if any).\n    if (entry.serviceTags && entry.serviceTags.length > 0) {\n      for (const tag of entry.serviceTags) {\n        const key = getTagKey(tag)\n        const info: TagInfo = {\n          key,\n          tag,\n          ownerModuleId: ownerId,\n          source: 'service',\n        }\n        const existingInfos = index.get(key)\n        if (existingInfos) {\n          existingInfos.push(info)\n        } else {\n          index.set(key, [info])\n        }\n      }\n    }\n  }\n\n  return index\n}\n\nconst validateTags = (entries: ReadonlyArray<AppModuleEntry>): void => {\n  const index = buildTagIndex(entries)\n  const collisions: TagCollision[] = []\n\n  for (const [key, infos] of index) {\n    if (infos.length <= 1) {\n      continue\n    }\n    const owners = new Set<string>()\n    for (const info of infos) {\n      owners.add(info.ownerModuleId)\n    }\n    // Treat it as a collision only when the same key appears under multiple different modules.\n    // Duplicates within a single module are not considered an error (may come from multi-layer composition).\n    if (owners.size > 1) {\n      collisions.push({ key, conflicts: infos })\n    }\n  }\n\n  if (collisions.length === 0) {\n    return\n  }\n\n  const message =\n    '[Logix] Tag collision detected:\\n' +\n    collisions\n      .map((c) => {\n        const header = `- key: ${c.key}`\n        const lines = c.conflicts.map((i) => `  - owner: ${i.ownerModuleId}, source: ${i.source}`)\n        return [header, ...lines].join('\\n')\n      })\n      .join('\\n')\n\n  const error: TagCollisionError = Object.assign(new Error(message), {\n    _tag: 'TagCollisionError' as const,\n    collisions,\n  })\n\n  throw error\n}\n\nexport const makeApp = <R>(config: LogixAppConfig<R>): AppDefinition<R> => {\n  const seenIds = new Set<string>()\n  for (const entry of config.modules) {\n    const id = String(entry.module.id)\n\n    if (seenIds.has(id)) {\n      throw new Error(\n        `[Logix] Duplicate Module ID/Tag detected: \"${id}\". \\nEnsure all modules in the application Runtime have unique IDs.`,\n      )\n    }\n    seenIds.add(id)\n  }\n\n  // Validate tag collisions before merging layers.\n  // This exposes \"the same ServiceTag implemented by multiple modules\" early, avoiding silent Env overrides.\n  validateTags(config.modules)\n\n  // If the Runtime provides a unified StateTransaction config, attach the corresponding service to the app Env.\n  const stateTxnLayer: Layer.Layer<R, never, never> = config.stateTransaction\n    ? (Layer.succeed(StateTransactionConfigTag, config.stateTransaction) as Layer.Layer<R, never, never>)\n    : (Layer.empty as Layer.Layer<R, never, never>)\n\n  // If the Runtime provides a unified ConcurrencyPolicy, attach the corresponding service to the app Env.\n  const concurrencyPolicyLayer: Layer.Layer<R, never, never> = config.concurrencyPolicy\n    ? (Layer.succeed(ConcurrencyPolicyTag, config.concurrencyPolicy) as Layer.Layer<R, never, never>)\n    : (Layer.empty as Layer.Layer<R, never, never>)\n\n  // If the Runtime provides a ReadQuery strict gate, attach the corresponding service to the app Env.\n  const readQueryStrictGateLayer: Layer.Layer<R, never, never> = config.readQueryStrictGate\n    ? (Layer.succeed(ReadQueryStrictGateConfigTag, config.readQueryStrictGate) as Layer.Layer<R, never, never>)\n    : (Layer.empty as Layer.Layer<R, never, never>)\n\n  const appModuleIds = config.modules.map((entry) => String(entry.module.id))\n  const appId = appModuleIds.length === 1 ? appModuleIds[0]! : appModuleIds.slice().sort().join('~')\n\n  const pinnedHostSchedulerLayer: Layer.Layer<any, never, never> | undefined =\n    config.hostScheduler !== undefined\n      ? (Layer.succeed(HostSchedulerTag, config.hostScheduler) as Layer.Layer<any, never, never>)\n      : undefined\n\n  const tickServicesLayer = Layer.provideMerge(pinnedHostSchedulerLayer ?? hostSchedulerLayer)(\n    Layer.provideMerge(runtimeStoreLayer)(Layer.provideMerge(declarativeLinkRuntimeLayer)(tickSchedulerLayer())),\n  )\n\n  // Provide tick services as the baseline runtime env for caller layers.\n  // This allows app layers to override TickScheduler/HostScheduler while still depending on RuntimeStore/DeclarativeLinkRuntime.\n  const appLayer = (config.layer as Layer.Layer<any, never, never>).pipe(Layer.provide(tickServicesLayer))\n\n  const baseLayer = Layer.mergeAll(\n    tickServicesLayer,\n    appLayer,\n    // If a HostScheduler override is requested, pin it as the final HostSchedulerTag value to avoid accidental divergence.\n    // (Build-time capture is handled above by injecting it into tickServicesLayer.)\n    pinnedHostSchedulerLayer ?? (Layer.empty as Layer.Layer<any, never, never>),\n    stateTxnLayer,\n    concurrencyPolicyLayer,\n    readQueryStrictGateLayer,\n    ProcessRuntime.layer(),\n    Layer.effect(\n      RootContextTag,\n      Effect.gen(function* () {\n        const ready = yield* Deferred.make<Context.Context<any>>()\n        return { context: undefined, ready, appId, appModuleIds } satisfies RootContext\n      }),\n    ),\n  ) as Layer.Layer<R, never, never>\n\n  const finalLayer = Layer.unwrapScoped(\n    Effect.gen(function* () {\n      const scope = yield* Effect.scope\n\n      // buildWithScope builds layers within the current scope and patches FiberRefs (e.g. Debug sinks).\n      // We wrap it with diffFiberRefs to capture FiberRef patch changes, then feed the patch back as a Layer,\n      // so FiberRef modifications are not \"washed out\" during assembly.\n      //\n      // IMPORTANT (073):\n      // - Build baseLayer first, then build module layers under baseEnv.\n      // - Otherwise, module initialization may fork long-lived fibers (txnQueue/logics) before TickScheduler/RuntimeStore\n      //   is available, and those fibers will permanently miss the runtime services due to Env capture semantics.\n      const [patch, env] = yield* Effect.diffFiberRefs(\n        Effect.gen(function* () {\n          const baseEnv = yield* Layer.buildWithScope(baseLayer, scope)\n\n          const moduleEnv =\n            config.modules.length > 0\n              ? yield* Effect.provide(\n                  Layer.buildWithScope(\n                    config.modules.length === 1\n                      ? config.modules[0]!.layer\n                      : config.modules\n                          .slice(1)\n                          .reduce((acc, entry) => Layer.merge(acc, entry.layer), config.modules[0]!.layer),\n                    scope,\n                  ),\n                  baseEnv as Context.Context<any>,\n                )\n              : undefined\n\n          const mergedEnv = moduleEnv\n            ? (Context.merge(baseEnv as Context.Context<any>, moduleEnv as Context.Context<any>) as Context.Context<any>)\n            : (baseEnv as Context.Context<any>)\n\n          // After env is built, complete RootContext (single source of truth for the root provider).\n          // Note: module logics may already be forked and waiting for RootContext in the run phase; completing it here unblocks them.\n          // RootContextTag is an internal service injected by AppRuntime (should not leak into external R types);\n          // keep types minimal to avoid incorrect generic inference in Context.get.\n          const rootContext = Context.get(mergedEnv as Context.Context<any>, RootContextTag as any) as RootContext\n\n          rootContext.context = mergedEnv as Context.Context<any>\n          yield* Deferred.succeed(rootContext.ready, mergedEnv as Context.Context<any>)\n\n          const processRuntime = Context.get(\n            mergedEnv as Context.Context<any>,\n            ProcessRuntime.ProcessRuntimeTag as any,\n          ) as ProcessRuntime.ProcessRuntime\n\n          // After Env is fully ready, start app-level long-lived processes (Process / Link / watchers / host bridges, etc.).\n          yield* Effect.forEach(\n            config.processes,\n            (process) =>\n              Effect.gen(function* () {\n                const installation = yield* Effect.provide(\n                  processRuntime.install(process as any, {\n                    scope: { type: 'app', appId },\n                    enabled: true,\n                    installedAt: 'appRuntime',\n                  }),\n                  mergedEnv,\n                )\n\n                // Legacy fallback: a raw Effect is still allowed as a process host, but it has no Process static surface/diagnostics.\n                if (installation === undefined) {\n                  yield* Effect.forkScoped(\n                    Effect.provide(\n                      config.onError ? Effect.catchAllCause(process, config.onError) : process,\n                      mergedEnv,\n                    ),\n                  )\n                }\n              }),\n            { discard: true },\n          )\n\n          return mergedEnv\n        }),\n      )\n\n      const fiberRefsLayer = Layer.scopedDiscard(Effect.patchFiberRefs(patch))\n\n      return Layer.mergeAll(Layer.succeedContext(env), fiberRefsLayer)\n    }),\n  ) as Layer.Layer<R, never, never>\n\n  return {\n    definition: config,\n    layer: finalLayer,\n    makeRuntime: () => ManagedRuntime.make(finalLayer),\n  }\n}\n\n/**\n * Sugar: pair a Module with a runtime instance or layer for AppRuntime's modules config.\n */\nexport const provide = <Sh extends AnyModuleShape, R, E>(\n  module: ModuleTag<any, Sh>,\n  resource: Layer.Layer<ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>, E, R> | ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>,\n): AppModuleEntry => {\n  const layer = isLayer(resource)\n    ? resource\n    : Layer.succeed(module, resource as ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>)\n\n  return { module, layer }\n}\n\n/**\n * Sugar: attach explicit ServiceTag metadata to an app module entry for tag collision detection.\n *\n * - serviceTags should include only services implemented by this module's layer.\n * - Internal-only helper: `@logixjs/core` blocks `./internal/*` in package exports, so this is not a public API surface.\n */\nexport const provideWithTags = <Sh extends AnyModuleShape, R, E>(\n  module: ModuleTag<any, Sh>,\n  resource: Layer.Layer<ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>, E, R> | ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>,\n  serviceTags: ReadonlyArray<Context.Tag<any, any>>,\n): AppModuleEntry => {\n  const base = provide(module, resource)\n  return {\n    ...base,\n    serviceTags,\n  }\n}\n\nconst isLayer = (value: unknown): value is Layer.Layer<any, any, any> =>\n  typeof value === 'object' && value !== null && Layer.LayerTypeId in value\n", "import { Cause, Effect, Exit, Fiber, Option, Scope } from 'effect'\nimport { getGlobalHostScheduler } from '../HostScheduler.js'\nimport { HostSchedulerTag } from '../env.js'\nimport { DisposeError, DisposeTimeoutError, type ProgramIdentity } from './ProgramRunner.errors.js'\n\nexport const closeProgramScope = (params: {\n  readonly scope: Scope.CloseableScope\n  readonly timeoutMs: number\n  readonly identity: ProgramIdentity\n  readonly onError?: (cause: Cause.Cause<unknown>) => Effect.Effect<void, never, never>\n}): Effect.Effect<void, never, never> => {\n  return Effect.gen(function* () {\n    const start = Date.now()\n    const hostSchedulerOpt = yield* Effect.serviceOption(HostSchedulerTag)\n    const hostScheduler = Option.isSome(hostSchedulerOpt) ? hostSchedulerOpt.value : getGlobalHostScheduler()\n    const yieldMicrotask = Effect.async<void, never>((resume) => {\n      hostScheduler.scheduleMicrotask(() => resume(Effect.void))\n    })\n\n    const fiber = yield* Effect.forkDaemon(Scope.close(params.scope, Exit.void))\n\n    while (true) {\n      const exitOpt = yield* Fiber.poll(fiber)\n      if (Option.isSome(exitOpt)) {\n        const exit = exitOpt.value\n        if (exit._tag === 'Success') {\n          return\n        }\n        return yield* Effect.die(new DisposeError(params.identity, exit.cause))\n      }\n\n      const elapsedMs = Date.now() - start\n      if (elapsedMs >= params.timeoutMs) {\n        const error = new DisposeTimeoutError(params.identity, {\n          timeoutMs: params.timeoutMs,\n          elapsedMs,\n        })\n\n        if (typeof params.onError === 'function') {\n          yield* params.onError(Cause.die(error)).pipe(Effect.catchAllCause(() => Effect.void))\n        }\n\n        yield* Fiber.interruptFork(fiber)\n        return yield* Effect.die(error)\n      }\n\n      // NOTE: Use a microtask yield (not TestClock-based) to avoid being blocked by TestClock,\n      // while keeping the \"successful close\" fast path cheap (perf-critical for tight loops).\n      yield* yieldMicrotask\n    }\n  })\n}\n", "import { Effect, Exit, Scope } from 'effect'\n\nconst getProcess = (): any => (globalThis as any).process\n\nconst isNodeProcess = (\n  value: unknown,\n): value is {\n  on: (event: string, handler: () => void) => void\n  off?: (event: string, handler: () => void) => void\n  removeListener?: (event: string, handler: () => void) => void\n} => typeof value === 'object' && value !== null && typeof (value as any).on === 'function'\n\nconst removeListener = (proc: any, event: string, handler: () => void): void => {\n  if (typeof proc.off === 'function') {\n    proc.off(event, handler)\n    return\n  }\n  if (typeof proc.removeListener === 'function') {\n    proc.removeListener(event, handler)\n  }\n}\n\nexport const installGracefulShutdownHandlers = (params: {\n  readonly scope: Scope.CloseableScope\n  readonly enabled: boolean\n}): Effect.Effect<void> => {\n  if (!params.enabled) {\n    return Effect.void\n  }\n\n  const proc = getProcess()\n  if (!isNodeProcess(proc)) {\n    return Effect.void\n  }\n\n  const handler = (): void => {\n    void Effect.runPromise(Scope.close(params.scope, Exit.void))\n  }\n\n  return Effect.gen(function* () {\n    yield* Scope.addFinalizer(\n      params.scope,\n      Effect.sync(() => {\n        removeListener(proc, 'SIGINT', handler)\n        removeListener(proc, 'SIGTERM', handler)\n      }),\n    )\n\n    yield* Effect.sync(() => {\n      proc.on('SIGINT', handler)\n      proc.on('SIGTERM', handler)\n    })\n  })\n}\n", "import { Effect, Scope } from 'effect'\nimport type { ManagedRuntime } from 'effect'\nimport type { AnyModuleShape, ModuleImpl } from '../module.js'\nimport { make as makeBoundApi } from '../BoundApiRuntime.js'\nimport { closeProgramScope } from './ProgramRunner.closeScope.js'\nimport type { ProgramIdentity } from './ProgramRunner.errors.js'\nimport { installGracefulShutdownHandlers } from './ProgramRunner.signals.js'\nimport type { ProgramRunContext } from './ProgramRunner.context.js'\n\nexport type RuntimeFactory = (\n  rootImpl: ModuleImpl<any, AnyModuleShape, any>,\n  options?: unknown,\n) => ManagedRuntime.ManagedRuntime<any, never>\n\nexport interface ProgramRunnerKernel<Sh extends AnyModuleShape> {\n  readonly scope: Scope.CloseableScope\n  readonly runtime: ManagedRuntime.ManagedRuntime<any, never>\n  readonly identity: ProgramIdentity\n  readonly installSignals: (enabled: boolean) => Effect.Effect<void>\n  readonly close: (params: {\n    readonly timeoutMs: number\n    readonly onError?: (cause: import('effect').Cause.Cause<unknown>) => Effect.Effect<void, never, never>\n  }) => Effect.Effect<void, never, never>\n  readonly setInstanceId: (value: unknown) => void\n  readonly toContext: (moduleRuntime: unknown) => ProgramRunContext<Sh>\n}\n\nexport const makeProgramRunnerKernel = <Sh extends AnyModuleShape>(\n  makeRuntime: RuntimeFactory,\n  rootImpl: ModuleImpl<any, Sh, any>,\n  options?: unknown,\n): Effect.Effect<ProgramRunnerKernel<Sh>> =>\n  Effect.gen(function* () {\n    const identity: ProgramIdentity = {\n      moduleId: String(rootImpl.module.id),\n      instanceId: 'unknown',\n    }\n\n    const scope = yield* Scope.make()\n    const runtime = makeRuntime(rootImpl as unknown as ModuleImpl<any, AnyModuleShape, any>, options)\n\n    yield* Scope.addFinalizer(scope, Effect.promise(() => runtime.dispose()).pipe(Effect.asVoid))\n\n    const setInstanceId = (value: unknown) => {\n      identity.instanceId = typeof value === 'string' && value.length > 0 ? value : String(value ?? 'unknown')\n    }\n\n    const close = (params: {\n      readonly timeoutMs: number\n      readonly onError?: (cause: import('effect').Cause.Cause<unknown>) => Effect.Effect<void, never, never>\n    }) =>\n      closeProgramScope({\n        scope,\n        timeoutMs: params.timeoutMs,\n        identity,\n        onError: params.onError,\n      })\n\n    const installSignals = (enabled: boolean) => installGracefulShutdownHandlers({ scope, enabled })\n\n    const toContext = (moduleRuntime: unknown) =>\n      ({\n        scope,\n        runtime,\n        module: moduleRuntime as any,\n        $: makeBoundApi(rootImpl.module.shape as any, moduleRuntime as any) as any,\n      }) satisfies ProgramRunContext<Sh>\n\n    return {\n      scope,\n      runtime,\n      identity,\n      installSignals,\n      close,\n      setInstanceId,\n      toContext,\n    }\n  })\n"],
  "mappings": "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",
  "names": ["layer", "Effect", "Effect", "Effect", "Exit", "Scope", "Effect", "Scope", "Effect", "Scope"]
}


package/public/sandbox/chunks/chunk-BVE33AN6.js

@@ -0,0 +1,42 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  exportStaticIr
+} from "./chunk-QGIM3FQK.js";
+import {
+  isDevEnv
+} from "./chunk-GP37MEGJ.js";
+
+// ../logix-core/src/internal/debug/ModuleTraitsRegistry.ts
+var programsByIdAndDigest = /* @__PURE__ */ new Map();
+var latestDigestById = /* @__PURE__ */ new Map();
+var MAX_VERSIONS_PER_MODULE = 8;
+var registerModuleProgram = (moduleId, program) => {
+  if (!isDevEnv()) {
+    return;
+  }
+  const ir = exportStaticIr({ program, moduleId, version: "009" });
+  const digest = ir.digest;
+  let versions = programsByIdAndDigest.get(moduleId);
+  if (!versions) {
+    versions = /* @__PURE__ */ new Map();
+    programsByIdAndDigest.set(moduleId, versions);
+  }
+  versions.set(digest, program);
+  latestDigestById.set(moduleId, digest);
+  if (versions.size > MAX_VERSIONS_PER_MODULE) {
+    const oldest = versions.keys().next().value;
+    if (oldest) versions.delete(oldest);
+  }
+};
+var getModuleProgramById = (moduleId) => {
+  const latestDigest = latestDigestById.get(moduleId);
+  if (!latestDigest) return void 0;
+  return programsByIdAndDigest.get(moduleId)?.get(latestDigest);
+};
+
+export {
+  registerModuleProgram,
+  getModuleProgramById
+};
+//# sourceMappingURL=data:application/json;base64,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

package/public/sandbox/chunks/chunk-BWTGJZVP.js

@@ -0,0 +1,19 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+import {
+  compile,
+  isReadQuery,
+  make
+} from "./chunk-LWI7BXFN.js";
+
+// ../logix-core/src/ReadQuery.ts
+var isReadQuery2 = isReadQuery;
+var make2 = make;
+var compile2 = compile;
+
+export {
+  isReadQuery2 as isReadQuery,
+  make2 as make,
+  compile2 as compile
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vbG9naXgtY29yZS9zcmMvUmVhZFF1ZXJ5LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJpbXBvcnQgKiBhcyBSZWFkUXVlcnlDb3JlIGZyb20gJy4vaW50ZXJuYWwvcnVudGltZS9jb3JlL1JlYWRRdWVyeS5qcydcblxuZXhwb3J0IHR5cGUgUmVhZExhbmUgPSBSZWFkUXVlcnlDb3JlLlJlYWRMYW5lXG5leHBvcnQgdHlwZSBSZWFkUHJvZHVjZXIgPSBSZWFkUXVlcnlDb3JlLlJlYWRQcm9kdWNlclxuZXhwb3J0IHR5cGUgRXF1YWxzS2luZCA9IFJlYWRRdWVyeUNvcmUuRXF1YWxzS2luZFxuZXhwb3J0IHR5cGUgUmVhZHNEaWdlc3QgPSBSZWFkUXVlcnlDb3JlLlJlYWRzRGlnZXN0XG5cbmV4cG9ydCB0eXBlIFJlYWRRdWVyeVN0YXRpY0lyID0gUmVhZFF1ZXJ5Q29yZS5SZWFkUXVlcnlTdGF0aWNJclxuXG5leHBvcnQgdHlwZSBSZWFkUXVlcnk8UywgVj4gPSBSZWFkUXVlcnlDb3JlLlJlYWRRdWVyeTxTLCBWPlxuZXhwb3J0IHR5cGUgUmVhZFF1ZXJ5Q29tcGlsZWQ8UywgVj4gPSBSZWFkUXVlcnlDb3JlLlJlYWRRdWVyeUNvbXBpbGVkPFMsIFY+XG5leHBvcnQgdHlwZSBSZWFkUXVlcnlJbnB1dDxTLCBWPiA9IFJlYWRRdWVyeUNvcmUuUmVhZFF1ZXJ5SW5wdXQ8UywgVj5cblxuZXhwb3J0IGNvbnN0IGlzUmVhZFF1ZXJ5ID0gUmVhZFF1ZXJ5Q29yZS5pc1JlYWRRdWVyeVxuXG5leHBvcnQgY29uc3QgbWFrZSA9IFJlYWRRdWVyeUNvcmUubWFrZVxuXG5leHBvcnQgY29uc3QgY29tcGlsZSA9IFJlYWRRdWVyeUNvcmUuY29tcGlsZVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7O0FBYU8sSUFBTUEsZUFBNEI7QUFFbEMsSUFBTUMsUUFBcUI7QUFFM0IsSUFBTUMsV0FBd0I7IiwKICAibmFtZXMiOiBbImlzUmVhZFF1ZXJ5IiwgIm1ha2UiLCAiY29tcGlsZSJdCn0K