@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,208 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  attachPhaseRef,
+  isLogicPlanEffect,
+  make as make2,
+  markAsLogicPlanEffect
+} from "./chunk-HIJ67QWR.js";
+import {
+  LogicUnitServiceTag,
+  make
+} from "./chunk-WJY2LSWG.js";
+
+// ../logix-core/src/internal/runtime/ModuleFactory.ts
+import { Context, Effect, Layer, Option, Schema } from "../effect.js";
+function Link(modules, logic) {
+  return Effect.gen(function* () {
+    const handles = {};
+    for (const [key, module] of Object.entries(modules)) {
+      const runtime = yield* module;
+      handles[key] = {
+        read: (selector) => Effect.map(runtime.getState, selector),
+        changes: runtime.changes,
+        dispatch: runtime.dispatch,
+        actions$: runtime.actions$,
+        actions: new Proxy(
+          {},
+          {
+            get: (_target, prop) => (payload) => runtime.dispatch({ _tag: prop, payload })
+          }
+        )
+      };
+    }
+    return yield* logic(
+      handles
+    );
+  });
+}
+function Module(id, def) {
+  const shape = {
+    stateSchema: def.state,
+    actionSchema: Schema.Union(
+      ...Object.entries(def.actions).map(
+        ([tag2, payload]) => Schema.Struct(
+          payload === Schema.Void ? {
+            _tag: Schema.Literal(tag2),
+            payload: Schema.optional(payload)
+          } : {
+            _tag: Schema.Literal(tag2),
+            payload
+          }
+        )
+      )
+    ),
+    actionMap: def.actions
+  };
+  const reducers = def.reducers && Object.fromEntries(
+    Object.entries(def.reducers).map(([tag2, reducer]) => [
+      tag2,
+      (state, action, sink) => (
+        // 这里依赖 `_tag` 的运行时约定：只有匹配当前 tag 的 Action 会交给对应 reducer。
+        reducer(
+          state,
+          action,
+          sink
+        )
+      )
+    ])
+  );
+  class ModuleTag extends Context.Tag(`@logix/Module/${id}`)() {
+  }
+  const tag = ModuleTag;
+  const moduleTag = Object.assign(tag, {
+    _kind: "ModuleTag",
+    id,
+    shape,
+    stateSchema: shape.stateSchema,
+    actionSchema: shape.actionSchema,
+    /**
+     * 为当前 Module 构造一段 Logic 程序：
+     * - 在运行时从 Context 中取出自身的 ModuleRuntime；
+     * - 基于 Runtime 构造 BoundApi；
+     * - 将 BoundApi 交给调用方构造业务 Logic。
+     */
+    logic: (build) => {
+      const phaseRef = { current: "setup" };
+      const phaseService = {
+        get current() {
+          return phaseRef.current;
+        }
+      };
+      const logicEffect = Effect.gen(function* () {
+        const runtime = yield* tag;
+        const logicUnit = yield* Effect.serviceOption(LogicUnitServiceTag).pipe(
+          Effect.map(Option.getOrUndefined)
+        );
+        const api = make(shape, runtime, {
+          getPhase: () => phaseRef.current,
+          phaseService,
+          moduleId: id,
+          logicUnit
+        });
+        let built;
+        try {
+          built = build(api);
+        } catch (err) {
+          if (err?._tag === "LogicPhaseError") {
+            return yield* Effect.fail(err);
+          }
+          throw err;
+        }
+        if (isLogicPlanEffect(built)) {
+          return yield* built;
+        }
+        const isLogicPlan = (value) => Boolean(value && typeof value === "object" && "setup" in value && "run" in value);
+        const plan = isLogicPlan(built) ? built : {
+          setup: Effect.void,
+          run: built
+        };
+        attachPhaseRef(plan, phaseRef);
+        return plan;
+      });
+      markAsLogicPlanEffect(logicEffect);
+      attachPhaseRef(logicEffect, phaseRef);
+      return logicEffect;
+    },
+    /**
+     * live：给定初始状态与一组 Logic，构造带 Scope 的 ModuleRuntime Layer。
+     *
+     * Env 约定：
+     * - R 表示 Logic 运行所需的额外环境（Service / 平台等）；
+     * - ModuleRuntime 本身只依赖 Scope.Scope，由 Layer.scoped 管理。
+     */
+    live: (initial, ...logics) => Layer.scoped(
+      tag,
+      make2(initial, {
+        tag,
+        logics,
+        moduleId: id,
+        reducers
+      })
+    ),
+    /**
+     * implement：基于 Module 定义 + 初始状态 + Logic 集合，生成 ModuleImpl 蓝图。
+     *
+     * - R 表示 Logic 所需的 Env 类型；
+     * - 返回的 ModuleImpl.layer 会携带 R 作为输入环境；
+     * - 通过 withLayer/withLayers 可以逐步将 R 收敛为更具体的 Env（甚至 never）。
+     */
+    implement: (config) => {
+      const importedModules = (config.imports ?? []).flatMap((item) => {
+        if (item._tag === "ModuleImpl") {
+          return [
+            item.module
+          ];
+        }
+        return [];
+      });
+      const baseLayer = Layer.scoped(
+        tag,
+        make2(config.initial, {
+          tag,
+          logics: config.logics || [],
+          processes: config.processes || [],
+          moduleId: id,
+          imports: importedModules,
+          reducers,
+          stateTransaction: config.stateTransaction
+        })
+      );
+      const processes = config.processes ?? [];
+      const makeImplWithLayer = (layer) => ({
+        _tag: "ModuleImpl",
+        module: moduleTag,
+        layer,
+        processes,
+        stateTransaction: config.stateTransaction,
+        withLayer: (extra) => {
+          const provided = layer.pipe(Layer.provide(extra));
+          const merged = Layer.mergeAll(provided, extra);
+          return makeImplWithLayer(merged);
+        },
+        withLayers: (...extras) => extras.reduce(
+          (implAcc, extra) => implAcc.withLayer(extra),
+          makeImplWithLayer(
+            layer
+          )
+        )
+      });
+      const initialImpl = makeImplWithLayer(
+        baseLayer
+      );
+      const imports = config.imports ?? [];
+      const finalImpl = imports.reduce((implAcc, item) => {
+        const layer = item._tag === "ModuleImpl" ? item.layer : item;
+        return implAcc.withLayer(layer);
+      }, initialImpl);
+      return finalImpl;
+    }
+  });
+  return moduleTag;
+}
+
+export {
+  Link,
+  Module
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/ModuleFactory.ts"],
  "sourcesContent": ["import { Context, Effect, Layer, Option, Schema } from 'effect'\nimport * as ModuleRuntimeImpl from './ModuleRuntime.js'\nimport * as BoundApiRuntime from './BoundApiRuntime.js'\nimport * as LogicDiagnostics from './core/LogicDiagnostics.js'\nimport * as LogicPlanMarker from './core/LogicPlanMarker.js'\nimport type { FieldPath } from '../field-path.js'\nimport type {\n  AnyModuleShape,\n  AnySchema,\n  ActionsFromMap,\n  ModuleTag as LogixModuleTag,\n  ModuleShape,\n  ReducersFromMap,\n  StateOf,\n  ActionOf,\n  ModuleHandle,\n  ModuleLogic,\n  ModuleImpl,\n  ModuleImplementStateTransactionOptions,\n} from './core/module.js'\n\n/**\n * v3: Link (\u539F Orchestrator)\n * \u7528\u4E8E\u8DE8\u6A21\u5757\u534F\u4F5C\u7684\u80F6\u6C34\u5C42\u3002\n *\n * - \u4E0D\u6301\u6709\u81EA\u5DF1\u7684 State\uFF1B\n * - \u53EF\u4EE5\u8BBF\u95EE\u591A\u4E2A Module \u7684 ReadonlyHandle\uFF1B\n * - \u53EA\u80FD\u5B9A\u4E49 Logic\uFF0C\u4E0D\u80FD\u5B9A\u4E49 State/Action\u3002\n */\nexport function Link<Modules extends Record<string, LogixModuleTag<any, AnyModuleShape>>, E = never, R = never>(\n  modules: Modules,\n  logic: ($: { [K in keyof Modules]: ModuleHandle<Modules[K]['shape']> }) => Effect.Effect<void, E, R>,\n): Effect.Effect<void, E, R> {\n  return Effect.gen(function* () {\n    const handles: Record<string, ModuleHandle<AnyModuleShape>> = {}\n\n    for (const [key, module] of Object.entries(modules)) {\n      const runtime = yield* module\n\n      handles[key] = {\n        read: (selector: any) => Effect.map(runtime.getState, selector),\n        changes: runtime.changes,\n        dispatch: runtime.dispatch,\n        actions$: runtime.actions$,\n        actions: new Proxy(\n          {},\n          {\n            get: (_target, prop) => (payload: any) => runtime.dispatch({ _tag: prop as string, payload }),\n          },\n        ),\n      }\n    }\n\n    return yield* logic(\n      handles as {\n        [K in keyof Modules]: ModuleHandle<Modules[K]['shape']>\n      },\n    )\n  })\n}\n\n/**\n * Module \u5DE5\u5382\u5B9E\u73B0\uFF1A\u6839\u636E id \u548C Schema \u5B9A\u4E49\u6784\u9020 ModuleTag\u3002\n */\nexport function Module<Id extends string, SSchema extends AnySchema, AMap extends Record<string, AnySchema>>(\n  id: Id,\n  def: {\n    readonly state: SSchema\n    readonly actions: AMap\n    readonly reducers?: ReducersFromMap<SSchema, AMap>\n  },\n): LogixModuleTag<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>> {\n  const shape: ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap> = {\n    stateSchema: def.state,\n    actionSchema: Schema.Union(\n      ...Object.entries(def.actions).map(([tag, payload]) =>\n        Schema.Struct(\n          payload === Schema.Void\n            ? {\n                _tag: Schema.Literal(tag),\n                payload: Schema.optional(payload),\n              }\n            : {\n                _tag: Schema.Literal(tag),\n                payload,\n              },\n        ),\n      ),\n    ) as unknown as Schema.Schema<ActionsFromMap<AMap>>,\n    actionMap: def.actions,\n  }\n\n  type ShapeState = StateOf<typeof shape>\n  type ShapeAction = ActionOf<typeof shape>\n\n  // \u5C06\u6309 Tag \u5206\u7EC4\u7684 reducer \u6620\u5C04\u4E3A\u7B80\u5355\u7684 `_tag -> (state, action, sink?) => state` \u5F62\u6001\uFF0C\u4F9B Runtime \u4F7F\u7528\u3002\n  const reducers =\n    def.reducers &&\n    (Object.fromEntries(\n      Object.entries(def.reducers).map(([tag, reducer]) => [\n        tag,\n        (state: ShapeState, action: ShapeAction, sink?: (path: string | FieldPath) => void) =>\n          // \u8FD9\u91CC\u4F9D\u8D56 `_tag` \u7684\u8FD0\u884C\u65F6\u7EA6\u5B9A\uFF1A\u53EA\u6709\u5339\u914D\u5F53\u524D tag \u7684 Action \u4F1A\u4EA4\u7ED9\u5BF9\u5E94 reducer\u3002\n          (reducer as any)(\n            state,\n            action as {\n              readonly _tag: string\n              readonly payload: unknown\n            },\n            sink,\n          ) as ShapeState,\n      ]),\n    ) as Record<string, (state: ShapeState, action: ShapeAction, sink?: (path: string | FieldPath) => void) => ShapeState>)\n\n  class ModuleTag extends Context.Tag(`@logix/Module/${id}`)<\n    ModuleTag,\n    import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>\n  >() {}\n\n  const tag = ModuleTag\n\n  const moduleTag = Object.assign(tag, {\n    _kind: 'ModuleTag' as const,\n    id,\n    shape,\n    stateSchema: shape.stateSchema,\n    actionSchema: shape.actionSchema,\n    /**\n     * \u4E3A\u5F53\u524D Module \u6784\u9020\u4E00\u6BB5 Logic \u7A0B\u5E8F\uFF1A\n     * - \u5728\u8FD0\u884C\u65F6\u4ECE Context \u4E2D\u53D6\u51FA\u81EA\u8EAB\u7684 ModuleRuntime\uFF1B\n     * - \u57FA\u4E8E Runtime \u6784\u9020 BoundApi\uFF1B\n     * - \u5C06 BoundApi \u4EA4\u7ED9\u8C03\u7528\u65B9\u6784\u9020\u4E1A\u52A1 Logic\u3002\n     */\n    logic: <R = unknown, E = never>(\n      build: (api: import('./core/module.js').BoundApi<typeof shape, R>) => ModuleLogic<typeof shape, R, E>,\n    ): ModuleLogic<typeof shape, R, E> => {\n      const phaseRef: LogicPlanMarker.PhaseRef = { current: 'setup' }\n      const phaseService: LogicDiagnostics.LogicPhaseService = {\n        get current() {\n          return phaseRef.current\n        },\n      }\n      const logicEffect = Effect.gen(function* () {\n        const runtime = yield* tag\n        const logicUnit = yield* Effect.serviceOption(LogicDiagnostics.LogicUnitServiceTag).pipe(\n          Effect.map(Option.getOrUndefined),\n        )\n        const api = BoundApiRuntime.make<typeof shape, R>(shape, runtime, {\n          getPhase: () => phaseRef.current,\n          phaseService,\n          moduleId: id,\n          logicUnit,\n        })\n\n        let built: unknown\n        try {\n          built = build(api)\n        } catch (err) {\n          // \u5C06\u540C\u6B65\u629B\u51FA\u7684 LogicPhaseError \u8F6C\u6362\u4E3A Effect.fail\uFF0C\u907F\u514D runSync \u89C6\u4E3A\u201C\u5F02\u6B65\u672A\u51B3 Fiber\u201D\n          if ((err as any)?._tag === 'LogicPhaseError') {\n            return yield* Effect.fail(err as any)\n          }\n          throw err\n        }\n\n        if (LogicPlanMarker.isLogicPlanEffect(built)) {\n          return yield* built as Effect.Effect<any, any, any>\n        }\n\n        const isLogicPlan = (value: unknown): value is import('./core/module.js').LogicPlan<typeof shape, R, E> =>\n          Boolean(value && typeof value === 'object' && 'setup' in (value as any) && 'run' in (value as any))\n\n        const plan = isLogicPlan(built)\n          ? built\n          : ({\n              setup: Effect.void,\n              run: built as Effect.Effect<any, any, any>,\n            } satisfies import('./core/module.js').LogicPlan<typeof shape, R, E>)\n\n        LogicPlanMarker.attachPhaseRef(plan as any, phaseRef)\n        return plan\n      })\n\n      LogicPlanMarker.markAsLogicPlanEffect(logicEffect)\n      LogicPlanMarker.attachPhaseRef(logicEffect, phaseRef)\n      return logicEffect\n    },\n\n    /**\n     * live\uFF1A\u7ED9\u5B9A\u521D\u59CB\u72B6\u6001\u4E0E\u4E00\u7EC4 Logic\uFF0C\u6784\u9020\u5E26 Scope \u7684 ModuleRuntime Layer\u3002\n     *\n     * Env \u7EA6\u5B9A\uFF1A\n     * - R \u8868\u793A Logic \u8FD0\u884C\u6240\u9700\u7684\u989D\u5916\u73AF\u5883\uFF08Service / \u5E73\u53F0\u7B49\uFF09\uFF1B\n     * - ModuleRuntime \u672C\u8EAB\u53EA\u4F9D\u8D56 Scope.Scope\uFF0C\u7531 Layer.scoped \u7BA1\u7406\u3002\n     */\n    live: <R = never, E = never>(\n      initial: StateOf<typeof shape>,\n      ...logics: Array<ModuleLogic<typeof shape, R, E>>\n    ): Layer.Layer<import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>, E, R> =>\n      Layer.scoped(\n        tag,\n        ModuleRuntimeImpl.make<StateOf<typeof shape>, ActionOf<typeof shape>, R>(initial, {\n          tag,\n          logics: logics as ReadonlyArray<Effect.Effect<any, any, any>>,\n          moduleId: id,\n          reducers,\n        }),\n      ) as unknown as Layer.Layer<\n        import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>,\n        E,\n        R\n      >,\n\n    /**\n     * implement\uFF1A\u57FA\u4E8E Module \u5B9A\u4E49 + \u521D\u59CB\u72B6\u6001 + Logic \u96C6\u5408\uFF0C\u751F\u6210 ModuleImpl \u84DD\u56FE\u3002\n     *\n     * - R \u8868\u793A Logic \u6240\u9700\u7684 Env \u7C7B\u578B\uFF1B\n     * - \u8FD4\u56DE\u7684 ModuleImpl.layer \u4F1A\u643A\u5E26 R \u4F5C\u4E3A\u8F93\u5165\u73AF\u5883\uFF1B\n     * - \u901A\u8FC7 withLayer/withLayers \u53EF\u4EE5\u9010\u6B65\u5C06 R \u6536\u655B\u4E3A\u66F4\u5177\u4F53\u7684 Env\uFF08\u751A\u81F3 never\uFF09\u3002\n     */\n    implement: <R = never>(config: {\n      initial: StateOf<typeof shape>\n      logics?: Array<ModuleLogic<typeof shape, R, never>>\n      imports?: ReadonlyArray<Layer.Layer<any, any, any> | ModuleImpl<any, AnyModuleShape, any>>\n      /**\n       * processes\uFF1A\u4E0E\u8BE5 Module \u5B9E\u73B0\u7ED1\u5B9A\u7684\u4E00\u7EC4\u957F\u671F\u6D41\u7A0B\uFF08\u542B Link\uFF09\u3002\n       *\n       * - \u8FD9\u4E9B Effect \u4F1A\u5728\u8FD0\u884C\u65F6\u5BB9\u5668\uFF08\u4F8B\u5982 Runtime.make\uFF09\u4E2D\u88AB\u7EDF\u4E00 fork\uFF1B\n       * - \u7C7B\u578B\u4E0A\u4F7F\u7528\u5BBD\u677E\u7684 E/R \u4EE5\u4FBF\u7EC4\u5408\u5404\u79CD\u8DE8\u6A21\u5757\u7F16\u6392\u903B\u8F91\uFF1B\n       * - \u4E1A\u52A1\u4EE3\u7801\u901A\u5E38\u901A\u8FC7 Link.make \u6784\u9020\u8FD9\u4E9B\u6D41\u7A0B\u3002\n       */\n      processes?: ReadonlyArray<Effect.Effect<void, any, any>>\n      /**\n       * stateTransaction\uFF1A\u6A21\u5757\u7EA7 StateTransaction \u914D\u7F6E\u3002\n       *\n       * - instrumentation \u672A\u63D0\u4F9B\u65F6\uFF0C\u9000\u56DE\u5230 Runtime \u7EA7\u914D\u7F6E\uFF08\u5982\u6709\uFF09\u6216 NODE_ENV \u9ED8\u8BA4\uFF1B\n       * - instrumentation \u63D0\u4F9B\u65F6\uFF0C\u4F18\u5148\u4E8E Runtime \u7EA7\u914D\u7F6E\u4E0E\u9ED8\u8BA4\u503C\u3002\n       */\n      stateTransaction?: ModuleImplementStateTransactionOptions\n    }): ModuleImpl<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>, R> => {\n      const importedModules = (config.imports ?? []).flatMap((item) => {\n        if ((item as ModuleImpl<any, AnyModuleShape, any>)._tag === 'ModuleImpl') {\n          return [\n            (item as ModuleImpl<any, AnyModuleShape, any>).module as unknown as Context.Tag<\n              any,\n              import('./core/module.js').ModuleRuntime<any, any>\n            >,\n          ]\n        }\n        return []\n      })\n\n      const baseLayer = Layer.scoped(\n        tag,\n        ModuleRuntimeImpl.make<StateOf<typeof shape>, ActionOf<typeof shape>, R>(config.initial, {\n          tag,\n          logics: (config.logics || []) as ReadonlyArray<Effect.Effect<any, any, any>>,\n          processes: (config.processes || []) as ReadonlyArray<Effect.Effect<void, any, any>>,\n          moduleId: id,\n          imports: importedModules,\n          reducers,\n          stateTransaction: config.stateTransaction,\n        }),\n      ) as unknown as Layer.Layer<\n        import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>,\n        never,\n        any\n      >\n\n      const processes = config.processes ?? []\n\n      const makeImplWithLayer = (\n        layer: Layer.Layer<\n          import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>,\n          never,\n          any\n        >,\n      ): ModuleImpl<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>, any> => ({\n        _tag: 'ModuleImpl',\n        module: moduleTag as unknown as LogixModuleTag<\n          Id,\n          ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>\n        >,\n        layer,\n        processes,\n        stateTransaction: config.stateTransaction,\n        withLayer: (\n          extra: Layer.Layer<any, never, any>,\n        ): ModuleImpl<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>, any> => {\n          const provided = (\n            layer as Layer.Layer<\n              import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>,\n              never,\n              any\n            >\n          ).pipe(Layer.provide(extra as Layer.Layer<any, never, any>))\n\n          const merged = Layer.mergeAll(provided, extra as Layer.Layer<any, never, any>) as Layer.Layer<\n            import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>,\n            never,\n            any\n          >\n\n          return makeImplWithLayer(merged)\n        },\n        withLayers: (\n          ...extras: ReadonlyArray<Layer.Layer<any, never, any>>\n        ): ModuleImpl<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>, any> =>\n          extras.reduce<ModuleImpl<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>, any>>(\n            (implAcc, extra) => implAcc.withLayer(extra),\n            makeImplWithLayer(\n              layer as Layer.Layer<\n                import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>,\n                never,\n                any\n              >,\n            ),\n          ),\n      })\n\n      // \u4ECE baseLayer \u5F00\u59CB\uFF0C\u4F9D\u6B21\u53E0\u52A0 imports\uFF08Layer \u6216\u5176\u4ED6 ModuleImpl \u7684 layer\uFF09\n      const initialImpl = makeImplWithLayer(\n        baseLayer as Layer.Layer<\n          import('./core/module.js').ModuleRuntime<StateOf<typeof shape>, ActionOf<typeof shape>>,\n          never,\n          any\n        >,\n      )\n\n      const imports = config.imports ?? []\n\n      const finalImpl = imports.reduce<\n        ModuleImpl<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>, any>\n      >((implAcc, item) => {\n        const layer =\n          (item as ModuleImpl<any, AnyModuleShape, any>)._tag === 'ModuleImpl'\n            ? (item as ModuleImpl<any, AnyModuleShape, any>).layer\n            : (item as Layer.Layer<any, any, any>)\n\n        return implAcc.withLayer(layer as Layer.Layer<any, never, any>)\n      }, initialImpl)\n\n      return finalImpl\n    },\n  })\n\n  return moduleTag as LogixModuleTag<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>>\n}\n"],
  "mappings": "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",
  "names": ["tag", "make"]
}


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

@@ -0,0 +1,13 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+
+// ../logix-core/src/internal/runtime/core/RootContext.ts
+import { Context } from "../effect.js";
+var RootContextTagImpl = class extends Context.Tag("@logixjs/core/RootContext")() {
+};
+var RootContextTag = RootContextTagImpl;
+
+export {
+  RootContextTag
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vbG9naXgtY29yZS9zcmMvaW50ZXJuYWwvcnVudGltZS9jb3JlL1Jvb3RDb250ZXh0LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJpbXBvcnQgeyBDb250ZXh0LCBEZWZlcnJlZCB9IGZyb20gJ2VmZmVjdCdcblxuZXhwb3J0IGludGVyZmFjZSBSb290Q29udGV4dCB7XG4gIGNvbnRleHQ6IENvbnRleHQuQ29udGV4dDxhbnk+IHwgdW5kZWZpbmVkXG4gIHJlYWRvbmx5IHJlYWR5OiBEZWZlcnJlZC5EZWZlcnJlZDxDb250ZXh0LkNvbnRleHQ8YW55PiwgbmV2ZXI+XG4gIHJlYWRvbmx5IGFwcElkPzogc3RyaW5nXG4gIHJlYWRvbmx5IGFwcE1vZHVsZUlkcz86IFJlYWRvbmx5QXJyYXk8c3RyaW5nPlxufVxuXG5jbGFzcyBSb290Q29udGV4dFRhZ0ltcGwgZXh0ZW5kcyBDb250ZXh0LlRhZygnQGxvZ2l4anMvY29yZS9Sb290Q29udGV4dCcpPFJvb3RDb250ZXh0VGFnSW1wbCwgUm9vdENvbnRleHQ+KCkge31cblxuZXhwb3J0IGNvbnN0IFJvb3RDb250ZXh0VGFnID0gUm9vdENvbnRleHRUYWdJbXBsXG4iXSwKICAibWFwcGluZ3MiOiAiOzs7O0FBQUEsU0FBUyxlQUF5QjtBQVNsQyxJQUFNLHFCQUFOLGNBQWlDLFFBQVEsSUFBSSwyQkFBMkIsRUFBbUMsRUFBRTtBQUFDO0FBRXZHLElBQU0saUJBQWlCOyIsCiAgIm5hbWVzIjogW10KfQo=

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

@@ -0,0 +1,69 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  record
+} from "./chunk-SFXJ24HY.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-UJGVDFZN.js

@@ -0,0 +1,147 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+
+// ../logix-core/src/internal/runtime/core/HostScheduler.ts
+var noopCancel = () => {
+};
+var safeNowMs = () => {
+  const perf = globalThis.performance;
+  if (perf && typeof perf.now === "function") {
+    try {
+      const v = perf.now();
+      if (typeof v === "number" && Number.isFinite(v)) return v;
+    } catch {
+    }
+  }
+  return Date.now();
+};
+var safeQueueMicrotask = (cb) => {
+  const qm = globalThis.queueMicrotask;
+  if (typeof qm === "function") {
+    try {
+      qm(cb);
+      return;
+    } catch {
+    }
+  }
+  try {
+    Promise.resolve().then(cb);
+  } catch {
+    setTimeout(cb, 0);
+  }
+};
+var safeSetTimeout = (ms, cb) => {
+  const id = setTimeout(cb, ms);
+  return () => {
+    try {
+      clearTimeout(id);
+    } catch {
+    }
+  };
+};
+var makeMessageChannelMacrotask = () => {
+  const MC = globalThis.MessageChannel;
+  if (typeof MC !== "function") return void 0;
+  let channel;
+  try {
+    channel = new MC();
+  } catch {
+    return void 0;
+  }
+  const queue = [];
+  let scheduled = false;
+  const flush = () => {
+    scheduled = false;
+    const tasks = queue.splice(0, queue.length);
+    for (const t of tasks) {
+      if (t.canceled) continue;
+      try {
+        t.cb();
+      } catch {
+      }
+    }
+  };
+  try {
+    channel.port1.onmessage = flush;
+  } catch {
+    return void 0;
+  }
+  const schedule = (cb) => {
+    const task = { canceled: false, cb };
+    queue.push(task);
+    if (!scheduled) {
+      scheduled = true;
+      try {
+        channel.port2.postMessage(void 0);
+      } catch {
+        scheduled = false;
+        return safeSetTimeout(0, cb);
+      }
+    }
+    return () => {
+      task.canceled = true;
+    };
+  };
+  return schedule;
+};
+var makeSetImmediateMacrotask = () => {
+  const si = globalThis.setImmediate;
+  const ci = globalThis.clearImmediate;
+  if (typeof si !== "function") return void 0;
+  return (cb) => {
+    let id;
+    try {
+      id = si(cb);
+    } catch {
+      return safeSetTimeout(0, cb);
+    }
+    return () => {
+      if (typeof ci !== "function") return;
+      try {
+        ci(id);
+      } catch {
+      }
+    };
+  };
+};
+var makeRaf = () => {
+  const raf = globalThis.requestAnimationFrame;
+  const cancel = globalThis.cancelAnimationFrame;
+  if (typeof raf !== "function") return void 0;
+  return (cb) => {
+    let id;
+    try {
+      id = raf(cb);
+    } catch {
+      return noopCancel;
+    }
+    return () => {
+      if (typeof cancel !== "function") return;
+      try {
+        cancel(id);
+      } catch {
+      }
+    };
+  };
+};
+var makeDefaultHostScheduler = () => {
+  const macrotask = makeSetImmediateMacrotask() ?? makeMessageChannelMacrotask() ?? ((cb) => safeSetTimeout(0, cb));
+  const raf = makeRaf();
+  return {
+    nowMs: safeNowMs,
+    scheduleMicrotask: safeQueueMicrotask,
+    scheduleMacrotask: macrotask,
+    scheduleAnimationFrame: (cb) => raf?.(cb) ?? macrotask(cb),
+    scheduleTimeout: safeSetTimeout
+  };
+};
+var globalHostScheduler;
+var getGlobalHostScheduler = () => {
+  globalHostScheduler ?? (globalHostScheduler = makeDefaultHostScheduler());
+  return globalHostScheduler;
+};
+
+export {
+  getGlobalHostScheduler
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/HostScheduler.ts"],
  "sourcesContent": ["export type Cancel = () => void\n\nexport type HostScheduler = {\n  readonly nowMs: () => number\n  readonly scheduleMicrotask: (cb: () => void) => void\n  readonly scheduleMacrotask: (cb: () => void) => Cancel\n  readonly scheduleAnimationFrame: (cb: () => void) => Cancel\n  readonly scheduleTimeout: (ms: number, cb: () => void) => Cancel\n}\n\nconst noopCancel: Cancel = () => {}\n\nconst safeNowMs = (): number => {\n  const perf = (globalThis as any).performance as { now?: () => number } | undefined\n  if (perf && typeof perf.now === 'function') {\n    try {\n      const v = perf.now()\n      if (typeof v === 'number' && Number.isFinite(v)) return v\n    } catch {\n      // fallthrough\n    }\n  }\n\n  return Date.now()\n}\n\nconst safeQueueMicrotask = (cb: () => void): void => {\n  const qm = (globalThis as any).queueMicrotask as ((run: () => void) => void) | undefined\n  if (typeof qm === 'function') {\n    try {\n      qm(cb)\n      return\n    } catch {\n      // fallthrough\n    }\n  }\n\n  // Promise job fallback (still a microtask boundary).\n  try {\n    Promise.resolve().then(cb)\n  } catch {\n    // last resort\n    setTimeout(cb, 0)\n  }\n}\n\nconst safeSetTimeout = (ms: number, cb: () => void): Cancel => {\n  const id = setTimeout(cb, ms)\n  return () => {\n    try {\n      clearTimeout(id)\n    } catch {\n      // best-effort\n    }\n  }\n}\n\nconst makeMessageChannelMacrotask = (): ((cb: () => void) => Cancel) | undefined => {\n  const MC = (globalThis as any).MessageChannel as { new (): MessageChannel } | undefined\n  if (typeof MC !== 'function') return undefined\n\n  let channel: MessageChannel\n  try {\n    channel = new MC()\n  } catch {\n    return undefined\n  }\n\n  type Task = { canceled: boolean; cb: () => void }\n  const queue: Array<Task> = []\n  let scheduled = false\n\n  const flush = (): void => {\n    scheduled = false\n    const tasks = queue.splice(0, queue.length)\n    for (const t of tasks) {\n      if (t.canceled) continue\n      try {\n        t.cb()\n      } catch {\n        // best-effort\n      }\n    }\n  }\n\n  try {\n    channel.port1.onmessage = flush\n  } catch {\n    return undefined\n  }\n\n  const schedule = (cb: () => void): Cancel => {\n    const task: Task = { canceled: false, cb }\n    queue.push(task)\n    if (!scheduled) {\n      scheduled = true\n      try {\n        channel.port2.postMessage(undefined)\n      } catch {\n        scheduled = false\n        // fallback to timeout if postMessage fails\n        return safeSetTimeout(0, cb)\n      }\n    }\n    return () => {\n      task.canceled = true\n    }\n  }\n\n  return schedule\n}\n\nconst makeSetImmediateMacrotask = (): ((cb: () => void) => Cancel) | undefined => {\n  const si = (globalThis as any).setImmediate as ((run: () => void) => any) | undefined\n  const ci = (globalThis as any).clearImmediate as ((id: any) => void) | undefined\n  if (typeof si !== 'function') return undefined\n\n  return (cb) => {\n    let id: any\n    try {\n      id = si(cb)\n    } catch {\n      return safeSetTimeout(0, cb)\n    }\n\n    return () => {\n      if (typeof ci !== 'function') return\n      try {\n        ci(id)\n      } catch {\n        // best-effort\n      }\n    }\n  }\n}\n\nconst makeRaf = (): ((cb: () => void) => Cancel) | undefined => {\n  const raf = (globalThis as any).requestAnimationFrame as ((run: () => void) => number) | undefined\n  const cancel = (globalThis as any).cancelAnimationFrame as ((id: number) => void) | undefined\n  if (typeof raf !== 'function') return undefined\n\n  return (cb) => {\n    let id: number\n    try {\n      id = raf(cb)\n    } catch {\n      return noopCancel\n    }\n\n    return () => {\n      if (typeof cancel !== 'function') return\n      try {\n        cancel(id)\n      } catch {\n        // best-effort\n      }\n    }\n  }\n}\n\nexport const makeDefaultHostScheduler = (): HostScheduler => {\n  const macrotask =\n    makeSetImmediateMacrotask() ??\n    makeMessageChannelMacrotask() ??\n    ((cb: () => void) => safeSetTimeout(0, cb))\n\n  const raf = makeRaf()\n\n  return {\n    nowMs: safeNowMs,\n    scheduleMicrotask: safeQueueMicrotask,\n    scheduleMacrotask: macrotask,\n    scheduleAnimationFrame: (cb) => raf?.(cb) ?? macrotask(cb),\n    scheduleTimeout: safeSetTimeout,\n  }\n}\n\nlet globalHostScheduler: HostScheduler | undefined\n\nexport const getGlobalHostScheduler = (): HostScheduler => {\n  globalHostScheduler ??= makeDefaultHostScheduler()\n  return globalHostScheduler\n}\n\nexport const __unsafeSetGlobalHostSchedulerForTests = (next: HostScheduler | undefined): void => {\n  globalHostScheduler = next\n}\n\nexport type DeterministicHostScheduler = HostScheduler & {\n  readonly flushMicrotasks: (options?: { readonly max?: number }) => number\n  readonly flushOneMacrotask: () => boolean\n  readonly flushAll: (options?: { readonly maxTurns?: number }) => { readonly turns: number; readonly ran: number }\n  readonly getQueueSize: () => { readonly microtasks: number; readonly macrotasks: number }\n}\n\nexport const makeDeterministicHostScheduler = (): DeterministicHostScheduler => {\n  const microtasks: Array<() => void> = []\n  const macrotasks: Array<{ canceled: boolean; cb: () => void }> = []\n\n  const flushMicrotasks = (options?: { readonly max?: number }): number => {\n    const max = options?.max ?? 10_000\n    let ran = 0\n    while (microtasks.length > 0 && ran < max) {\n      const cb = microtasks.shift()!\n      ran += 1\n      try {\n        cb()\n      } catch {\n        // best-effort\n      }\n    }\n    return ran\n  }\n\n  const flushOneMacrotask = (): boolean => {\n    const t = macrotasks.shift()\n    if (!t) return false\n    if (t.canceled) return true\n    try {\n      t.cb()\n    } catch {\n      // best-effort\n    }\n    return true\n  }\n\n  const flushAll = (options?: { readonly maxTurns?: number }): { turns: number; ran: number } => {\n    const maxTurns = options?.maxTurns ?? 10_000\n    let turns = 0\n    let ran = 0\n\n    while (turns < maxTurns) {\n      const before = microtasks.length + macrotasks.length\n      ran += flushMicrotasks()\n      if (microtasks.length > 0) {\n        turns += 1\n        continue\n      }\n      if (flushOneMacrotask()) {\n        turns += 1\n        continue\n      }\n      const after = microtasks.length + macrotasks.length\n      if (after === 0 || after === before) break\n      turns += 1\n    }\n\n    return { turns, ran }\n  }\n\n  return {\n    nowMs: safeNowMs,\n    scheduleMicrotask: (cb) => {\n      microtasks.push(cb)\n    },\n    scheduleMacrotask: (cb) => {\n      const task = { canceled: false, cb }\n      macrotasks.push(task)\n      return () => {\n        task.canceled = true\n      }\n    },\n    scheduleAnimationFrame: (cb) => {\n      const task = { canceled: false, cb }\n      macrotasks.push(task)\n      return () => {\n        task.canceled = true\n      }\n    },\n    scheduleTimeout: (_ms, cb) => {\n      const task = { canceled: false, cb }\n      macrotasks.push(task)\n      return () => {\n        task.canceled = true\n      }\n    },\n    flushMicrotasks,\n    flushOneMacrotask,\n    flushAll,\n    getQueueSize: () => ({ microtasks: microtasks.length, macrotasks: macrotasks.length }),\n  }\n}\n"],
  "mappings": "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",
  "names": []
}
