@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,69 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  record
+} from "./chunk-OQ4SYV5D.js";
+
+// ../logix-core/src/Middleware.ts
+import { Effect } from "../effect.js";
+var makeDebugLogger = (config) => (op) => Effect.gen(function* () {
+  if (op.meta?.policy?.disableObservers) {
+    return yield* op.effect;
+  }
+  if (config?.logger) {
+    config.logger(op);
+  } else {
+    yield* Effect.logDebug(
+      `[EffectOp] kind=${op.kind} name=${op.name}`
+    );
+  }
+  return yield* op.effect;
+});
+var applyDebug = (stack, config) => [...stack, makeDebugLogger(config)];
+var makeDebugObserver = (config) => (op) => Effect.gen(function* () {
+  if (op.meta?.policy?.disableObservers) {
+    return yield* op.effect;
+  }
+  if (!config?.filter || config.filter(op)) {
+    const meta = op.meta ?? {};
+    const slimOp = {
+      id: op.id,
+      kind: op.kind,
+      name: op.name,
+      payload: op.payload,
+      meta: op.meta
+    };
+    yield* record({
+      type: "trace:effectop",
+      moduleId: typeof meta.moduleId === "string" ? meta.moduleId : void 0,
+      instanceId: typeof meta.instanceId === "string" ? meta.instanceId : void 0,
+      runtimeLabel: typeof meta.runtimeLabel === "string" ? meta.runtimeLabel : void 0,
+      txnSeq: typeof meta.txnSeq === "number" && Number.isFinite(meta.txnSeq) ? Math.floor(meta.txnSeq) : void 0,
+      data: slimOp
+    });
+  }
+  return yield* op.effect;
+});
+var applyDebugObserver = (stack, config) => [...stack, makeDebugObserver(config)];
+var withDebug = (stack, options) => {
+  let next = stack;
+  if (options?.logger !== false) {
+    const loggerConfig = typeof options?.logger === "function" ? { logger: options.logger } : void 0;
+    next = applyDebug(next, loggerConfig);
+  }
+  if (options?.observer !== false) {
+    const observerOption = options?.observer;
+    const observerConfig = observerOption === void 0 ? void 0 : observerOption;
+    next = applyDebugObserver(next, observerConfig);
+  }
+  return next;
+};
+
+export {
+  makeDebugLogger,
+  applyDebug,
+  makeDebugObserver,
+  applyDebugObserver,
+  withDebug
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/Middleware.ts"],
  "sourcesContent": ["// Middleware \u547D\u540D\u7A7A\u95F4\u5165\u53E3\uFF08@logix/core/Middleware\uFF09\u3002\n// - \u63D0\u4F9B\u57FA\u4E8E EffectOp \u7684\u8C03\u8BD5/\u89C2\u6D4B\u4E2D\u95F4\u4EF6\u7B49\u8F85\u52A9\u5DE5\u5177\uFF1B\n// - Query / DebugObserver \u7B49\u80FD\u529B\u5728\u672C\u547D\u540D\u7A7A\u95F4\u4E0B\u6269\u5C55\u3002\n\nimport { Effect } from \"effect\"\nimport * as EffectOp from \"./EffectOp.js\"\nimport * as Debug from \"./Debug.js\"\n\nexport type Middleware = EffectOp.Middleware\nexport type MiddlewareStack = EffectOp.MiddlewareStack\n\nexport interface DebugLoggerConfig {\n  /**\n   * \u53EF\u9009\uFF1A\u81EA\u5B9A\u4E49\u65E5\u5FD7\u51FD\u6570\uFF0C\u65B9\u4FBF\u5728\u6D4B\u8BD5\u4E2D\u6355\u83B7\u8C03\u7528\u3002\n   * - \u82E5\u672A\u63D0\u4F9B\uFF0C\u5219\u9ED8\u8BA4\u4F7F\u7528 Effect.logDebug \u8F93\u51FA\u3002\n   */\n  readonly logger?: (op: EffectOp.EffectOp<any, any, any>) => void\n}\n\n/**\n * \u521B\u5EFA\u4E00\u4E2A\u7B80\u5355\u7684 Debug \u65E5\u5FD7\u4E2D\u95F4\u4EF6\uFF1A\n * - \u5728\u6267\u884C Effect \u4E4B\u524D\u8BB0\u5F55\u4E00\u6761\u65E5\u5FD7\uFF1B\n * - \u4E0D\u6539\u53D8\u7ED3\u679C\u4E0E\u9519\u8BEF\u8BED\u4E49\u3002\n */\nexport const makeDebugLogger = (\n  config?: DebugLoggerConfig,\n): Middleware =>\n  <A, E, R>(op: EffectOp.EffectOp<A, E, R>): Effect.Effect<A, E, R> =>\n    Effect.gen(function* () {\n      // \u7EAF\u89C2\u6D4B\u7C7B\u80FD\u529B\uFF1A\u5141\u8BB8\u88AB\u5C40\u90E8\u7B56\u7565\u5173\u95ED\u3002\n      if (op.meta?.policy?.disableObservers) {\n        return yield* op.effect\n      }\n      if (config?.logger) {\n        config.logger(op)\n      } else {\n        yield* Effect.logDebug(\n          `[EffectOp] kind=${op.kind} name=${op.name}`,\n        )\n      }\n      return yield* op.effect\n    })\n\n/**\n * applyDebug\uFF1A\n * - \u5728\u73B0\u6709 MiddlewareStack \u672B\u5C3E\u8FFD\u52A0\u4E00\u4E2A DebugLogger \u4E2D\u95F4\u4EF6\uFF1B\n * - \u8FD4\u56DE\u65B0\u7684 stack\uFF0C\u4E0D\u4FEE\u6539\u539F\u6570\u7EC4\u3002\n */\nexport const applyDebug = (\n  stack: MiddlewareStack,\n  config?: DebugLoggerConfig,\n): MiddlewareStack => [...stack, makeDebugLogger(config)]\n\n/**\n * DebugObserverConfig\uFF1A\n * - \u9884\u7559\u8FC7\u6EE4\u5165\u53E3\uFF1A\u53EF\u6309\u6A21\u5757 / kind / name \u7B49\u7EF4\u5EA6\u7B5B\u9009\u9700\u8981\u89C2\u6D4B\u7684 EffectOp\u3002\n */\nexport interface DebugObserverConfig {\n  readonly filter?: (\n    op: EffectOp.EffectOp<any, any, any>,\n  ) => boolean\n}\n\n/**\n * makeDebugObserver\uFF1A\n * - \u5C06 EffectOp \u6D41\u7EDF\u4E00\u6536\u53E3\u5230 DebugSink\uFF08EffectOp \u2192 Debug.Event\uFF09\uFF1B\n * - \u5F53\u524D\u901A\u8FC7 trace:* \u4E8B\u4EF6\u5C06 EffectOp \u7684 Slim \u89C6\u56FE\u900F\u4F20\u5230 Debug \u6D41\uFF08\u7981\u6B62\u643A\u5E26 effect \u95ED\u5305\uFF09\uFF1A\n *   - type: \"trace:effectop\"\n *   - moduleId: \u6765\u81EA op.meta?.moduleId\uFF08\u82E5\u5B58\u5728\uFF09\n *   - data: { id, kind, name, payload, meta }\n *\n * \u8BF4\u660E\uFF1A\n * - \u4E0D\u6539\u53D8\u539F\u6709 Effect \u884C\u4E3A\uFF0C\u4EC5\u8FFD\u52A0 Debug \u4FA7\u89C2\u6D4B\uFF1B\n * - \u5177\u4F53\u7684 Devtools / Timeline \u89C6\u56FE\u53EF\u4EE5\u57FA\u4E8E trace:effectop \u4E8B\u4EF6\u91CD\u5EFA EffectOp \u65F6\u95F4\u7EBF\u3002\n */\nexport const makeDebugObserver = (\n  config?: DebugObserverConfig,\n): Middleware =>\n  <A, E, R>(op: EffectOp.EffectOp<A, E, R>): Effect.Effect<A, E, R> =>\n    Effect.gen(function* () {\n      // \u7EAF\u89C2\u6D4B\u7C7B\u80FD\u529B\uFF1A\u5141\u8BB8\u88AB\u5C40\u90E8\u7B56\u7565\u5173\u95ED\u3002\n      if (op.meta?.policy?.disableObservers) {\n        return yield* op.effect\n      }\n      if (!config?.filter || config.filter(op)) {\n        const meta: any = op.meta ?? {}\n        const slimOp = {\n          id: op.id,\n          kind: op.kind,\n          name: op.name,\n          payload: op.payload,\n          meta: op.meta,\n        }\n        yield* Debug.record({\n          type: \"trace:effectop\",\n          moduleId: typeof meta.moduleId === \"string\" ? meta.moduleId : undefined,\n          instanceId: typeof meta.instanceId === \"string\" ? meta.instanceId : undefined,\n          runtimeLabel: typeof meta.runtimeLabel === \"string\" ? meta.runtimeLabel : undefined,\n          txnSeq:\n            typeof meta.txnSeq === \"number\" && Number.isFinite(meta.txnSeq)\n              ? Math.floor(meta.txnSeq)\n              : undefined,\n          data: slimOp,\n        })\n      }\n      return yield* op.effect\n    })\n\n/**\n * applyDebugObserver\uFF1A\n * - \u5728\u73B0\u6709 MiddlewareStack \u672B\u5C3E\u8FFD\u52A0 DebugObserver \u4E2D\u95F4\u4EF6\uFF1B\n * - \u8FD4\u56DE\u65B0\u7684 stack\uFF0C\u4E0D\u4FEE\u6539\u539F\u6570\u7EC4\u3002\n */\nexport const applyDebugObserver = (\n  stack: MiddlewareStack,\n  config?: DebugObserverConfig,\n): MiddlewareStack => [...stack, makeDebugObserver(config)]\n\n/**\n * WithDebugOptions\uFF1A\n * - \u9AD8\u5C42\u7EC4\u5408\u5165\u53E3\u7684\u914D\u7F6E\u9879\uFF0C\u7528\u4E8E\u5728\u73B0\u6709 MiddlewareStack \u4E0A\u8FFD\u52A0 Debug \u80FD\u529B\u3002\n *\n * \u7EA6\u5B9A\uFF1A\n * - logger:\n *   - \u672A\u8BBE\u7F6E\uFF08undefined\uFF09\uFF1A\u542F\u7528\u9ED8\u8BA4 DebugLogger\uFF08Effect.logDebug\uFF09\uFF1B\n *   - \u63D0\u4F9B\u51FD\u6570\uFF1A\u4F7F\u7528\u81EA\u5B9A\u4E49 logger(op) \u66FF\u4EE3\u9ED8\u8BA4\u884C\u4E3A\uFF1B\n *   - \u663E\u5F0F false\uFF1A\u4E0D\u8FFD\u52A0 DebugLogger \u4E2D\u95F4\u4EF6\u3002\n * - observer:\n *   - \u672A\u8BBE\u7F6E\uFF08undefined\uFF09\uFF1A\u542F\u7528 DebugObserver\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u914D\u7F6E\uFF1B\n *   - \u63D0\u4F9B DebugObserverConfig\uFF1A\u6309\u914D\u7F6E\u542F\u7528 DebugObserver\uFF1B\n *   - \u663E\u5F0F false\uFF1A\u4E0D\u8FFD\u52A0 DebugObserver \u4E2D\u95F4\u4EF6\u3002\n */\nexport interface WithDebugOptions {\n  readonly logger?: DebugLoggerConfig[\"logger\"] | false\n  readonly observer?: DebugObserverConfig | false\n}\n\n/**\n * withDebug\uFF1A\n * - \u5728\u73B0\u6709 MiddlewareStack \u4E0A\u8FFD\u52A0 DebugLogger + DebugObserver \u9884\u8BBE\uFF1B\n * - \u652F\u6301\u901A\u8FC7 options \u63A7\u5236 logger / observer \u662F\u5426\u542F\u7528\u53CA\u5176\u914D\u7F6E\uFF1B\n * - \u8FD4\u56DE\u65B0\u7684 stack\uFF0C\u4E0D\u4FEE\u6539\u539F\u6570\u7EC4\u3002\n *\n * \u5178\u578B\u7528\u6CD5\uFF1A\n *\n *   let stack: MiddlewareStack = [metrics, timing]\n *   stack = Middleware.withDebug(stack, {\n *     logger: (op) => console.log(op.kind, op.name),\n *     observer: { filter: (op) => op.kind !== \"service\" },\n *   })\n */\nexport const withDebug = (\n  stack: MiddlewareStack,\n  options?: WithDebugOptions,\n): MiddlewareStack => {\n  let next = stack\n\n  // DebugLogger\uFF1A\u9ED8\u8BA4\u5F00\u542F\uFF0C\u9664\u975E\u663E\u5F0F logger === false\u3002\n  if (options?.logger !== false) {\n    const loggerConfig: DebugLoggerConfig | undefined =\n      typeof options?.logger === \"function\"\n        ? { logger: options.logger }\n        : undefined\n    next = applyDebug(next, loggerConfig)\n  }\n\n  // DebugObserver\uFF1A\u9ED8\u8BA4\u5F00\u542F\uFF0C\u9664\u975E\u663E\u5F0F observer === false\u3002\n  if (options?.observer !== false) {\n    // \u8FD9\u91CC\u5DF2\u7ECF\u901A\u8FC7\u6761\u4EF6\u6392\u9664\u4E86 observer === false\uFF0C\u53EA\u9700\u8981\u5728\u6709\u914D\u7F6E\u5BF9\u8C61\u65F6\u900F\u4F20\uFF1B\n    // undefined \u8868\u793A\u4F7F\u7528 DebugObserver \u9ED8\u8BA4\u884C\u4E3A\u3002\n    const observerOption = options?.observer\n    const observerConfig: DebugObserverConfig | undefined =\n      observerOption === undefined ? undefined : observerOption\n    next = applyDebugObserver(next, observerConfig)\n  }\n\n  return next\n}\n"],
  "mappings": ";;;;;;;AAIA,SAAS,cAAc;AAoBhB,IAAM,kBAAkB,CAC7B,WAEA,CAAU,OACR,OAAO,IAAI,aAAa;AAEtB,MAAI,GAAG,MAAM,QAAQ,kBAAkB;AACrC,WAAO,OAAO,GAAG;AAAA,EACnB;AACA,MAAI,QAAQ,QAAQ;AAClB,WAAO,OAAO,EAAE;AAAA,EAClB,OAAO;AACL,WAAO,OAAO;AAAA,MACZ,mBAAmB,GAAG,IAAI,SAAS,GAAG,IAAI;AAAA,IAC5C;AAAA,EACF;AACA,SAAO,OAAO,GAAG;AACnB,CAAC;AAOE,IAAM,aAAa,CACxB,OACA,WACoB,CAAC,GAAG,OAAO,gBAAgB,MAAM,CAAC;AAwBjD,IAAM,oBAAoB,CAC/B,WAEA,CAAU,OACR,OAAO,IAAI,aAAa;AAEtB,MAAI,GAAG,MAAM,QAAQ,kBAAkB;AACrC,WAAO,OAAO,GAAG;AAAA,EACnB;AACA,MAAI,CAAC,QAAQ,UAAU,OAAO,OAAO,EAAE,GAAG;AACxC,UAAM,OAAY,GAAG,QAAQ,CAAC;AAC9B,UAAM,SAAS;AAAA,MACb,IAAI,GAAG;AAAA,MACP,MAAM,GAAG;AAAA,MACT,MAAM,GAAG;AAAA,MACT,SAAS,GAAG;AAAA,MACZ,MAAM,GAAG;AAAA,IACX;AACA,WAAa,OAAO;AAAA,MAClB,MAAM;AAAA,MACN,UAAU,OAAO,KAAK,aAAa,WAAW,KAAK,WAAW;AAAA,MAC9D,YAAY,OAAO,KAAK,eAAe,WAAW,KAAK,aAAa;AAAA,MACpE,cAAc,OAAO,KAAK,iBAAiB,WAAW,KAAK,eAAe;AAAA,MAC1E,QACE,OAAO,KAAK,WAAW,YAAY,OAAO,SAAS,KAAK,MAAM,IAC1D,KAAK,MAAM,KAAK,MAAM,IACtB;AAAA,MACN,MAAM;AAAA,IACR,CAAC;AAAA,EACH;AACA,SAAO,OAAO,GAAG;AACnB,CAAC;AAOE,IAAM,qBAAqB,CAChC,OACA,WACoB,CAAC,GAAG,OAAO,kBAAkB,MAAM,CAAC;AAmCnD,IAAM,YAAY,CACvB,OACA,YACoB;AACpB,MAAI,OAAO;AAGX,MAAI,SAAS,WAAW,OAAO;AAC7B,UAAM,eACJ,OAAO,SAAS,WAAW,aACvB,EAAE,QAAQ,QAAQ,OAAO,IACzB;AACN,WAAO,WAAW,MAAM,YAAY;AAAA,EACtC;AAGA,MAAI,SAAS,aAAa,OAAO;AAG/B,UAAM,iBAAiB,SAAS;AAChC,UAAM,iBACJ,mBAAmB,SAAY,SAAY;AAC7C,WAAO,mBAAmB,MAAM,cAAc;AAAA,EAChD;AAEA,SAAO;AACT;",
  "names": []
}


package/public/sandbox/chunks/{chunk-5SOP6EKV.js → chunk-SZI65PSP.js}

@@ -1,13 +1,13 @@
-// @logixjs/core subpath bundles for @logixjs/sandbox
+// @logix/core subpath bundles for @logix/sandbox
 
 import {
   Link
-} from "./chunk-YF6IO732.js";
+} from "./chunk-UQKQ6V3V.js";
 import {
   attachMeta,
   getDefinition,
   getMeta
-} from "./chunk-4LRLOTMA.js";
+} from "./chunk-DEPSGFSY.js";
 
 // ../logix-core/src/Process.ts
 var DEFAULT_TRIGGERS = [{ kind: "platformEvent", platformEvent: "runtime:boot" }];
@@ -40,12 +40,7 @@ var getDefinition2 = (effect) => getDefinition(effect);
 var getMeta2 = (effect) => getMeta(effect);
 var attachMeta2 = (effect, meta) => attachMeta(effect, meta);
 var isModuleLike = (value) => Boolean(value) && typeof value === "object" && (value._kind === "ModuleDef" || value._kind === "Module") && "tag" in value;
-var unwrapModuleTag = (module) => {
-  if (isModuleLike(module)) {
-    return module.tag;
-  }
-  return module;
-};
+var unwrapModuleTag = (module) => isModuleLike(module) ? module.tag : module;
 function link(config, logic) {
   const linkId = config.id ?? [...config.modules].map((m) => m.id).sort().join("~");
   const modulesRecord = /* @__PURE__ */ Object.create(null);
@@ -80,4 +75,4 @@ export {
   attachMeta2 as attachMeta,
   link
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/Process.ts"],
  "sourcesContent": ["import { Effect } from 'effect'\nimport * as ModuleFactory from './internal/runtime/ModuleFactory.js'\nimport type * as Protocol from './internal/runtime/core/process/protocol.js'\nimport * as Meta from './internal/runtime/core/process/meta.js'\nimport type { AnyModuleShape, ModuleHandle, ModuleLike, ModuleTag } from './internal/module.js'\n\nexport type DiagnosticsLevel = Protocol.DiagnosticsLevel\nexport type ProcessScope = Protocol.ProcessScope\nexport type ProcessIdentity = Protocol.ProcessIdentity\nexport type ProcessInstanceIdentity = Protocol.ProcessInstanceIdentity\nexport type ProcessTriggerSpec = Protocol.ProcessTriggerSpec\nexport type ProcessTrigger = Protocol.ProcessTrigger\nexport type ProcessConcurrencyPolicy = Protocol.ProcessConcurrencyPolicy\nexport type ProcessErrorPolicy = Protocol.ProcessErrorPolicy\nexport type ProcessDefinition = Protocol.ProcessDefinition\nexport type ProcessInstallation = Protocol.ProcessInstallation\nexport type SerializableErrorSummary = Protocol.SerializableErrorSummary\nexport type ProcessInstanceStatus = Protocol.ProcessInstanceStatus\nexport type ProcessEvent = Protocol.ProcessEvent\nexport type ProcessControlRequest = Protocol.ProcessControlRequest\nexport type ProcessPlatformEvent = Protocol.ProcessPlatformEvent\n\nexport type ProcessEffect<E = never, R = never> = Meta.ProcessEffect<E, R>\n\nexport type ProcessMakeDefinition =\n  | string\n  | {\n      readonly processId: string\n      readonly name?: string\n      readonly description?: string\n      readonly requires?: ReadonlyArray<string>\n      readonly triggers?: ReadonlyArray<ProcessTriggerSpec>\n      readonly concurrency?: ProcessConcurrencyPolicy\n      readonly errorPolicy?: ProcessErrorPolicy\n      readonly diagnosticsLevel?: DiagnosticsLevel\n    }\n\nconst DEFAULT_TRIGGERS: ReadonlyArray<ProcessTriggerSpec> = [{ kind: 'platformEvent', platformEvent: 'runtime:boot' }]\n\nconst normalizeDefinition = (input: ProcessMakeDefinition): ProcessDefinition => {\n  const base = typeof input === 'string' ? ({ processId: input } satisfies { readonly processId: string }) : input\n\n  const processId = base.processId\n  if (typeof processId !== 'string' || processId.length === 0) {\n    throw new Error('[Process.make] processId must be a non-empty string')\n  }\n\n  const triggers = Array.isArray(base.triggers) && base.triggers.length > 0 ? base.triggers : DEFAULT_TRIGGERS\n\n  const concurrency = base.concurrency ?? ({ mode: 'latest' } satisfies ProcessConcurrencyPolicy)\n  const errorPolicy = base.errorPolicy ?? ({ mode: 'failStop' } satisfies ProcessErrorPolicy)\n  const diagnosticsLevel = base.diagnosticsLevel ?? 'off'\n\n  return {\n    processId,\n    name: base.name,\n    description: base.description,\n    requires: base.requires,\n    triggers,\n    concurrency,\n    errorPolicy,\n    diagnosticsLevel,\n  }\n}\n\nexport const make = <E, R>(definition: ProcessMakeDefinition, effect: Effect.Effect<void, E, R>): ProcessEffect<E, R> =>\n  Meta.attachMeta(effect, {\n    definition: normalizeDefinition(definition),\n    kind: 'process',\n  })\n\nexport const getDefinition = (effect: Effect.Effect<void, any, any>): ProcessDefinition | undefined =>\n  Meta.getDefinition(effect)\n\nexport const getMeta = (effect: Effect.Effect<void, any, any>): Meta.ProcessMeta | undefined => Meta.getMeta(effect)\n\nexport const attachMeta = <E, R>(effect: Effect.Effect<void, E, R>, meta: Meta.ProcessMeta): ProcessEffect<E, R> =>\n  Meta.attachMeta(effect, meta)\n\ntype LinkModuleToken<Id extends string, Sh extends AnyModuleShape> = ModuleTag<Id, Sh> | ModuleLike<Id, Sh, object>\n\ntype LinkModuleIdOf<M> = M extends { readonly id: infer Id } ? Id : never\ntype LinkModuleShapeOf<M> =\n  M extends ModuleLike<string, infer Sh, object> ? Sh : M extends ModuleTag<string, infer Sh> ? Sh : never\ntype LinkModuleTagOf<M> =\n  M extends ModuleLike<string, infer Sh, object>\n    ? ModuleTag<string, Sh>\n    : M extends ModuleTag<string, AnyModuleShape>\n      ? M\n      : never\n\nconst isModuleLike = (value: unknown): value is ModuleLike<string, AnyModuleShape, object> =>\n  Boolean(value) &&\n  typeof value === 'object' &&\n  ((value as { readonly _kind?: unknown })._kind === 'ModuleDef' ||\n    (value as { readonly _kind?: unknown })._kind === 'Module') &&\n  'tag' in (value as object)\n\nconst unwrapModuleTag = <Id extends string, Sh extends AnyModuleShape>(\n  module: LinkModuleToken<Id, Sh>,\n): ModuleTag<Id, Sh> => {\n  if (isModuleLike(module)) {\n    return module.tag\n  }\n  return module as ModuleTag<Id, Sh>\n}\n\nexport interface LinkConfig<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[]> {\n  readonly id?: string\n  readonly modules: Ms\n}\n\nexport type LinkHandles<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[]> = {\n  [M in Ms[number] as LinkModuleIdOf<M>]: ModuleHandle<LinkModuleShapeOf<M>>\n}\n\ntype ModulesRecord<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[]> = {\n  [M in Ms[number] as LinkModuleIdOf<M>]: LinkModuleTagOf<M>\n}\n\nexport function link<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[], E = never, R = never>(\n  config: LinkConfig<Ms>,\n  logic: ($: LinkHandles<Ms>) => Effect.Effect<void, E, R>,\n): ProcessEffect<E, R> {\n  const linkId =\n    config.id ??\n    [...config.modules]\n      .map((m) => m.id)\n      .sort()\n      .join('~')\n\n  const modulesRecord = Object.create(null) as ModulesRecord<Ms>\n  const requires = new Set<string>()\n\n  for (const module of config.modules) {\n    const tag = unwrapModuleTag(module)\n    requires.add(String(tag.id))\n    ;(modulesRecord as Record<string, ModuleTag<string, AnyModuleShape>>)[tag.id] = tag as unknown as ModuleTag<\n      string,\n      AnyModuleShape\n    >\n  }\n\n  const effect = ModuleFactory.Link(\n    modulesRecord as unknown as Record<string, ModuleTag<string, AnyModuleShape>>,\n    logic as unknown as ($: Record<string, ModuleHandle<AnyModuleShape>>) => Effect.Effect<void, E, R>,\n  )\n\n  const definition: ProcessDefinition = {\n    processId: linkId,\n    requires: Array.from(requires),\n    triggers: [...DEFAULT_TRIGGERS, { kind: 'platformEvent', platformEvent: `link:${linkId}` }],\n    concurrency: { mode: 'latest' },\n    errorPolicy: { mode: 'failStop' },\n    diagnosticsLevel: 'off',\n  }\n\n  return Meta.attachMeta(effect, {\n    definition,\n    kind: 'link',\n  }) as ProcessEffect<E, R>\n}\n"],
  "mappings": ";;;;;;;;;;;;AAqCA,IAAM,mBAAsD,CAAC,EAAE,MAAM,iBAAiB,eAAe,eAAe,CAAC;AAErH,IAAM,sBAAsB,CAAC,UAAoD;AAC/E,QAAM,OAAO,OAAO,UAAU,WAAY,EAAE,WAAW,MAAM,IAA8C;AAE3G,QAAM,YAAY,KAAK;AACvB,MAAI,OAAO,cAAc,YAAY,UAAU,WAAW,GAAG;AAC3D,UAAM,IAAI,MAAM,qDAAqD;AAAA,EACvE;AAEA,QAAM,WAAW,MAAM,QAAQ,KAAK,QAAQ,KAAK,KAAK,SAAS,SAAS,IAAI,KAAK,WAAW;AAE5F,QAAM,cAAc,KAAK,eAAgB,EAAE,MAAM,SAAS;AAC1D,QAAM,cAAc,KAAK,eAAgB,EAAE,MAAM,WAAW;AAC5D,QAAM,mBAAmB,KAAK,oBAAoB;AAElD,SAAO;AAAA,IACL;AAAA,IACA,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,UAAU,KAAK;AAAA,IACf;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAEO,IAAM,OAAO,CAAO,YAAmC,WACvD,WAAW,QAAQ;AAAA,EACtB,YAAY,oBAAoB,UAAU;AAAA,EAC1C,MAAM;AACR,CAAC;AAEI,IAAMA,iBAAgB,CAAC,WACvB,cAAc,MAAM;AAEpB,IAAMC,WAAU,CAAC,WAA6E,QAAQ,MAAM;AAE5G,IAAMC,cAAa,CAAO,QAAmC,SAC7D,WAAW,QAAQ,IAAI;AAc9B,IAAM,eAAe,CAAC,UACpB,QAAQ,KAAK,KACb,OAAO,UAAU,aACf,MAAuC,UAAU,eAChD,MAAuC,UAAU,aACpD,SAAU;AAEZ,IAAM,kBAAkB,CACtB,WACsB;AACtB,MAAI,aAAa,MAAM,GAAG;AACxB,WAAO,OAAO;AAAA,EAChB;AACA,SAAO;AACT;AAeO,SAAS,KACd,QACA,OACqB;AACrB,QAAM,SACJ,OAAO,MACP,CAAC,GAAG,OAAO,OAAO,EACf,IAAI,CAAC,MAAM,EAAE,EAAE,EACf,KAAK,EACL,KAAK,GAAG;AAEb,QAAM,gBAAgB,uBAAO,OAAO,IAAI;AACxC,QAAM,WAAW,oBAAI,IAAY;AAEjC,aAAW,UAAU,OAAO,SAAS;AACnC,UAAM,MAAM,gBAAgB,MAAM;AAClC,aAAS,IAAI,OAAO,IAAI,EAAE,CAAC;AAC1B,IAAC,cAAoE,IAAI,EAAE,IAAI;AAAA,EAIlF;AAEA,QAAM,SAAuB;AAAA,IAC3B;AAAA,IACA;AAAA,EACF;AAEA,QAAM,aAAgC;AAAA,IACpC,WAAW;AAAA,IACX,UAAU,MAAM,KAAK,QAAQ;AAAA,IAC7B,UAAU,CAAC,GAAG,kBAAkB,EAAE,MAAM,iBAAiB,eAAe,QAAQ,MAAM,GAAG,CAAC;AAAA,IAC1F,aAAa,EAAE,MAAM,SAAS;AAAA,IAC9B,aAAa,EAAE,MAAM,WAAW;AAAA,IAChC,kBAAkB;AAAA,EACpB;AAEA,SAAY,WAAW,QAAQ;AAAA,IAC7B;AAAA,IACA,MAAM;AAAA,EACR,CAAC;AACH;",
  "names": ["getDefinition", "getMeta", "attachMeta"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/Process.ts"],
  "sourcesContent": ["import { Effect } from 'effect'\nimport * as ModuleFactory from './internal/runtime/ModuleFactory.js'\nimport type * as Protocol from './internal/runtime/core/process/protocol.js'\nimport * as Meta from './internal/runtime/core/process/meta.js'\nimport type { AnyModuleShape, ModuleHandle, ModuleLike, ModuleTag } from './internal/module.js'\n\nexport type DiagnosticsLevel = Protocol.DiagnosticsLevel\nexport type ProcessScope = Protocol.ProcessScope\nexport type ProcessIdentity = Protocol.ProcessIdentity\nexport type ProcessInstanceIdentity = Protocol.ProcessInstanceIdentity\nexport type ProcessTriggerSpec = Protocol.ProcessTriggerSpec\nexport type ProcessTrigger = Protocol.ProcessTrigger\nexport type ProcessConcurrencyPolicy = Protocol.ProcessConcurrencyPolicy\nexport type ProcessErrorPolicy = Protocol.ProcessErrorPolicy\nexport type ProcessDefinition = Protocol.ProcessDefinition\nexport type ProcessInstallation = Protocol.ProcessInstallation\nexport type SerializableErrorSummary = Protocol.SerializableErrorSummary\nexport type ProcessInstanceStatus = Protocol.ProcessInstanceStatus\nexport type ProcessEvent = Protocol.ProcessEvent\nexport type ProcessControlRequest = Protocol.ProcessControlRequest\nexport type ProcessPlatformEvent = Protocol.ProcessPlatformEvent\n\nexport type ProcessEffect<E = never, R = never> = Meta.ProcessEffect<E, R>\n\nexport type ProcessMakeDefinition =\n  | string\n  | {\n      readonly processId: string\n      readonly name?: string\n      readonly description?: string\n      readonly requires?: ReadonlyArray<string>\n      readonly triggers?: ReadonlyArray<ProcessTriggerSpec>\n      readonly concurrency?: ProcessConcurrencyPolicy\n      readonly errorPolicy?: ProcessErrorPolicy\n      readonly diagnosticsLevel?: DiagnosticsLevel\n    }\n\nconst DEFAULT_TRIGGERS: ReadonlyArray<ProcessTriggerSpec> = [{ kind: 'platformEvent', platformEvent: 'runtime:boot' }]\n\nconst normalizeDefinition = (input: ProcessMakeDefinition): ProcessDefinition => {\n  const base = typeof input === 'string' ? ({ processId: input } satisfies { readonly processId: string }) : input\n\n  const processId = base.processId\n  if (typeof processId !== 'string' || processId.length === 0) {\n    throw new Error('[Process.make] processId must be a non-empty string')\n  }\n\n  const triggers = Array.isArray(base.triggers) && base.triggers.length > 0 ? base.triggers : DEFAULT_TRIGGERS\n\n  const concurrency = base.concurrency ?? ({ mode: 'latest' } satisfies ProcessConcurrencyPolicy)\n  const errorPolicy = base.errorPolicy ?? ({ mode: 'failStop' } satisfies ProcessErrorPolicy)\n  const diagnosticsLevel = base.diagnosticsLevel ?? 'off'\n\n  return {\n    processId,\n    name: base.name,\n    description: base.description,\n    requires: base.requires,\n    triggers,\n    concurrency,\n    errorPolicy,\n    diagnosticsLevel,\n  }\n}\n\nexport const make = <E, R>(definition: ProcessMakeDefinition, effect: Effect.Effect<void, E, R>): ProcessEffect<E, R> =>\n  Meta.attachMeta(effect, {\n    definition: normalizeDefinition(definition),\n    kind: 'process',\n  })\n\nexport const getDefinition = (effect: Effect.Effect<void, any, any>): ProcessDefinition | undefined =>\n  Meta.getDefinition(effect)\n\nexport const getMeta = (effect: Effect.Effect<void, any, any>): Meta.ProcessMeta | undefined => Meta.getMeta(effect)\n\nexport const attachMeta = <E, R>(effect: Effect.Effect<void, E, R>, meta: Meta.ProcessMeta): ProcessEffect<E, R> =>\n  Meta.attachMeta(effect, meta)\n\ntype LinkModuleToken<Id extends string, Sh extends AnyModuleShape> = ModuleTag<Id, Sh> | ModuleLike<Id, Sh, object>\n\ntype LinkModuleIdOf<M> = M extends { readonly id: infer Id } ? Id : never\ntype LinkModuleShapeOf<M> =\n  M extends ModuleLike<string, infer Sh, object> ? Sh : M extends ModuleTag<string, infer Sh> ? Sh : never\ntype LinkModuleTagOf<M> =\n  M extends ModuleLike<string, infer Sh, object>\n    ? ModuleTag<string, Sh>\n    : M extends ModuleTag<string, AnyModuleShape>\n      ? M\n      : never\n\nconst isModuleLike = (value: unknown): value is ModuleLike<string, AnyModuleShape, object> =>\n  Boolean(value) &&\n  typeof value === 'object' &&\n  ((value as { readonly _kind?: unknown })._kind === 'ModuleDef' ||\n    (value as { readonly _kind?: unknown })._kind === 'Module') &&\n  'tag' in (value as object)\n\nconst unwrapModuleTag = <Id extends string, Sh extends AnyModuleShape>(\n  module: LinkModuleToken<Id, Sh>,\n): ModuleTag<Id, Sh> => (isModuleLike(module) ? module.tag : module)\n\nexport interface LinkConfig<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[]> {\n  readonly id?: string\n  readonly modules: Ms\n}\n\nexport type LinkHandles<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[]> = {\n  [M in Ms[number] as LinkModuleIdOf<M>]: ModuleHandle<LinkModuleShapeOf<M>>\n}\n\ntype ModulesRecord<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[]> = {\n  [M in Ms[number] as LinkModuleIdOf<M>]: LinkModuleTagOf<M>\n}\n\nexport function link<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[], E = never, R = never>(\n  config: LinkConfig<Ms>,\n  logic: ($: LinkHandles<Ms>) => Effect.Effect<void, E, R>,\n): ProcessEffect<E, R> {\n  const linkId =\n    config.id ??\n    [...config.modules]\n      .map((m) => m.id)\n      .sort()\n      .join('~')\n\n  const modulesRecord = Object.create(null) as ModulesRecord<Ms>\n  const requires = new Set<string>()\n\n  for (const module of config.modules) {\n    const tag = unwrapModuleTag(module)\n    requires.add(String(tag.id))\n    ;(modulesRecord as Record<string, ModuleTag<string, AnyModuleShape>>)[tag.id] = tag as unknown as ModuleTag<\n      string,\n      AnyModuleShape\n    >\n  }\n\n  const effect = ModuleFactory.Link(\n    modulesRecord as unknown as Record<string, ModuleTag<string, AnyModuleShape>>,\n    logic as unknown as ($: Record<string, ModuleHandle<AnyModuleShape>>) => Effect.Effect<void, E, R>,\n  )\n\n  const definition: ProcessDefinition = {\n    processId: linkId,\n    requires: Array.from(requires),\n    triggers: [...DEFAULT_TRIGGERS, { kind: 'platformEvent', platformEvent: `link:${linkId}` }],\n    concurrency: { mode: 'latest' },\n    errorPolicy: { mode: 'failStop' },\n    diagnosticsLevel: 'off',\n  }\n\n  return Meta.attachMeta(effect, {\n    definition,\n    kind: 'link',\n  }) as ProcessEffect<E, R>\n}\n"],
  "mappings": ";;;;;;;;;;;;AAqCA,IAAM,mBAAsD,CAAC,EAAE,MAAM,iBAAiB,eAAe,eAAe,CAAC;AAErH,IAAM,sBAAsB,CAAC,UAAoD;AAC/E,QAAM,OAAO,OAAO,UAAU,WAAY,EAAE,WAAW,MAAM,IAA8C;AAE3G,QAAM,YAAY,KAAK;AACvB,MAAI,OAAO,cAAc,YAAY,UAAU,WAAW,GAAG;AAC3D,UAAM,IAAI,MAAM,qDAAqD;AAAA,EACvE;AAEA,QAAM,WAAW,MAAM,QAAQ,KAAK,QAAQ,KAAK,KAAK,SAAS,SAAS,IAAI,KAAK,WAAW;AAE5F,QAAM,cAAc,KAAK,eAAgB,EAAE,MAAM,SAAS;AAC1D,QAAM,cAAc,KAAK,eAAgB,EAAE,MAAM,WAAW;AAC5D,QAAM,mBAAmB,KAAK,oBAAoB;AAElD,SAAO;AAAA,IACL;AAAA,IACA,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,UAAU,KAAK;AAAA,IACf;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAEO,IAAM,OAAO,CAAO,YAAmC,WACvD,WAAW,QAAQ;AAAA,EACtB,YAAY,oBAAoB,UAAU;AAAA,EAC1C,MAAM;AACR,CAAC;AAEI,IAAMA,iBAAgB,CAAC,WACvB,cAAc,MAAM;AAEpB,IAAMC,WAAU,CAAC,WAA6E,QAAQ,MAAM;AAE5G,IAAMC,cAAa,CAAO,QAAmC,SAC7D,WAAW,QAAQ,IAAI;AAc9B,IAAM,eAAe,CAAC,UACpB,QAAQ,KAAK,KACb,OAAO,UAAU,aACf,MAAuC,UAAU,eAChD,MAAuC,UAAU,aACpD,SAAU;AAEZ,IAAM,kBAAkB,CACtB,WACuB,aAAa,MAAM,IAAI,OAAO,MAAM;AAetD,SAAS,KACd,QACA,OACqB;AACrB,QAAM,SACJ,OAAO,MACP,CAAC,GAAG,OAAO,OAAO,EACf,IAAI,CAAC,MAAM,EAAE,EAAE,EACf,KAAK,EACL,KAAK,GAAG;AAEb,QAAM,gBAAgB,uBAAO,OAAO,IAAI;AACxC,QAAM,WAAW,oBAAI,IAAY;AAEjC,aAAW,UAAU,OAAO,SAAS;AACnC,UAAM,MAAM,gBAAgB,MAAM;AAClC,aAAS,IAAI,OAAO,IAAI,EAAE,CAAC;AAC1B,IAAC,cAAoE,IAAI,EAAE,IAAI;AAAA,EAIlF;AAEA,QAAM,SAAuB;AAAA,IAC3B;AAAA,IACA;AAAA,EACF;AAEA,QAAM,aAAgC;AAAA,IACpC,WAAW;AAAA,IACX,UAAU,MAAM,KAAK,QAAQ;AAAA,IAC7B,UAAU,CAAC,GAAG,kBAAkB,EAAE,MAAM,iBAAiB,eAAe,QAAQ,MAAM,GAAG,CAAC;AAAA,IAC1F,aAAa,EAAE,MAAM,SAAS;AAAA,IAC9B,aAAa,EAAE,MAAM,WAAW;AAAA,IAChC,kBAAkB;AAAA,EACpB;AAEA,SAAY,WAAW,QAAQ;AAAA,IAC7B;AAAA,IACA,MAAM;AAAA,EACR,CAAC;AACH;",
  "names": ["getDefinition", "getMeta", "attachMeta"]
}


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

@@ -0,0 +1,78 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  Link
+} from "./chunk-UABFN3NH.js";
+import {
+  attachMeta,
+  getDefinition,
+  getMeta
+} from "./chunk-PBPT2U2N.js";
+
+// ../logix-core/src/Process.ts
+var DEFAULT_TRIGGERS = [{ kind: "platformEvent", platformEvent: "runtime:boot" }];
+var normalizeDefinition = (input) => {
+  const base = typeof input === "string" ? { processId: input } : input;
+  const processId = base.processId;
+  if (typeof processId !== "string" || processId.length === 0) {
+    throw new Error("[Process.make] processId must be a non-empty string");
+  }
+  const triggers = Array.isArray(base.triggers) && base.triggers.length > 0 ? base.triggers : DEFAULT_TRIGGERS;
+  const concurrency = base.concurrency ?? { mode: "latest" };
+  const errorPolicy = base.errorPolicy ?? { mode: "failStop" };
+  const diagnosticsLevel = base.diagnosticsLevel ?? "off";
+  return {
+    processId,
+    name: base.name,
+    description: base.description,
+    requires: base.requires,
+    triggers,
+    concurrency,
+    errorPolicy,
+    diagnosticsLevel
+  };
+};
+var make = (definition, effect) => attachMeta(effect, {
+  definition: normalizeDefinition(definition),
+  kind: "process"
+});
+var getDefinition2 = (effect) => getDefinition(effect);
+var getMeta2 = (effect) => getMeta(effect);
+var attachMeta2 = (effect, meta) => attachMeta(effect, meta);
+var isModuleLike = (value) => Boolean(value) && typeof value === "object" && (value._kind === "ModuleDef" || value._kind === "Module") && "tag" in value;
+var unwrapModuleTag = (module) => isModuleLike(module) ? module.tag : module;
+function link(config, logic) {
+  const linkId = config.id ?? [...config.modules].map((m) => m.id).sort().join("~");
+  const modulesRecord = /* @__PURE__ */ Object.create(null);
+  const requires = /* @__PURE__ */ new Set();
+  for (const module of config.modules) {
+    const tag = unwrapModuleTag(module);
+    requires.add(String(tag.id));
+    modulesRecord[tag.id] = tag;
+  }
+  const effect = Link(
+    modulesRecord,
+    logic
+  );
+  const definition = {
+    processId: linkId,
+    requires: Array.from(requires),
+    triggers: [...DEFAULT_TRIGGERS, { kind: "platformEvent", platformEvent: `link:${linkId}` }],
+    concurrency: { mode: "latest" },
+    errorPolicy: { mode: "failStop" },
+    diagnosticsLevel: "off"
+  };
+  return attachMeta(effect, {
+    definition,
+    kind: "link"
+  });
+}
+
+export {
+  make,
+  getDefinition2 as getDefinition,
+  getMeta2 as getMeta,
+  attachMeta2 as attachMeta,
+  link
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/Process.ts"],
  "sourcesContent": ["import { Effect } from 'effect'\nimport * as ModuleFactory from './internal/runtime/ModuleFactory.js'\nimport type * as Protocol from './internal/runtime/core/process/protocol.js'\nimport * as Meta from './internal/runtime/core/process/meta.js'\nimport type { AnyModuleShape, ModuleHandle, ModuleLike, ModuleTag } from './internal/module.js'\n\nexport type DiagnosticsLevel = Protocol.DiagnosticsLevel\nexport type ProcessScope = Protocol.ProcessScope\nexport type ProcessIdentity = Protocol.ProcessIdentity\nexport type ProcessInstanceIdentity = Protocol.ProcessInstanceIdentity\nexport type ProcessTriggerSpec = Protocol.ProcessTriggerSpec\nexport type ProcessTrigger = Protocol.ProcessTrigger\nexport type ProcessConcurrencyPolicy = Protocol.ProcessConcurrencyPolicy\nexport type ProcessErrorPolicy = Protocol.ProcessErrorPolicy\nexport type ProcessDefinition = Protocol.ProcessDefinition\nexport type ProcessInstallation = Protocol.ProcessInstallation\nexport type SerializableErrorSummary = Protocol.SerializableErrorSummary\nexport type ProcessInstanceStatus = Protocol.ProcessInstanceStatus\nexport type ProcessEvent = Protocol.ProcessEvent\nexport type ProcessControlRequest = Protocol.ProcessControlRequest\nexport type ProcessPlatformEvent = Protocol.ProcessPlatformEvent\n\nexport type ProcessEffect<E = never, R = never> = Meta.ProcessEffect<E, R>\n\nexport type ProcessMakeDefinition =\n  | string\n  | {\n      readonly processId: string\n      readonly name?: string\n      readonly description?: string\n      readonly requires?: ReadonlyArray<string>\n      readonly triggers?: ReadonlyArray<ProcessTriggerSpec>\n      readonly concurrency?: ProcessConcurrencyPolicy\n      readonly errorPolicy?: ProcessErrorPolicy\n      readonly diagnosticsLevel?: DiagnosticsLevel\n    }\n\nconst DEFAULT_TRIGGERS: ReadonlyArray<ProcessTriggerSpec> = [{ kind: 'platformEvent', platformEvent: 'runtime:boot' }]\n\nconst normalizeDefinition = (input: ProcessMakeDefinition): ProcessDefinition => {\n  const base = typeof input === 'string' ? ({ processId: input } satisfies { readonly processId: string }) : input\n\n  const processId = base.processId\n  if (typeof processId !== 'string' || processId.length === 0) {\n    throw new Error('[Process.make] processId must be a non-empty string')\n  }\n\n  const triggers = Array.isArray(base.triggers) && base.triggers.length > 0 ? base.triggers : DEFAULT_TRIGGERS\n\n  const concurrency = base.concurrency ?? ({ mode: 'latest' } satisfies ProcessConcurrencyPolicy)\n  const errorPolicy = base.errorPolicy ?? ({ mode: 'failStop' } satisfies ProcessErrorPolicy)\n  const diagnosticsLevel = base.diagnosticsLevel ?? 'off'\n\n  return {\n    processId,\n    name: base.name,\n    description: base.description,\n    requires: base.requires,\n    triggers,\n    concurrency,\n    errorPolicy,\n    diagnosticsLevel,\n  }\n}\n\nexport const make = <E, R>(definition: ProcessMakeDefinition, effect: Effect.Effect<void, E, R>): ProcessEffect<E, R> =>\n  Meta.attachMeta(effect, {\n    definition: normalizeDefinition(definition),\n    kind: 'process',\n  })\n\nexport const getDefinition = (effect: Effect.Effect<void, any, any>): ProcessDefinition | undefined =>\n  Meta.getDefinition(effect)\n\nexport const getMeta = (effect: Effect.Effect<void, any, any>): Meta.ProcessMeta | undefined => Meta.getMeta(effect)\n\nexport const attachMeta = <E, R>(effect: Effect.Effect<void, E, R>, meta: Meta.ProcessMeta): ProcessEffect<E, R> =>\n  Meta.attachMeta(effect, meta)\n\ntype LinkModuleToken<Id extends string, Sh extends AnyModuleShape> = ModuleTag<Id, Sh> | ModuleLike<Id, Sh, object>\n\ntype LinkModuleIdOf<M> = M extends { readonly id: infer Id } ? Id : never\ntype LinkModuleShapeOf<M> =\n  M extends ModuleLike<string, infer Sh, object> ? Sh : M extends ModuleTag<string, infer Sh> ? Sh : never\ntype LinkModuleTagOf<M> =\n  M extends ModuleLike<string, infer Sh, object>\n    ? ModuleTag<string, Sh>\n    : M extends ModuleTag<string, AnyModuleShape>\n      ? M\n      : never\n\nconst isModuleLike = (value: unknown): value is ModuleLike<string, AnyModuleShape, object> =>\n  Boolean(value) &&\n  typeof value === 'object' &&\n  ((value as { readonly _kind?: unknown })._kind === 'ModuleDef' ||\n    (value as { readonly _kind?: unknown })._kind === 'Module') &&\n  'tag' in (value as object)\n\nconst unwrapModuleTag = <Id extends string, Sh extends AnyModuleShape>(\n  module: LinkModuleToken<Id, Sh>,\n): ModuleTag<Id, Sh> => (isModuleLike(module) ? module.tag : module)\n\nexport interface LinkConfig<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[]> {\n  readonly id?: string\n  readonly modules: Ms\n}\n\nexport type LinkHandles<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[]> = {\n  [M in Ms[number] as LinkModuleIdOf<M>]: ModuleHandle<LinkModuleShapeOf<M>>\n}\n\ntype ModulesRecord<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[]> = {\n  [M in Ms[number] as LinkModuleIdOf<M>]: LinkModuleTagOf<M>\n}\n\nexport function link<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[], E = never, R = never>(\n  config: LinkConfig<Ms>,\n  logic: ($: LinkHandles<Ms>) => Effect.Effect<void, E, R>,\n): ProcessEffect<E, R> {\n  const linkId =\n    config.id ??\n    [...config.modules]\n      .map((m) => m.id)\n      .sort()\n      .join('~')\n\n  const modulesRecord = Object.create(null) as ModulesRecord<Ms>\n  const requires = new Set<string>()\n\n  for (const module of config.modules) {\n    const tag = unwrapModuleTag(module)\n    requires.add(String(tag.id))\n    ;(modulesRecord as Record<string, ModuleTag<string, AnyModuleShape>>)[tag.id] = tag as unknown as ModuleTag<\n      string,\n      AnyModuleShape\n    >\n  }\n\n  const effect = ModuleFactory.Link(\n    modulesRecord as unknown as Record<string, ModuleTag<string, AnyModuleShape>>,\n    logic as unknown as ($: Record<string, ModuleHandle<AnyModuleShape>>) => Effect.Effect<void, E, R>,\n  )\n\n  const definition: ProcessDefinition = {\n    processId: linkId,\n    requires: Array.from(requires),\n    triggers: [...DEFAULT_TRIGGERS, { kind: 'platformEvent', platformEvent: `link:${linkId}` }],\n    concurrency: { mode: 'latest' },\n    errorPolicy: { mode: 'failStop' },\n    diagnosticsLevel: 'off',\n  }\n\n  return Meta.attachMeta(effect, {\n    definition,\n    kind: 'link',\n  }) as ProcessEffect<E, R>\n}\n"],
  "mappings": ";;;;;;;;;;;;AAqCA,IAAM,mBAAsD,CAAC,EAAE,MAAM,iBAAiB,eAAe,eAAe,CAAC;AAErH,IAAM,sBAAsB,CAAC,UAAoD;AAC/E,QAAM,OAAO,OAAO,UAAU,WAAY,EAAE,WAAW,MAAM,IAA8C;AAE3G,QAAM,YAAY,KAAK;AACvB,MAAI,OAAO,cAAc,YAAY,UAAU,WAAW,GAAG;AAC3D,UAAM,IAAI,MAAM,qDAAqD;AAAA,EACvE;AAEA,QAAM,WAAW,MAAM,QAAQ,KAAK,QAAQ,KAAK,KAAK,SAAS,SAAS,IAAI,KAAK,WAAW;AAE5F,QAAM,cAAc,KAAK,eAAgB,EAAE,MAAM,SAAS;AAC1D,QAAM,cAAc,KAAK,eAAgB,EAAE,MAAM,WAAW;AAC5D,QAAM,mBAAmB,KAAK,oBAAoB;AAElD,SAAO;AAAA,IACL;AAAA,IACA,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,UAAU,KAAK;AAAA,IACf;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAEO,IAAM,OAAO,CAAO,YAAmC,WACvD,WAAW,QAAQ;AAAA,EACtB,YAAY,oBAAoB,UAAU;AAAA,EAC1C,MAAM;AACR,CAAC;AAEI,IAAMA,iBAAgB,CAAC,WACvB,cAAc,MAAM;AAEpB,IAAMC,WAAU,CAAC,WAA6E,QAAQ,MAAM;AAE5G,IAAMC,cAAa,CAAO,QAAmC,SAC7D,WAAW,QAAQ,IAAI;AAc9B,IAAM,eAAe,CAAC,UACpB,QAAQ,KAAK,KACb,OAAO,UAAU,aACf,MAAuC,UAAU,eAChD,MAAuC,UAAU,aACpD,SAAU;AAEZ,IAAM,kBAAkB,CACtB,WACuB,aAAa,MAAM,IAAI,OAAO,MAAM;AAetD,SAAS,KACd,QACA,OACqB;AACrB,QAAM,SACJ,OAAO,MACP,CAAC,GAAG,OAAO,OAAO,EACf,IAAI,CAAC,MAAM,EAAE,EAAE,EACf,KAAK,EACL,KAAK,GAAG;AAEb,QAAM,gBAAgB,uBAAO,OAAO,IAAI;AACxC,QAAM,WAAW,oBAAI,IAAY;AAEjC,aAAW,UAAU,OAAO,SAAS;AACnC,UAAM,MAAM,gBAAgB,MAAM;AAClC,aAAS,IAAI,OAAO,IAAI,EAAE,CAAC;AAC1B,IAAC,cAAoE,IAAI,EAAE,IAAI;AAAA,EAIlF;AAEA,QAAM,SAAuB;AAAA,IAC3B;AAAA,IACA;AAAA,EACF;AAEA,QAAM,aAAgC;AAAA,IACpC,WAAW;AAAA,IACX,UAAU,MAAM,KAAK,QAAQ;AAAA,IAC7B,UAAU,CAAC,GAAG,kBAAkB,EAAE,MAAM,iBAAiB,eAAe,QAAQ,MAAM,GAAG,CAAC;AAAA,IAC1F,aAAa,EAAE,MAAM,SAAS;AAAA,IAC9B,aAAa,EAAE,MAAM,WAAW;AAAA,IAChC,kBAAkB;AAAA,EACpB;AAEA,SAAY,WAAW,QAAQ;AAAA,IAC7B;AAAA,IACA,MAAM;AAAA,EACR,CAAC;AACH;",
  "names": ["getDefinition", "getMeta", "attachMeta"]
}


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

@@ -0,0 +1,57 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  CutoverCoverageMatrix,
+  evaluateFullCutoverGate
+} from "./chunk-FEGFZ5OX.js";
+import {
+  FullCutoverGateModeTag,
+  KernelImplementationRefTag,
+  RuntimeServicesRegistryTag,
+  RuntimeServicesRuntimeConfigTag,
+  defaultKernelImplementationRef,
+  getKernelImplementationRef,
+  getRuntimeServicesEvidence,
+  isKernelImplementationRef
+} from "./chunk-3VU3JLZO.js";
+
+// ../logix-core/src/Kernel.ts
+import { Layer } from "../effect.js";
+var defaultKernelImplementationRef2 = defaultKernelImplementationRef;
+var isKernelImplementationRef2 = isKernelImplementationRef;
+var CutoverCoverageMatrix2 = CutoverCoverageMatrix;
+var evaluateFullCutoverGate2 = (args) => {
+  return evaluateFullCutoverGate({
+    mode: args.mode,
+    requestedKernelId: args.requestedKernelId,
+    runtimeServicesEvidence: args.runtimeServicesEvidence,
+    coverageMatrix: args.coverageMatrix,
+    diagnosticsLevel: args.diagnosticsLevel
+  });
+};
+var KernelContractMetaAllowlist = [];
+var kernelLayer = (ref) => Layer.succeed(KernelImplementationRefTag, ref);
+var runtimeDefaultServicesOverridesLayer = (services) => Layer.succeed(RuntimeServicesRuntimeConfigTag, {
+  services
+});
+var getRuntimeServicesEvidence2 = getRuntimeServicesEvidence;
+var getKernelImplementationRef2 = getKernelImplementationRef;
+var runtimeServicesRegistryLayer = (registry) => Layer.succeed(RuntimeServicesRegistryTag, registry);
+var fullCutoverGateModeLayer = (mode) => Layer.succeed(FullCutoverGateModeTag, mode);
+var isKernelFullyActivated = (evidence) => !evidence.overridesApplied.some((s) => s.includes("fallback="));
+
+export {
+  defaultKernelImplementationRef2 as defaultKernelImplementationRef,
+  isKernelImplementationRef2 as isKernelImplementationRef,
+  CutoverCoverageMatrix2 as CutoverCoverageMatrix,
+  evaluateFullCutoverGate2 as evaluateFullCutoverGate,
+  KernelContractMetaAllowlist,
+  kernelLayer,
+  runtimeDefaultServicesOverridesLayer,
+  getRuntimeServicesEvidence2 as getRuntimeServicesEvidence,
+  getKernelImplementationRef2 as getKernelImplementationRef,
+  runtimeServicesRegistryLayer,
+  fullCutoverGateModeLayer,
+  isKernelFullyActivated
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/Kernel.ts"],
  "sourcesContent": ["import { Layer } from 'effect'\nimport type { Layer as LayerType } from 'effect'\nimport type * as Debug from './Debug.js'\nimport * as FullCutoverGate from './internal/runtime/core/FullCutoverGate.js'\nimport * as RuntimeKernel from './internal/runtime/core/RuntimeKernel.js'\nimport * as KernelRef from './internal/runtime/core/KernelRef.js'\nexport type { RuntimeServiceBuiltins } from './internal/runtime/core/RuntimeServiceBuiltins.js'\nexport { RuntimeServiceBuiltinsTag } from './internal/runtime/core/RuntimeServiceBuiltins.js'\n\nexport type KernelId = KernelRef.KernelId\n\nexport interface KernelImplementationRef extends KernelRef.KernelImplementationRef {}\n\nexport const defaultKernelImplementationRef = KernelRef.defaultKernelImplementationRef\n\nexport const isKernelImplementationRef = KernelRef.isKernelImplementationRef\n\nexport type RuntimeServiceOverride = RuntimeKernel.RuntimeServiceOverride\nexport type RuntimeServicesOverrides = RuntimeKernel.RuntimeServicesOverrides\nexport type RuntimeServiceBinding = RuntimeKernel.RuntimeServiceBinding\nexport type RuntimeServicesEvidence = RuntimeKernel.RuntimeServicesEvidence\n\nexport type RuntimeServiceImpl<Service> = RuntimeKernel.RuntimeServiceImpl<Service>\nexport type RuntimeServicesRegistry = RuntimeKernel.RuntimeServicesRegistry\n\nexport type CutoverCoverageMatrix = FullCutoverGate.CutoverCoverageMatrix\n\nexport const CutoverCoverageMatrix = FullCutoverGate.CutoverCoverageMatrix\n\nexport type FullCutoverGateMode = FullCutoverGate.FullCutoverGateMode\n\nexport type FullCutoverGateAnchor = FullCutoverGate.FullCutoverGateAnchor\n\nexport type FullCutoverGateVerdict = FullCutoverGate.FullCutoverGateVerdict\n\nexport type FullCutoverGateResult = FullCutoverGate.FullCutoverGateResult\n\nexport const evaluateFullCutoverGate = (args: {\n  readonly mode: FullCutoverGateMode\n  readonly requestedKernelId: KernelId\n  readonly runtimeServicesEvidence: RuntimeServicesEvidence\n  readonly coverageMatrix?: CutoverCoverageMatrix\n  readonly diagnosticsLevel?: Debug.DiagnosticsLevel\n}): FullCutoverGateResult => {\n  return FullCutoverGate.evaluateFullCutoverGate({\n    mode: args.mode,\n    requestedKernelId: args.requestedKernelId,\n    runtimeServicesEvidence: args.runtimeServicesEvidence,\n    coverageMatrix: args.coverageMatrix,\n    diagnosticsLevel: args.diagnosticsLevel,\n  })\n}\n\nexport interface KernelContractMetaAllowlistItem {\n  readonly metaKey: string\n  readonly reason?: string\n}\n\nexport const KernelContractMetaAllowlist = [] as const satisfies ReadonlyArray<KernelContractMetaAllowlistItem>\n\n/**\n * kernelLayer\uFF1A\n * - \u5728\u5F53\u524D runtime tree \u4E0B\u58F0\u660E\u201C\u8BF7\u6C42\u7684\u5185\u6838\u65CF\u201D\uFF08requested kernel family\uFF09\uFF1B\n * - \u4E0D\u76F4\u63A5\u4F5C\u4E3A\u201C\u5168\u5957\u751F\u6548\u201D\u7684\u8BC1\u660E\uFF08fallback/mix \u7531 RuntimeServicesEvidence \u5224\u5B9A\uFF09\u3002\n */\nexport const kernelLayer = (ref: KernelImplementationRef): LayerType.Layer<any, never, never> =>\n  Layer.succeed(KernelRef.KernelImplementationRefTag, ref) as LayerType.Layer<any, never, never>\n\n/**\n * runtimeDefaultServicesOverridesLayer\uFF1A\n * - \u5728 ManagedRuntime \u88C5\u914D\u9636\u6BB5\u63D0\u4F9B runtime_default scope \u7684 serviceId \u2192 implId \u8986\u5199\uFF1B\n * - \u9ED8\u8BA4\u4E0D\u63D0\u4F9B servicesByModuleId\uFF08\u7981\u6B62\u7528 moduleId \u4F5C\u4E3A\u9ED8\u8BA4\u5185\u6838\u9009\u62E9\u7C92\u5EA6\uFF09\u3002\n */\nexport const runtimeDefaultServicesOverridesLayer = (\n  services: RuntimeServicesOverrides,\n): LayerType.Layer<any, never, never> =>\n  Layer.succeed(RuntimeKernel.RuntimeServicesRuntimeConfigTag, {\n    services,\n  }) as LayerType.Layer<any, never, never>\n\n/**\n * getRuntimeServicesEvidence\uFF1A\n * - \u8BFB\u53D6\u5DF2\u5B89\u88C5\u5728 ModuleRuntime \u4E0A\u7684 RuntimeServicesEvidence\uFF08serviceId \u2192 implId \u8BC1\u636E\uFF09\u3002\n * - \u4F5C\u4E3A\u5BF9\u5916\u5165\u53E3\uFF0C\u907F\u514D\u8C03\u7528\u65B9\u76F4\u63A5\u4F9D\u8D56 src/internal \u8DEF\u5F84\u3002\n */\nexport const getRuntimeServicesEvidence = RuntimeKernel.getRuntimeServicesEvidence\n\n/**\n * getKernelImplementationRef\uFF1A\n * - \u8BFB\u53D6\u5DF2\u5B89\u88C5\u5728 ModuleRuntime \u4E0A\u7684 KernelImplementationRef\uFF08requested kernel family\uFF09\u3002\n */\nexport const getKernelImplementationRef = KernelRef.getKernelImplementationRef\n\n/**\n * runtimeServicesRegistryLayer\uFF1A\n * - \u5728 runtime \u88C5\u914D\u9636\u6BB5\u6CE8\u5165\u989D\u5916\u7684 serviceId \u2192 impls\uFF08\u4F8B\u5982 core-ng \u63D0\u4F9B\u7684\u5B9E\u73B0\uFF09\u3002\n */\nexport const runtimeServicesRegistryLayer = (registry: RuntimeServicesRegistry): LayerType.Layer<any, never, never> =>\n  Layer.succeed(RuntimeKernel.RuntimeServicesRegistryTag, registry) as LayerType.Layer<any, never, never>\n\n/**\n * fullCutoverGateModeLayer\uFF1A\n * - \u63A7\u5236\u8FD0\u884C\u65F6\u88C5\u914D\u9636\u6BB5\u7684 cutover gate \u6267\u884C\u6A21\u5F0F\uFF08trial/fullCutover\uFF09\u3002\n * - \u9ED8\u8BA4\u8DEF\u5F84\uFF08048\uFF09\u5E94\u663E\u5F0F\u8BBE\u7F6E\u4E3A fullCutover\uFF1Btrial-run/\u5BF9\u7167\u53EF\u8986\u76D6\u4E3A trial\u3002\n */\nexport const fullCutoverGateModeLayer = (mode: FullCutoverGateMode): LayerType.Layer<any, never, never> =>\n  Layer.succeed(RuntimeKernel.FullCutoverGateModeTag, mode) as LayerType.Layer<any, never, never>\n\n/**\n * isKernelFullyActivated\uFF1A\n * - \u201C\u5168\u5957\u5207\u6362\u201D\u7684\u6700\u5C0F\u5224\u5B9A\uFF1A\u4E0D\u5141\u8BB8\u53D1\u751F fallback\uFF08\u5426\u5219\u89C6\u4E3A\u672A\u8FBE\u6807\uFF09\u3002\n */\nexport const isKernelFullyActivated = (evidence: RuntimeServicesEvidence): boolean =>\n  !evidence.overridesApplied.some((s) => s.includes('fallback='))\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA,SAAS,aAAa;AAaf,IAAMA,kCAA2C;AAEjD,IAAMC,6BAAsC;AAY5C,IAAMC,yBAAwC;AAU9C,IAAMC,2BAA0B,CAAC,SAMX;AAC3B,SAAuB,wBAAwB;AAAA,IAC7C,MAAM,KAAK;AAAA,IACX,mBAAmB,KAAK;AAAA,IACxB,yBAAyB,KAAK;AAAA,IAC9B,gBAAgB,KAAK;AAAA,IACrB,kBAAkB,KAAK;AAAA,EACzB,CAAC;AACH;AAOO,IAAM,8BAA8B,CAAC;AAOrC,IAAM,cAAc,CAAC,QAC1B,MAAM,QAAkB,4BAA4B,GAAG;AAOlD,IAAM,uCAAuC,CAClD,aAEA,MAAM,QAAsB,iCAAiC;AAAA,EAC3D;AACF,CAAC;AAOI,IAAMC,8BAA2C;AAMjD,IAAMC,8BAAuC;AAM7C,IAAM,+BAA+B,CAAC,aAC3C,MAAM,QAAsB,4BAA4B,QAAQ;AAO3D,IAAM,2BAA2B,CAAC,SACvC,MAAM,QAAsB,wBAAwB,IAAI;AAMnD,IAAM,yBAAyB,CAAC,aACrC,CAAC,SAAS,iBAAiB,KAAK,CAAC,MAAM,EAAE,SAAS,WAAW,CAAC;",
  "names": ["defaultKernelImplementationRef", "isKernelImplementationRef", "CutoverCoverageMatrix", "evaluateFullCutoverGate", "getRuntimeServicesEvidence", "getKernelImplementationRef"]
}
