@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,112 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  isDevEnv
+} from "./chunk-GP37MEGJ.js";
+
+// ../logix-core/src/internal/resource.ts
+import { Context, Layer } from "../effect.js";
+var stableStringify = (value) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const encode = (input) => {
+    if (input === null) return null;
+    if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") {
+      return input;
+    }
+    if (typeof input === "bigint") return input.toString();
+    if (typeof input === "undefined") return "__undefined__";
+    if (typeof input === "symbol") return `__symbol__:${String(input)}`;
+    if (typeof input === "function") return "__function__";
+    if (Array.isArray(input)) {
+      return input.map((v) => encode(v));
+    }
+    if (input instanceof Date) {
+      return `__date__:${input.toISOString()}`;
+    }
+    if (input instanceof Error) {
+      return {
+        _tag: "Error",
+        name: input.name,
+        message: input.message
+      };
+    }
+    if (input && typeof input === "object") {
+      const obj = input;
+      if (seen.has(obj)) return "__cycle__";
+      seen.add(obj);
+      const record = input;
+      const keys = Object.keys(record).sort();
+      const out = {};
+      for (const k of keys) {
+        out[k] = encode(record[k]);
+      }
+      return out;
+    }
+    return String(input);
+  };
+  try {
+    return JSON.stringify(encode(value));
+  } catch {
+    return String(value);
+  }
+};
+var keyHash = (key) => stableStringify(key);
+var Snapshot = {
+  idle: () => ({
+    status: "idle",
+    keyHash: void 0,
+    data: void 0,
+    error: void 0
+  }),
+  loading: (params) => ({
+    status: "loading",
+    keyHash: params.keyHash,
+    data: void 0,
+    error: void 0
+  }),
+  success: (params) => ({
+    status: "success",
+    keyHash: params.keyHash,
+    data: params.data,
+    error: void 0
+  }),
+  error: (params) => ({
+    status: "error",
+    keyHash: params.keyHash,
+    data: void 0,
+    error: params.error
+  })
+};
+var ResourceRegistryTag = class extends Context.Tag(
+  "@logix/core/ResourceRegistry"
+)() {
+};
+var internal = {
+  ResourceRegistryTag
+};
+var make = (spec) => spec;
+var layer = (specs) => Layer.succeed(
+  ResourceRegistryTag,
+  (() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const spec of specs) {
+      if (isDevEnv() && map.has(spec.id) && map.get(spec.id) !== spec) {
+        throw new Error(
+          `[Resource.layer] Duplicate resource id "${spec.id}" detected in the same runtime scope`
+        );
+      }
+      map.set(spec.id, spec);
+    }
+    return { specs: map };
+  })()
+);
+
+export {
+  keyHash,
+  Snapshot,
+  ResourceRegistryTag,
+  internal,
+  make,
+  layer
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/resource.ts"],
  "sourcesContent": ["import { Context, Layer } from \"effect\"\nimport { isDevEnv } from \"./runtime/core/env.js\"\n\nexport interface ResourceSpec<Key, Out, Err, Env> {\n  readonly id: string\n  readonly keySchema: import(\"effect\").Schema.Schema<Key, any>\n  readonly load: (key: Key) => import(\"effect\").Effect.Effect<Out, Err, Env>\n  readonly meta?: {\n    readonly cacheGroup?: string\n    readonly description?: string\n    readonly [k: string]: unknown\n  }\n}\n\nexport type AnyResourceSpec = ResourceSpec<any, any, any, any>\n\nexport type ResourceStatus = \"idle\" | \"loading\" | \"success\" | \"error\"\n\nexport interface ResourceSnapshot<Data = unknown, Err = unknown> {\n  readonly status: ResourceStatus\n  readonly keyHash?: string\n  readonly data?: Data\n  readonly error?: Err\n}\n\nconst stableStringify = (value: unknown): string => {\n  const seen = new WeakSet<object>()\n  const encode = (input: unknown): unknown => {\n    if (input === null) return null\n    if (\n      typeof input === \"string\" ||\n      typeof input === \"number\" ||\n      typeof input === \"boolean\"\n    ) {\n      return input\n    }\n    if (typeof input === \"bigint\") return input.toString()\n    if (typeof input === \"undefined\") return \"__undefined__\"\n    if (typeof input === \"symbol\") return `__symbol__:${String(input)}`\n    if (typeof input === \"function\") return \"__function__\"\n\n    if (Array.isArray(input)) {\n      return input.map((v) => encode(v))\n    }\n    if (input instanceof Date) {\n      return `__date__:${input.toISOString()}`\n    }\n    if (input instanceof Error) {\n      return {\n        _tag: \"Error\",\n        name: input.name,\n        message: input.message,\n      }\n    }\n    if (input && typeof input === \"object\") {\n      const obj = input as object\n      if (seen.has(obj)) return \"__cycle__\"\n      seen.add(obj)\n\n      const record = input as Record<string, unknown>\n      const keys = Object.keys(record).sort()\n      const out: Record<string, unknown> = {}\n      for (const k of keys) {\n        out[k] = encode(record[k])\n      }\n      return out\n    }\n    return String(input)\n  }\n\n  try {\n    return JSON.stringify(encode(value))\n  } catch {\n    return String(value)\n  }\n}\n\nexport const keyHash = (key: unknown): string => stableStringify(key)\n\nexport const Snapshot = {\n  idle: <Data = never, Err = never>(): ResourceSnapshot<Data, Err> => ({\n    status: \"idle\",\n    keyHash: undefined,\n    data: undefined,\n    error: undefined,\n  }),\n  loading: <Data = never, Err = never>(params: {\n    readonly keyHash: string\n  }): ResourceSnapshot<Data, Err> => ({\n    status: \"loading\",\n    keyHash: params.keyHash,\n    data: undefined,\n    error: undefined,\n  }),\n  success: <Data>(params: {\n    readonly keyHash: string\n    readonly data: Data\n  }): ResourceSnapshot<Data, never> => ({\n    status: \"success\",\n    keyHash: params.keyHash,\n    data: params.data,\n    error: undefined,\n  }),\n  error: <Err>(params: {\n    readonly keyHash: string\n    readonly error: Err\n  }): ResourceSnapshot<never, Err> => ({\n    status: \"error\",\n    keyHash: params.keyHash,\n    data: undefined,\n    error: params.error,\n  }),\n} as const\n\nexport interface ResourceRegistry {\n  readonly specs: ReadonlyMap<string, AnyResourceSpec>\n}\n\nexport class ResourceRegistryTag extends Context.Tag(\n  \"@logix/core/ResourceRegistry\",\n)<ResourceRegistryTag, ResourceRegistry>() {}\n\nexport const internal = {\n  ResourceRegistryTag,\n}\n\nexport type Spec<Key, Out, Err, Env> = ResourceSpec<Key, Out, Err, Env>\n\nexport const make = <Key, Out, Err, Env>(\n  spec: ResourceSpec<Key, Out, Err, Env>,\n): ResourceSpec<Key, Out, Err, Env> => spec\n\nexport const layer = (\n  specs: ReadonlyArray<AnyResourceSpec>,\n): Layer.Layer<ResourceRegistryTag, never, never> =>\n  Layer.succeed(\n    ResourceRegistryTag,\n    (() => {\n      const map = new Map<string, AnyResourceSpec>()\n      for (const spec of specs) {\n        if (isDevEnv() && map.has(spec.id) && map.get(spec.id) !== spec) {\n          throw new Error(\n            `[Resource.layer] Duplicate resource id \"${spec.id}\" detected in the same runtime scope`,\n          )\n        }\n        map.set(spec.id, spec)\n      }\n      return { specs: map }\n    })(),\n  )\n\n"],
  "mappings": ";;;;;;;AAAA,SAAS,SAAS,aAAa;AAyB/B,IAAM,kBAAkB,CAAC,UAA2B;AAClD,QAAM,OAAO,oBAAI,QAAgB;AACjC,QAAM,SAAS,CAAC,UAA4B;AAC1C,QAAI,UAAU,KAAM,QAAO;AAC3B,QACE,OAAO,UAAU,YACjB,OAAO,UAAU,YACjB,OAAO,UAAU,WACjB;AACA,aAAO;AAAA,IACT;AACA,QAAI,OAAO,UAAU,SAAU,QAAO,MAAM,SAAS;AACrD,QAAI,OAAO,UAAU,YAAa,QAAO;AACzC,QAAI,OAAO,UAAU,SAAU,QAAO,cAAc,OAAO,KAAK,CAAC;AACjE,QAAI,OAAO,UAAU,WAAY,QAAO;AAExC,QAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,aAAO,MAAM,IAAI,CAAC,MAAM,OAAO,CAAC,CAAC;AAAA,IACnC;AACA,QAAI,iBAAiB,MAAM;AACzB,aAAO,YAAY,MAAM,YAAY,CAAC;AAAA,IACxC;AACA,QAAI,iBAAiB,OAAO;AAC1B,aAAO;AAAA,QACL,MAAM;AAAA,QACN,MAAM,MAAM;AAAA,QACZ,SAAS,MAAM;AAAA,MACjB;AAAA,IACF;AACA,QAAI,SAAS,OAAO,UAAU,UAAU;AACtC,YAAM,MAAM;AACZ,UAAI,KAAK,IAAI,GAAG,EAAG,QAAO;AAC1B,WAAK,IAAI,GAAG;AAEZ,YAAM,SAAS;AACf,YAAM,OAAO,OAAO,KAAK,MAAM,EAAE,KAAK;AACtC,YAAM,MAA+B,CAAC;AACtC,iBAAW,KAAK,MAAM;AACpB,YAAI,CAAC,IAAI,OAAO,OAAO,CAAC,CAAC;AAAA,MAC3B;AACA,aAAO;AAAA,IACT;AACA,WAAO,OAAO,KAAK;AAAA,EACrB;AAEA,MAAI;AACF,WAAO,KAAK,UAAU,OAAO,KAAK,CAAC;AAAA,EACrC,QAAQ;AACN,WAAO,OAAO,KAAK;AAAA,EACrB;AACF;AAEO,IAAM,UAAU,CAAC,QAAyB,gBAAgB,GAAG;AAE7D,IAAM,WAAW;AAAA,EACtB,MAAM,OAA+D;AAAA,IACnE,QAAQ;AAAA,IACR,SAAS;AAAA,IACT,MAAM;AAAA,IACN,OAAO;AAAA,EACT;AAAA,EACA,SAAS,CAA4B,YAED;AAAA,IAClC,QAAQ;AAAA,IACR,SAAS,OAAO;AAAA,IAChB,MAAM;AAAA,IACN,OAAO;AAAA,EACT;AAAA,EACA,SAAS,CAAO,YAGsB;AAAA,IACpC,QAAQ;AAAA,IACR,SAAS,OAAO;AAAA,IAChB,MAAM,OAAO;AAAA,IACb,OAAO;AAAA,EACT;AAAA,EACA,OAAO,CAAM,YAGwB;AAAA,IACnC,QAAQ;AAAA,IACR,SAAS,OAAO;AAAA,IAChB,MAAM;AAAA,IACN,OAAO,OAAO;AAAA,EAChB;AACF;AAMO,IAAM,sBAAN,cAAkC,QAAQ;AAAA,EAC/C;AACF,EAAyC,EAAE;AAAC;AAErC,IAAM,WAAW;AAAA,EACtB;AACF;AAIO,IAAM,OAAO,CAClB,SACqC;AAEhC,IAAM,QAAQ,CACnB,UAEA,MAAM;AAAA,EACJ;AAAA,GACC,MAAM;AACL,UAAM,MAAM,oBAAI,IAA6B;AAC7C,eAAW,QAAQ,OAAO;AACxB,UAAI,SAAS,KAAK,IAAI,IAAI,KAAK,EAAE,KAAK,IAAI,IAAI,KAAK,EAAE,MAAM,MAAM;AAC/D,cAAM,IAAI;AAAA,UACR,2CAA2C,KAAK,EAAE;AAAA,QACpD;AAAA,MACF;AACA,UAAI,IAAI,KAAK,IAAI,IAAI;AAAA,IACvB;AACA,WAAO,EAAE,OAAO,IAAI;AAAA,EACtB,GAAG;AACL;",
  "names": []
}


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

@@ -0,0 +1,221 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  attachPhaseRef,
+  isLogicPlanEffect,
+  make as make2,
+  markAsLogicPlanEffect
+} from "./chunk-TJB73XPN.js";
+import {
+  make
+} from "./chunk-U5J3LCYI.js";
+import {
+  LogicUnitServiceTag
+} from "./chunk-YOBLFWDV.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 || [],
+            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 {\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<\n  Modules extends Record<string, LogixModuleTag<any, AnyModuleShape>>,\n  E = never,\n  R = never\n>(\n  modules: Modules,\n  logic: (\n    $: { [K in keyof Modules]: ModuleHandle<Modules[K][\"shape\"]> }\n  ) => 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          get: (_target, prop) =>\n            (payload: any) =>\n              runtime.dispatch({ _tag: prop as string, payload }),\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<\n  Id extends string,\n  SSchema extends AnySchema,\n  AMap extends Record<string, AnySchema>\n>(\n  id: Id,\n  def: {\n    readonly state: SSchema\n    readonly actions: AMap\n    readonly reducers?: ReducersFromMap<SSchema, AMap>\n  }\n): LogixModuleTag<\n  Id,\n  ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>\n> {\n  const shape: ModuleShape<\n    SSchema,\n    Schema.Schema<ActionsFromMap<AMap>>,\n    AMap\n  > = {\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) => 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<\n      string,\n      (state: ShapeState, action: ShapeAction, sink?: (path: string) => void) => ShapeState\n    >)\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: (\n        api: import(\"./core/module.js\").BoundApi<typeof shape, R>\n      ) => 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(\n          LogicDiagnostics.LogicUnitServiceTag,\n        ).pipe(Effect.map(Option.getOrUndefined))\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 = (\n          value: unknown\n        ): value is import(\"./core/module.js\").LogicPlan<typeof shape, R, E> =>\n          Boolean(\n            value &&\n            typeof value === \"object\" &&\n            \"setup\" in (value as any) &&\n            \"run\" in (value as any)\n          )\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<\n        import(\"./core/module.js\").ModuleRuntime<\n          StateOf<typeof shape>,\n          ActionOf<typeof shape>\n        >,\n        E,\n        R\n      > =>\n\t      Layer.scoped(\n\t        tag,\n\t        ModuleRuntimeImpl.make<StateOf<typeof shape>, ActionOf<typeof shape>, R>(\n\t          initial,\n\t          {\n            tag,\n            logics: logics as ReadonlyArray<Effect.Effect<any, any, any>>,\n            moduleId: id,\n            reducers,\n\t          },\n\t        ),\n\t      ) as unknown as Layer.Layer<\n\t        import(\"./core/module.js\").ModuleRuntime<\n\t          StateOf<typeof shape>,\n\t          ActionOf<typeof shape>\n\t        >,\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<\n        Layer.Layer<any, any, any> | ModuleImpl<any, AnyModuleShape, any>\n      >\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<\n      Id,\n      ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>,\n      R\n      > => {\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>)\n              .module as unknown as Context.Tag<any, import(\"./core/module.js\").ModuleRuntime<any, any>>,\n          ]\n        }\n        return []\n      })\n\n\t      const baseLayer = Layer.scoped(\n\t        tag,\n\t        ModuleRuntimeImpl.make<StateOf<typeof shape>, ActionOf<typeof shape>, R>(\n\t          config.initial,\n\t          {\n            tag,\n            logics: (config.logics || []) as ReadonlyArray<Effect.Effect<any, any, any>>,\n            moduleId: id,\n            imports: importedModules,\n            reducers,\n            stateTransaction: config.stateTransaction,\n\t          },\n\t        ),\n\t      ) as unknown as Layer.Layer<\n\t        import(\"./core/module.js\").ModuleRuntime<\n\t          StateOf<typeof shape>,\n\t          ActionOf<typeof shape>\n\t        >,\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<\n            StateOf<typeof shape>,\n            ActionOf<typeof shape>\n          >,\n          never,\n          any\n        >,\n      ): ModuleImpl<\n        Id,\n        ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>,\n        any\n      > => ({\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<\n          Id,\n          ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>,\n          any\n        > => {\n          const provided = (layer as Layer.Layer<\n            import(\"./core/module.js\").ModuleRuntime<\n              StateOf<typeof shape>,\n              ActionOf<typeof shape>\n            >,\n            never,\n            any\n          >).pipe(\n            Layer.provide(\n              extra as Layer.Layer<any, never, any>\n            )\n          )\n\n          const merged = Layer.mergeAll(\n            provided,\n            extra as Layer.Layer<any, never, any>\n          ) as Layer.Layer<\n            import(\"./core/module.js\").ModuleRuntime<\n              StateOf<typeof shape>,\n              ActionOf<typeof shape>\n            >,\n            never,\n            any\n          >\n\n          return makeImplWithLayer(merged)\n        },\n        withLayers: (\n          ...extras: ReadonlyArray<Layer.Layer<any, never, any>>\n        ): ModuleImpl<\n          Id,\n          ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>,\n          any\n        > =>\n          extras.reduce<ModuleImpl<\n            Id,\n            ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>,\n            any\n          >>(\n            (implAcc, extra) => implAcc.withLayer(extra),\n            makeImplWithLayer(\n              layer as Layer.Layer<\n                import(\"./core/module.js\").ModuleRuntime<\n                  StateOf<typeof shape>,\n                  ActionOf<typeof shape>\n                >,\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<\n            StateOf<typeof shape>,\n            ActionOf<typeof shape>\n          >,\n          never,\n          any\n        >\n      )\n\n      const imports = config.imports ?? []\n\n      const finalImpl = imports.reduce<ModuleImpl<\n        Id,\n        ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>,\n        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<\n    Id,\n    ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>\n  >\n}\n"],
  "mappings": "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",
  "names": ["tag", "make"]
}


package/public/sandbox/chunks/{chunk-BWSNPKO5.js → chunk-LQL23SWJ.js}

@@ -1,8 +1,8 @@
-// @logixjs/core subpath bundles for @logixjs/sandbox
+// @logix/core subpath bundles for @logix/sandbox
 
 import {
   isJsonValue
-} from "./chunk-TOQ6SJ6O.js";
+} from "./chunk-S6ZZHV6G.js";
 
 // ../logix-core/src/internal/observability/evidence.ts
 var OBSERVABILITY_PROTOCOL_VERSION = "v1";

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

@@ -0,0 +1,46 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+
+// ../logix-core/src/internal/runtime/core/env.ts
+import { Context, Layer } from "../effect.js";
+var getNodeEnv = () => {
+  try {
+    const env = globalThis?.process?.env;
+    return typeof env?.NODE_ENV === "string" ? env.NODE_ENV : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var isDevEnv = () => getNodeEnv() !== "production";
+var getDefaultStateTxnInstrumentation = () => isDevEnv() ? "full" : "light";
+var StateTransactionConfigTagImpl = class extends Context.Tag("@logix/core/StateTransactionRuntimeConfig")() {
+};
+var StateTransactionConfigTag = StateTransactionConfigTagImpl;
+var ReadQueryStrictGateConfigTagImpl = class extends Context.Tag("@logix/core/ReadQueryStrictGateRuntimeConfig")() {
+};
+var ReadQueryStrictGateConfigTag = ReadQueryStrictGateConfigTagImpl;
+var ReplayModeConfigTagImpl = class extends Context.Tag("@logix/core/ReplayModeConfig")() {
+};
+var ReplayModeConfigTag = ReplayModeConfigTagImpl;
+var StateTransactionOverridesTagImpl = class extends Context.Tag("@logix/core/StateTransactionOverrides")() {
+};
+var StateTransactionOverridesTag = StateTransactionOverridesTagImpl;
+var ConcurrencyPolicyTagImpl = class extends Context.Tag("@logix/core/ConcurrencyPolicy")() {
+};
+var ConcurrencyPolicyTag = ConcurrencyPolicyTagImpl;
+var ConcurrencyPolicyOverridesTagImpl = class extends Context.Tag("@logix/core/ConcurrencyPolicyOverrides")() {
+};
+var ConcurrencyPolicyOverridesTag = ConcurrencyPolicyOverridesTagImpl;
+
+export {
+  getNodeEnv,
+  isDevEnv,
+  getDefaultStateTxnInstrumentation,
+  StateTransactionConfigTag,
+  ReadQueryStrictGateConfigTag,
+  ReplayModeConfigTag,
+  StateTransactionOverridesTag,
+  ConcurrencyPolicyTag,
+  ConcurrencyPolicyOverridesTag
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/env.ts"],
  "sourcesContent": ["import { Context, Layer } from 'effect'\nimport type { TraitConvergeRequestedMode } from '../../state-trait/model.js'\nimport type { ReadQueryStrictGateConfig } from './ReadQuery.js'\n\n// \u7EDF\u4E00\u7684\u8FD0\u884C\u65F6\u73AF\u5883\u68C0\u6D4B\uFF0C\u907F\u514D bundler \u5728\u6784\u5EFA\u671F\u5185\u8054 NODE_ENV\u3002\nexport const getNodeEnv = (): string | undefined => {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const env = (globalThis as any)?.process?.env\n    return typeof env?.NODE_ENV === 'string' ? env.NODE_ENV : undefined\n  } catch {\n    return undefined\n  }\n}\n\nexport const isDevEnv = (): boolean => getNodeEnv() !== 'production'\n\nexport type StateTransactionInstrumentation = 'full' | 'light'\n\n/**\n * getDefaultStateTxnInstrumentation\uFF1A\n * - \u5F53\u524D\u7B80\u5355\u6309 NODE_ENV \u9009\u62E9\u9ED8\u8BA4\u89C2\u6D4B\u5F3A\u5EA6\uFF1A\n *   - dev / test\uFF1Afull\uFF08\u4FDD\u7559 Patch \u4E0E\u5FEB\u7167\uFF0C\u4FBF\u4E8E\u8C03\u8BD5\uFF09\uFF1B\n *   - production\uFF1Alight\uFF08\u4EC5\u4FDD\u7559\u6700\u5C0F\u8BED\u4E49\uFF0C\u4FBF\u4E8E\u51CF\u5C11\u5F00\u9500\uFF09\u3002\n * - \u540E\u7EED\u53EF\u5728 Runtime.make / Module.make \u4E0A\u63D0\u4F9B\u66F4\u7EC6\u7C92\u5EA6\u7684\u8986\u5199\u5165\u53E3\u3002\n */\nexport const getDefaultStateTxnInstrumentation = (): StateTransactionInstrumentation => (isDevEnv() ? 'full' : 'light')\n\n/**\n * Runtime \u7EA7 StateTransaction \u914D\u7F6E Service\uFF1A\n * - \u7531 Logix.Runtime.make / AppRuntime.makeApp \u5728 App \u7EA7 Layer \u4E2D\u63D0\u4F9B\uFF1B\n * - ModuleRuntime.make \u53EF\u4EE5\u4ECE Env \u4E2D\u8BFB\u53D6 runtime \u7EA7\u9ED8\u8BA4\u89C2\u6D4B\u7B56\u7565\u3002\n *\n * \u8BF4\u660E\uFF1A\n * - instrumentation \u4EC5\u4F5C\u4E3A Runtime \u7EA7\u9ED8\u8BA4\u503C\uFF1B\n * - ModuleImpl / ModuleRuntimeOptions \u4E2D\u663E\u5F0F\u58F0\u660E\u7684 instrumentation \u5177\u6709\u66F4\u9AD8\u4F18\u5148\u7EA7\u3002\n */\nexport interface StateTransactionRuntimeConfig {\n  readonly instrumentation?: StateTransactionInstrumentation\n  /**\n   * StateTrait \u6D3E\u751F\u6536\u655B\uFF08converge\uFF09\u9884\u7B97\uFF08ms\uFF09\uFF1A\n   * - \u8D85\u8FC7\u9884\u7B97\u5C06\u89E6\u53D1\u8F6F\u964D\u7EA7\uFF08\u51BB\u7ED3\u6D3E\u751F\u5B57\u6BB5\uFF0C\u4FDD\u4F4F base \u5199\u5165\u4E0E 0/1 commit \u8BED\u4E49\uFF09\u3002\n   * - \u9ED8\u8BA4\u4E3A 200ms\uFF08\u4E0E 007 spec \u7684\u9ED8\u8BA4\u9608\u503C\u4FDD\u6301\u4E00\u81F4\uFF09\u3002\n   */\n  readonly traitConvergeBudgetMs?: number\n  /**\n   * Auto \u6A21\u5F0F\u51B3\u7B56\u9884\u7B97\uFF08ms\uFF09\uFF1A\n   * - \u4EC5\u7528\u4E8E requestedMode=\"auto\" \u7684\u51B3\u7B56\u9636\u6BB5\uFF1B\n   * - \u8D85\u8FC7\u9884\u7B97\u5FC5\u987B\u7ACB\u5373\u56DE\u9000 full\uFF08\u5E76\u5199\u5165\u8BC1\u636E\uFF09\u3002\n   */\n  readonly traitConvergeDecisionBudgetMs?: number\n  /**\n   * StateTrait converge \u8C03\u5EA6\u7B56\u7565\uFF1A\n   * - full\uFF1A\u5168\u91CF topo \u6267\u884C\uFF08\u5F53\u524D\u9ED8\u8BA4\uFF0C\u6700\u7A33\u59A5\uFF09\uFF1B\n   * - dirty\uFF1A\u57FA\u4E8E\u4E8B\u52A1\u7A97\u53E3\u5185 dirtyPaths + deps \u505A\u6700\u5C0F\u89E6\u53D1\uFF08\u8981\u6C42 deps \u51C6\u786E\uFF09\u3002\n   */\n  readonly traitConvergeMode?: TraitConvergeRequestedMode\n  /**\n   * 043\uFF1ATrait converge time-slicing\uFF08\u663E\u5F0F opt-in\uFF09\u3002\u9ED8\u8BA4\u5173\u95ED\u3002\n   */\n  readonly traitConvergeTimeSlicing?: TraitConvergeTimeSlicingPatch\n  /**\n   * 060\uFF1ATxn Lanes\uFF08\u4E8B\u52A1\u540E\u7EED\u5DE5\u4F5C\u4F18\u5148\u7EA7\u8C03\u5EA6\uFF09\u3002062 \u8D77\u9ED8\u8BA4\u5F00\u542F\u3002\n   */\n  readonly txnLanes?: TxnLanesPatch\n  /**\n   * Runtime \u7EA7 moduleId \u8986\u76D6\uFF08\u6B62\u8840\u8DEF\u5F84\uFF09\uFF1A\n   * - \u4EC5\u5F71\u54CD\u6307\u5B9A moduleId \u7684 converge \u884C\u4E3A\uFF1B\n   * - \u4F18\u5148\u7EA7\u4F4E\u4E8E Provider override\u3002\n   */\n  readonly traitConvergeOverridesByModuleId?: Readonly<Record<string, StateTransactionTraitConvergeOverrides>>\n  /**\n   * 060\uFF1ATxn Lanes \u7684 runtime_module \u8986\u76D6\uFF08\u6B62\u8840/\u7070\u5EA6\u8C03\u53C2\uFF09\u3002\n   * - \u4EC5\u5F71\u54CD\u6307\u5B9A moduleId\uFF1B\n   * - \u4F18\u5148\u7EA7\u4F4E\u4E8E Provider override\u3002\n   */\n  readonly txnLanesOverridesByModuleId?: Readonly<Record<string, TxnLanesPatch>>\n}\n\nclass StateTransactionConfigTagImpl extends Context.Tag('@logix/core/StateTransactionRuntimeConfig')<\n  StateTransactionConfigTagImpl,\n  StateTransactionRuntimeConfig\n>() {}\n\nexport const StateTransactionConfigTag = StateTransactionConfigTagImpl\n\nexport type ReadQueryStrictGateRuntimeConfig = ReadQueryStrictGateConfig\n\nclass ReadQueryStrictGateConfigTagImpl extends Context.Tag('@logix/core/ReadQueryStrictGateRuntimeConfig')<\n  ReadQueryStrictGateConfigTagImpl,\n  ReadQueryStrictGateRuntimeConfig\n>() {}\n\nexport const ReadQueryStrictGateConfigTag = ReadQueryStrictGateConfigTagImpl\n\nexport type ReplayMode = 'live' | 'replay'\n\nexport interface ReplayModeConfig {\n  readonly mode: ReplayMode\n}\n\nclass ReplayModeConfigTagImpl extends Context.Tag('@logix/core/ReplayModeConfig')<\n  ReplayModeConfigTagImpl,\n  ReplayModeConfig\n>() {}\n\nexport const ReplayModeConfigTag = ReplayModeConfigTagImpl\n\nexport const replayModeLayer = (mode: ReplayMode): Layer.Layer<ReplayModeConfigTagImpl, never, never> =>\n  Layer.succeed(ReplayModeConfigTag, { mode })\n\nexport interface StateTransactionTraitConvergeOverrides {\n  readonly traitConvergeMode?: TraitConvergeRequestedMode\n  readonly traitConvergeBudgetMs?: number\n  readonly traitConvergeDecisionBudgetMs?: number\n  readonly traitConvergeTimeSlicing?: TraitConvergeTimeSlicingPatch\n}\n\nexport interface TxnLanesPatch {\n  /**\n   * enabled\uFF1A\u662F\u5426\u542F\u7528 Txn Lanes\uFF08062 \u9ED8\u8BA4\u5F00\u542F\uFF09\u3002\n   * - undefined\uFF1A\u9ED8\u8BA4\u5F00\u542F\uFF08\u4E0D\u663E\u5F0F\u914D\u7F6E\u65F6\u751F\u6548\uFF09\n   * - false\uFF1A\u5173\u95ED\uFF08\u56DE\u5230 baseline \u884C\u4E3A\uFF09\n   * - true\uFF1A\u542F\u7528 Txn Lanes\uFF08\u53EA\u5F71\u54CD\u4E8B\u52A1\u5916 follow-up work \u7684\u8C03\u5EA6\uFF1B\u4E8B\u52A1\u4ECD\u540C\u6B65\u4E0D\u53EF\u4E2D\u65AD\uFF09\n   */\n  readonly enabled?: boolean\n  /**\n   * overrideMode\uFF1A\u8FD0\u884C\u671F\u4E34\u65F6\u8986\u76D6\uFF08\u7528\u4E8E\u6392\u67E5/\u56DE\u9000/\u5BF9\u7167\uFF09\u3002\n   * - forced_off\uFF1A\u5F3A\u5236\u5173\u95ED Txn Lanes \u7B56\u7565\uFF08\u56DE\u5230 baseline \u884C\u4E3A\uFF09\u3002\n   * - forced_sync\uFF1A\u5F3A\u5236\u5168\u540C\u6B65\uFF08\u5FFD\u7565 non-urgent \u5EF6\u540E\u4E0E time-slicing\uFF1B\u7528\u4E8E\u5BF9\u7167\u9A8C\u8BC1\u5DEE\u5F02\uFF09\u3002\n   *\n   * \u8BF4\u660E\uFF1A\n   * - \u8986\u76D6\u4F18\u5148\u7EA7\u9075\u5FAA StateTransactionOverrides \u89C4\u5219\uFF1Aprovider > runtime_module > runtime_default > builtin\u3002\n   * - \u8986\u76D6\u672C\u8EAB\u5FC5\u987B\u53EF\u88AB\u8BC1\u636E\u89E3\u91CA\uFF08\u89C1 060 LaneEvidence reasons\uFF09\u3002\n   */\n  readonly overrideMode?: 'forced_off' | 'forced_sync'\n  /** non-urgent work loop \u5355\u7247\u9884\u7B97\uFF08ms\uFF09\u3002 */\n  readonly budgetMs?: number\n  /** \u975E\u7D27\u6025 backlog \u7684\u5408\u5E76\u7A97\u53E3\uFF08ms\uFF09\u3002 */\n  readonly debounceMs?: number\n  /** \u6700\u5927\u6EDE\u540E\u4E0A\u754C\uFF08ms\uFF09\uFF1A\u8D85\u8FC7\u5FC5\u987B\u89E6\u53D1\u53EF\u89E3\u91CA\u7684\u9965\u997F\u4FDD\u62A4\uFF08\u5F3A\u5236\u8FFD\u5E73\uFF09\u3002 */\n  readonly maxLagMs?: number\n  /** \u662F\u5426\u5141\u8BB8\u5408\u5E76/\u53D6\u6D88\u4E2D\u95F4\u6001 non-urgent work\uFF08\u5FC5\u987B\u4FDD\u6301\u6700\u7EC8\u4E00\u81F4\u6027\uFF09\u3002 */\n  readonly allowCoalesce?: boolean\n  /**\n   * non-urgent work loop \u7684\u8BA9\u8DEF\u5224\u5B9A\u7B56\u7565\uFF08\u6E10\u8FDB\u589E\u5F3A\uFF09\u3002\n   * - baseline\uFF1A\u4EC5\u4F7F\u7528\u65F6\u95F4\u9884\u7B97 + \u786C\u4E0A\u754C\n   * - inputPending\uFF1A\u5728\u652F\u6301\u7684\u6D4F\u89C8\u5668\u73AF\u5883\u4E0B\uFF0C\u989D\u5916\u53C2\u8003 `navigator.scheduling.isInputPending`\n   */\n  readonly yieldStrategy?: 'baseline' | 'inputPending'\n}\n\nexport interface TraitConvergeTimeSlicingPatch {\n  /**\n   * enabled\uFF1A\n   * - false/undefined\uFF1A\u5173\u95ED\uFF08\u9ED8\u8BA4\uFF09\n   * - true\uFF1A\u542F\u7528 time-slicing\uFF08\u4EC5\u5BF9\u663E\u5F0F\u6807\u8BB0\u4E3A deferred \u7684 computed/link \u751F\u6548\uFF09\n   */\n  readonly enabled?: boolean\n  /**\n   * debounceMs\uFF1A\u5EF6\u8FDF\u7A97\u53E3\u7684\u5408\u5E76\u95F4\u9694\uFF08ms\uFF09\uFF0C\u7528\u4E8E\u628A\u9AD8\u9891\u8F93\u5165\u5408\u5E76\u4E3A\u4E00\u6B21 deferred flush\u3002\n   */\n  readonly debounceMs?: number\n  /**\n   * maxLagMs\uFF1A\u6700\u5927\u6EDE\u540E\u4E0A\u754C\uFF08ms\uFF09\uFF0C\u8D85\u8FC7\u4E0A\u754C\u5FC5\u987B\u89E6\u53D1\u4E00\u6B21\u53EF\u89E3\u91CA\u7684\u5F3A\u5236 flush\uFF08\u9965\u997F\u4FDD\u62A4\uFF09\u3002\n   */\n  readonly maxLagMs?: number\n}\n\n/**\n * Provider \u8303\u56F4\u7684 StateTransactionOverrides\uFF08\u5DEE\u91CF\u8986\u76D6\uFF09\uFF1A\n * - \u7528\u4E8E\u5728\u7EE7\u627F\u5168\u5C40 runtime \u914D\u7F6E\u7684\u57FA\u7840\u4E0A\uFF0C\u6309 Provider \u5B50\u6811\u6CE8\u5165\u66F4\u5C40\u90E8\u7684\u8986\u76D6\uFF1B\n * - \u8986\u76D6\u89E3\u6790\u4F18\u5148\u7EA7\uFF1Aprovider > runtime_module > runtime_default > builtin\u3002\n */\nexport interface StateTransactionOverrides {\n  readonly traitConvergeMode?: TraitConvergeRequestedMode\n  readonly traitConvergeBudgetMs?: number\n  readonly traitConvergeDecisionBudgetMs?: number\n  readonly traitConvergeTimeSlicing?: TraitConvergeTimeSlicingPatch\n  readonly traitConvergeOverridesByModuleId?: Readonly<Record<string, StateTransactionTraitConvergeOverrides>>\n  /** 060\uFF1ATxn Lanes provider \u7EA7\u8986\u76D6\uFF08\u5DEE\u91CF\u8986\u76D6\uFF09\u3002 */\n  readonly txnLanes?: TxnLanesPatch\n  /** 060\uFF1ATxn Lanes provider_module \u8986\u76D6\uFF08\u6309 moduleId \u8986\u5199\uFF09\u3002 */\n  readonly txnLanesOverridesByModuleId?: Readonly<Record<string, TxnLanesPatch>>\n}\n\nclass StateTransactionOverridesTagImpl extends Context.Tag('@logix/core/StateTransactionOverrides')<\n  StateTransactionOverridesTagImpl,\n  StateTransactionOverrides\n>() {}\n\nexport const StateTransactionOverridesTag = StateTransactionOverridesTagImpl\n\nexport type ConcurrencyLimit = number | 'unbounded'\n\nexport interface ConcurrencyPolicyPatch {\n  readonly concurrencyLimit?: ConcurrencyLimit\n  readonly losslessBackpressureCapacity?: number\n  readonly allowUnbounded?: boolean\n  readonly pressureWarningThreshold?: {\n    readonly backlogCount?: number\n    readonly backlogDurationMs?: number\n  }\n  readonly warningCooldownMs?: number\n}\n\n/**\n * Runtime \u7EA7 ConcurrencyPolicy\uFF1A\n * - \u7531 Logix.Runtime.make / AppRuntime.makeApp \u5728 App \u7EA7 Layer \u4E2D\u63D0\u4F9B\uFF1B\n * - ModuleRuntime \u901A\u8FC7 resolver \u5408\u5E76 builtin/runtime_module/provider \u7B49\u6765\u6E90\u3002\n *\n * \u8BF4\u660E\uFF1A\n * - overridesByModuleId \u7528\u4E8E runtime_module \u70ED\u5207\u6362\uFF08\u6B62\u8840/\u7070\u5EA6\u8C03\u53C2\uFF09\uFF0C\u4F18\u5148\u7EA7\u4F4E\u4E8E provider overrides\u3002\n */\nexport interface ConcurrencyPolicy extends ConcurrencyPolicyPatch {\n  readonly overridesByModuleId?: Readonly<Record<string, ConcurrencyPolicyPatch>>\n}\n\nclass ConcurrencyPolicyTagImpl extends Context.Tag('@logix/core/ConcurrencyPolicy')<\n  ConcurrencyPolicyTagImpl,\n  ConcurrencyPolicy\n>() {}\n\nexport const ConcurrencyPolicyTag = ConcurrencyPolicyTagImpl\n\n/**\n * Provider \u8303\u56F4\u7684 ConcurrencyPolicyOverrides\uFF08\u5DEE\u91CF\u8986\u76D6\uFF09\uFF1A\n * - \u7528\u4E8E\u5728\u7EE7\u627F\u5168\u5C40 runtime \u914D\u7F6E\u7684\u57FA\u7840\u4E0A\uFF0C\u6309 Provider \u5B50\u6811\u6CE8\u5165\u66F4\u5C40\u90E8\u7684\u8986\u76D6\uFF1B\n * - \u8986\u76D6\u89E3\u6790\u4F18\u5148\u7EA7\uFF1Aprovider > runtime_module > runtime_default > builtin\u3002\n */\nexport interface ConcurrencyPolicyOverrides extends ConcurrencyPolicyPatch {\n  readonly overridesByModuleId?: Readonly<Record<string, ConcurrencyPolicyPatch>>\n}\n\nclass ConcurrencyPolicyOverridesTagImpl extends Context.Tag('@logix/core/ConcurrencyPolicyOverrides')<\n  ConcurrencyPolicyOverridesTagImpl,\n  ConcurrencyPolicyOverrides\n>() {}\n\nexport const ConcurrencyPolicyOverridesTag = ConcurrencyPolicyOverridesTagImpl\n"],
  "mappings": ";;;;AAAA,SAAS,SAAS,aAAa;AAKxB,IAAM,aAAa,MAA0B;AAClD,MAAI;AAEF,UAAM,MAAO,YAAoB,SAAS;AAC1C,WAAO,OAAO,KAAK,aAAa,WAAW,IAAI,WAAW;AAAA,EAC5D,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEO,IAAM,WAAW,MAAe,WAAW,MAAM;AAWjD,IAAM,oCAAoC,MAAwC,SAAS,IAAI,SAAS;AAqD/G,IAAM,gCAAN,cAA4C,QAAQ,IAAI,2CAA2C,EAGjG,EAAE;AAAC;AAEE,IAAM,4BAA4B;AAIzC,IAAM,mCAAN,cAA+C,QAAQ,IAAI,8CAA8C,EAGvG,EAAE;AAAC;AAEE,IAAM,+BAA+B;AAQ5C,IAAM,0BAAN,cAAsC,QAAQ,IAAI,8BAA8B,EAG9E,EAAE;AAAC;AAEE,IAAM,sBAAsB;AAgFnC,IAAM,mCAAN,cAA+C,QAAQ,IAAI,uCAAuC,EAGhG,EAAE;AAAC;AAEE,IAAM,+BAA+B;AA2B5C,IAAM,2BAAN,cAAuC,QAAQ,IAAI,+BAA+B,EAGhF,EAAE;AAAC;AAEE,IAAM,uBAAuB;AAWpC,IAAM,oCAAN,cAAgD,QAAQ,IAAI,wCAAwC,EAGlG,EAAE;AAAC;AAEE,IAAM,gCAAgC;",
  "names": []
}
