@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,732 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  LifecycleContext,
+  makeLogicPhaseError
+} from "./chunk-YOBLFWDV.js";
+import {
+  create
+} from "./chunk-Y5I45PEB.js";
+import {
+  inSyncTransactionFiber,
+  makeTaskRunner
+} from "./chunk-E7BIWMQQ.js";
+import {
+  Tag
+} from "./chunk-ZWE3P6X2.js";
+import {
+  getRuntimeInternals,
+  setBoundInternals
+} from "./chunk-6FKWRVP4.js";
+import {
+  isDevEnv
+} from "./chunk-GP37MEGJ.js";
+import {
+  make
+} from "./chunk-LTWLVCKQ.js";
+import {
+  RunSessionTag
+} from "./chunk-RS5FFPUV.js";
+import {
+  currentDiagnosticsLevel,
+  record
+} from "./chunk-CVZPRIDB.js";
+import {
+  makeMatch,
+  makeMatchTag
+} from "./chunk-3U4CAKCX.js";
+
+// ../logix-core/src/internal/runtime/core/mutativePatches.ts
+var toPatchPathString = (path) => {
+  if (typeof path === "string") {
+    const trimmed = path.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  }
+  if (!Array.isArray(path)) return void 0;
+  const parts = [];
+  for (const seg of path) {
+    if (typeof seg === "string") {
+      if (seg.length > 0) parts.push(seg);
+      continue;
+    }
+    if (typeof seg === "number" && Number.isFinite(seg)) {
+      parts.push(String(Math.floor(seg)));
+      continue;
+    }
+  }
+  if (parts.length === 0) return "*";
+  return parts.join(".");
+};
+var mutateWithPatchPaths = (base, mutator) => {
+  const out = create(base, mutator, {
+    enablePatches: {
+      pathAsArray: true,
+      arrayLengthAssignment: false
+    }
+  });
+  if (!Array.isArray(out)) {
+    return { nextState: out, patchPaths: [] };
+  }
+  const nextState = out[0];
+  const patches = out[1] ?? [];
+  const set = /* @__PURE__ */ new Set();
+  for (const patch of patches) {
+    const p = toPatchPathString(patch?.path);
+    if (!p) continue;
+    set.add(p);
+  }
+  return {
+    nextState,
+    patchPaths: Array.from(set)
+  };
+};
+
+// ../logix-core/src/internal/runtime/BoundApiRuntime.ts
+import { Context, Effect, FiberRef, Option, Schema, Stream } from "../effect.js";
+var LogicBuilderFactory = (runtime, runtimeInternals) => {
+  const flowApi = make(runtime, runtimeInternals);
+  return (stream, triggerName) => {
+    const runWithStateTransaction = (origin, body) => runtimeInternals.txn.runWithStateTransaction(origin, body);
+    const taskRunnerRuntime = {
+      moduleId: runtime.moduleId,
+      instanceId: runtimeInternals.instanceId,
+      runWithStateTransaction,
+      resolveConcurrencyPolicy: runtimeInternals.concurrency.resolveConcurrencyPolicy
+    };
+    const builder = {
+      debounce: (ms) => LogicBuilderFactory(runtime, runtimeInternals)(
+        flowApi.debounce(ms)(stream),
+        triggerName
+      ),
+      throttle: (ms) => LogicBuilderFactory(runtime, runtimeInternals)(
+        flowApi.throttle(ms)(stream),
+        triggerName
+      ),
+      filter: (predicate) => LogicBuilderFactory(runtime, runtimeInternals)(
+        flowApi.filter(predicate)(stream),
+        triggerName
+      ),
+      map: (f) => LogicBuilderFactory(runtime, runtimeInternals)(
+        stream.pipe(Stream.map(f)),
+        triggerName
+      ),
+      run(eff, options) {
+        return flowApi.run(eff, options)(stream);
+      },
+      runLatest(eff, options) {
+        return flowApi.runLatest(eff, options)(stream);
+      },
+      runExhaust(eff, options) {
+        return flowApi.runExhaust(eff, options)(stream);
+      },
+      runParallel(eff, options) {
+        return flowApi.runParallel(eff, options)(stream);
+      },
+      runFork: (eff) => Effect.forkScoped(flowApi.run(eff)(stream)).pipe(
+        Effect.asVoid
+      ),
+      runParallelFork: (eff) => Effect.forkScoped(
+        flowApi.runParallel(eff)(stream)
+      ).pipe(
+        Effect.asVoid
+      ),
+      runTask: (config) => makeTaskRunner(
+        stream,
+        "task",
+        taskRunnerRuntime,
+        {
+          ...config,
+          triggerName: config.triggerName ?? triggerName
+        }
+      ),
+      runParallelTask: (config) => makeTaskRunner(
+        stream,
+        "parallel",
+        taskRunnerRuntime,
+        {
+          ...config,
+          triggerName: config.triggerName ?? triggerName
+        }
+      ),
+      runLatestTask: (config) => makeTaskRunner(
+        stream,
+        "latest",
+        taskRunnerRuntime,
+        {
+          ...config,
+          triggerName: config.triggerName ?? triggerName
+        }
+      ),
+      runExhaustTask: (config) => makeTaskRunner(
+        stream,
+        "exhaust",
+        taskRunnerRuntime,
+        {
+          ...config,
+          triggerName: config.triggerName ?? triggerName
+        }
+      ),
+      toStream: () => stream,
+      update: (reducer) => Stream.runForEach(
+        stream,
+        (payload) => taskRunnerRuntime.runWithStateTransaction(
+          {
+            kind: "watcher:update",
+            name: triggerName
+          },
+          () => Effect.gen(function* () {
+            const prev = yield* runtime.getState;
+            const next = reducer(prev, payload);
+            if (Effect.isEffect(next)) {
+              const exit = yield* Effect.exit(
+                next
+              );
+              if (exit._tag === "Failure") {
+                yield* Effect.logError("Flow error", exit.cause);
+                return;
+              }
+              yield* runtime.setState(exit.value);
+              return;
+            }
+            yield* runtime.setState(next);
+          })
+        )
+      ).pipe(
+        Effect.catchAllCause(
+          (cause) => Effect.logError("Flow error", cause)
+        )
+      ),
+      mutate: (reducer) => Stream.runForEach(
+        stream,
+        (payload) => taskRunnerRuntime.runWithStateTransaction(
+          {
+            kind: "watcher:mutate",
+            name: triggerName
+          },
+          () => Effect.gen(function* () {
+            const prev = yield* runtime.getState;
+            const recordPatch = runtimeInternals?.txn.recordStatePatch;
+            const { nextState, patchPaths } = mutateWithPatchPaths(
+              prev,
+              (draft) => {
+                reducer(draft, payload);
+              }
+            );
+            for (const path of patchPaths) {
+              recordPatch?.({
+                path,
+                reason: "watcher:mutate"
+              });
+            }
+            yield* runtime.setState(nextState);
+          })
+        )
+      ).pipe(
+        Effect.catchAllCause(
+          (cause) => Effect.logError("Flow error", cause)
+        )
+      )
+    };
+    const andThen = (handlerOrEff) => {
+      if (typeof handlerOrEff === "function") {
+        if (handlerOrEff.length >= 2) {
+          return builder.update(handlerOrEff);
+        }
+        return builder.run(handlerOrEff);
+      }
+      return builder.run(handlerOrEff);
+    };
+    const pipe = function() {
+      const fns = arguments;
+      let acc = builder;
+      for (let i = 0; i < fns.length; i++) {
+        acc = fns[i](acc);
+      }
+      return acc;
+    };
+    return Object.assign(builder, { pipe, andThen });
+  };
+};
+function make2(shape, runtime, options) {
+  const runtimeInternals = getRuntimeInternals(runtime);
+  const getPhase = options?.getPhase ?? (() => "run");
+  const getCurrentPhase = () => {
+    const phaseService = options?.phaseService;
+    const phase = phaseService?.current ?? getPhase();
+    return phase === "setup" ? "setup" : "run";
+  };
+  const guardRunOnly = (kind, api2) => {
+    const phaseService = options?.phaseService;
+    const phase = phaseService?.current ?? getPhase();
+    if (phase === "setup") {
+      throw makeLogicPhaseError(
+        kind,
+        api2,
+        "setup",
+        options?.moduleId
+      );
+    }
+  };
+  const flowApi = make(runtime, runtimeInternals);
+  const makeIntentBuilder = (runtime_) => LogicBuilderFactory(runtime_, runtimeInternals);
+  const withLifecycle = (available, missing) => Effect.serviceOption(LifecycleContext).pipe(
+    Effect.flatMap(
+      (maybe) => Option.match(maybe, {
+        onSome: available,
+        onNone: missing
+      })
+    )
+  );
+  const withPlatform = (invoke) => Effect.serviceOption(Tag).pipe(
+    Effect.flatMap(
+      (maybe) => Option.match(maybe, {
+        onSome: invoke,
+        onNone: () => Effect.void
+      })
+    )
+  );
+  const emitSetupOnlyViolation = (api2) => record({
+    type: "diagnostic",
+    moduleId: runtime.moduleId,
+    instanceId: runtime.instanceId,
+    code: "logic::invalid_phase",
+    severity: "error",
+    message: `${api2} is setup-only and is not allowed in run phase.`,
+    hint: "\u5C06 $.lifecycle.* \u8C03\u7528\u79FB\u52A8\u5230 Module.logic builder \u7684\u540C\u6B65\u90E8\u5206\uFF08return \u4E4B\u524D\uFF09\u7528\u4E8E\u6CE8\u518C\uFF1Brun \u6BB5\u9700\u8981\u52A8\u6001\u8D44\u6E90\u6E05\u7406\u65F6\uFF0C\u8BF7\u4F7F\u7528 Effect.acquireRelease / Scope finalizer\uFF0C\u800C\u4E0D\u662F late \u6CE8\u518C onDestroy\u3002",
+    kind: "lifecycle_in_run"
+  });
+  const createIntentBuilder = (stream, triggerName) => makeIntentBuilder(runtime)(stream, triggerName);
+  const onceInRunSession = (key) => Effect.serviceOption(RunSessionTag).pipe(
+    Effect.map(
+      (maybe) => Option.isSome(maybe) ? maybe.value.local.once(key) : true
+    )
+  );
+  let cachedDiagnosticsLevel;
+  const isModuleLike = (value) => Boolean(
+    value && typeof value === "object" && ((value._kind === "ModuleDef" || value._kind === "Module") && "tag" in value) && Context.isTag(value.tag)
+  );
+  const buildModuleHandle = (tag, rt) => {
+    const actionsProxy = new Proxy(
+      {},
+      {
+        get: (_target, prop) => (payload) => rt.dispatch({
+          _tag: prop,
+          payload
+        })
+      }
+    );
+    const handle = {
+      read: (selector) => Effect.map(rt.getState, selector),
+      changes: rt.changes,
+      dispatch: rt.dispatch,
+      actions$: rt.actions$,
+      actions: actionsProxy
+    };
+    const EXTEND_HANDLE = /* @__PURE__ */ Symbol.for("logix.module.handle.extend");
+    const extend = tag?.[EXTEND_HANDLE];
+    return typeof extend === "function" ? extend(rt, handle) ?? handle : handle;
+  };
+  const emitModuleDescriptorOnce = (module, rt) => Effect.gen(function* () {
+    if (cachedDiagnosticsLevel === "off") return;
+    const key = `module_descriptor:${String(rt.instanceId ?? "unknown")}`;
+    const shouldEmit = yield* onceInRunSession(key);
+    if (!shouldEmit) return;
+    const actionKeys = Object.keys(module.tag?.shape?.actionMap ?? {});
+    const internalSymbol = /* @__PURE__ */ Symbol.for("logix.module.internal");
+    const internal = module[internalSymbol];
+    const logicUnits = (internal?.mounted ?? []).map((u) => ({
+      kind: String(u?.kind ?? "user"),
+      id: String(u?.id ?? ""),
+      derived: u?.derived ? true : void 0,
+      name: typeof u?.name === "string" ? u.name : void 0
+    }));
+    const schemaKeys = module.schemas && typeof module.schemas === "object" ? Object.keys(module.schemas) : void 0;
+    const meta = module.meta && typeof module.meta === "object" ? module.meta : void 0;
+    const source = module.dev?.source;
+    const traitsSnapshot = runtimeInternals.traits.getModuleTraitsSnapshot();
+    const traits = traitsSnapshot ? {
+      digest: traitsSnapshot.digest,
+      count: traitsSnapshot.traits.length
+    } : void 0;
+    const data = {
+      id: module.id,
+      moduleId: String(rt.moduleId),
+      instanceId: String(rt.instanceId),
+      actionKeys,
+      logicUnits,
+      schemaKeys,
+      meta,
+      source,
+      traits
+    };
+    yield* record({
+      type: "trace:module:descriptor",
+      moduleId: rt.moduleId,
+      instanceId: rt.instanceId,
+      data
+    });
+  });
+  const resolveModuleRuntime = (tag) => Effect.gen(function* () {
+    const requestedModuleId = typeof tag?.id === "string" ? tag.id : void 0;
+    const fromModuleId = typeof options?.moduleId === "string" ? options.moduleId : void 0;
+    const fromEnv = yield* Effect.serviceOption(tag);
+    if (Option.isSome(fromEnv)) {
+      return fromEnv.value;
+    }
+    const tokenId = requestedModuleId ?? "<unknown module id>";
+    const fix = isDevEnv() ? [
+      "- Provide the child implementation in the same scope (imports).",
+      `  Example: ${fromModuleId ?? "ParentModule"}.implement({ imports: [${requestedModuleId ?? "ChildModule"}.impl], ... })`,
+      "- If you intentionally want a root singleton, provide it at app root (Runtime.make(...,{ layer }) / root imports),",
+      "  and use Root.resolve(ModuleTag) (instead of $.use) at the callsite."
+    ] : [];
+    const err = new Error(
+      isDevEnv() ? [
+        "[MissingModuleRuntimeError] Cannot resolve ModuleRuntime for ModuleTag.",
+        "",
+        `tokenId: ${tokenId}`,
+        "entrypoint: logic.$.use",
+        "mode: strict",
+        `from: ${fromModuleId ?? "<unknown module id>"}`,
+        `startScope: moduleId=${fromModuleId ?? "<unknown>"}, instanceId=${String(runtime.instanceId ?? "<unknown>")}`,
+        "",
+        "fix:",
+        ...fix
+      ].join("\n") : "[MissingModuleRuntimeError] module runtime not found"
+    );
+    err.tokenId = tokenId;
+    err.entrypoint = "logic.$.use";
+    err.mode = "strict";
+    err.from = fromModuleId;
+    err.startScope = {
+      moduleId: fromModuleId,
+      instanceId: String(runtime.instanceId ?? "<unknown>")
+    };
+    err.fix = fix;
+    err.name = "MissingModuleRuntimeError";
+    return yield* Effect.die(err);
+  });
+  const stateApi = {
+    read: runtime.getState,
+    update: (f) => Effect.gen(function* () {
+      const inTxn = yield* FiberRef.get(inSyncTransactionFiber);
+      if (inTxn) {
+        const prev = yield* runtime.getState;
+        return yield* runtime.setState(f(prev));
+      }
+      const body = () => Effect.flatMap(runtime.getState, (prev) => runtime.setState(f(prev)));
+      return yield* runtimeInternals ? runtimeInternals.txn.runWithStateTransaction(
+        { kind: "state", name: "update" },
+        body
+      ) : body();
+    }),
+    mutate: (f) => Effect.gen(function* () {
+      const recordPatch = runtimeInternals?.txn.recordStatePatch;
+      const inTxn = yield* FiberRef.get(inSyncTransactionFiber);
+      if (inTxn) {
+        const prev = yield* runtime.getState;
+        const { nextState, patchPaths } = mutateWithPatchPaths(
+          prev,
+          (draft) => {
+            f(draft);
+          }
+        );
+        for (const path of patchPaths) {
+          recordPatch?.({
+            path,
+            reason: "state:mutate"
+          });
+        }
+        return yield* runtime.setState(nextState);
+      }
+      const body = () => Effect.flatMap(runtime.getState, (prev) => {
+        const { nextState, patchPaths } = mutateWithPatchPaths(
+          prev,
+          (draft) => {
+            f(draft);
+          }
+        );
+        for (const path of patchPaths) {
+          recordPatch?.({
+            path,
+            reason: "state:mutate"
+          });
+        }
+        return runtime.setState(nextState);
+      });
+      return yield* runtimeInternals ? runtimeInternals.txn.runWithStateTransaction(
+        { kind: "state", name: "mutate" },
+        body
+      ) : body();
+    }),
+    ref: runtime.ref
+  };
+  const actionsApi = new Proxy({}, {
+    get: (_target, prop) => {
+      if (prop === "dispatch") {
+        return (a) => runtime.dispatch(a);
+      }
+      if (prop === "actions$") {
+        return runtime.actions$;
+      }
+      return (payload) => runtime.dispatch({ _tag: prop, payload });
+    }
+  });
+  const matchApi = (value) => makeMatch(value);
+  const matchTagApi = (value) => makeMatchTag(value);
+  const reducer = (tag, fn) => {
+    return Effect.sync(() => {
+      runtimeInternals.txn.registerReducer(String(tag), fn);
+    });
+  };
+  const api = {
+    state: stateApi,
+    actions: actionsApi,
+    flow: flowApi,
+    match: matchApi,
+    matchTag: matchTagApi,
+    lifecycle: {
+      onInitRequired: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onInitRequired");
+        }
+        runtimeInternals.lifecycle.registerInitRequired(eff);
+        return Effect.void;
+      },
+      onStart: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onStart");
+        }
+        runtimeInternals.lifecycle.registerStart(eff);
+        return Effect.void;
+      },
+      onInit: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onInit");
+        }
+        runtimeInternals.lifecycle.registerInitRequired(eff);
+        return Effect.void;
+      },
+      onDestroy: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onDestroy");
+        }
+        runtimeInternals.lifecycle.registerDestroy(eff);
+        return Effect.void;
+      },
+      onError: (handler) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onError");
+        }
+        runtimeInternals.lifecycle.registerOnError(handler);
+        return Effect.void;
+      },
+      onSuspend: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onSuspend");
+        }
+        runtimeInternals.lifecycle.registerPlatformSuspend(
+          Effect.asVoid(eff)
+        );
+        return Effect.void;
+      },
+      onResume: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onResume");
+        }
+        runtimeInternals.lifecycle.registerPlatformResume(
+          Effect.asVoid(eff)
+        );
+        return Effect.void;
+      },
+      onReset: (eff) => {
+        if (getCurrentPhase() === "run") {
+          return emitSetupOnlyViolation("$.lifecycle.onReset");
+        }
+        runtimeInternals.lifecycle.registerPlatformReset(
+          Effect.asVoid(eff)
+        );
+        return Effect.void;
+      }
+    },
+    traits: {
+      declare: (traits) => {
+        if (getCurrentPhase() === "run") {
+          throw makeLogicPhaseError(
+            "traits_declare_in_run",
+            "$.traits.declare",
+            "run",
+            options?.moduleId
+          );
+        }
+        if (!traits || typeof traits !== "object") {
+          throw new Error(
+            "[InvalidTraitsDeclaration] $.traits.declare expects an object."
+          );
+        }
+        const logicUnit = options?.logicUnit ?? {
+          logicUnitId: "unknown",
+          logicUnitIdKind: "derived",
+          logicUnitLabel: "logicUnit:unknown",
+          path: void 0
+        };
+        runtimeInternals.traits.registerModuleTraitsContribution({
+          traits,
+          provenance: {
+            originType: "logicUnit",
+            originId: logicUnit.logicUnitId,
+            originIdKind: logicUnit.logicUnitIdKind,
+            originLabel: logicUnit.logicUnitLabel,
+            path: logicUnit.path
+          }
+        });
+        return Effect.void;
+      },
+      source: {
+        refresh: (fieldPath) => Effect.gen(function* () {
+          const handler = runtimeInternals.traits.getSourceRefreshHandler(
+            fieldPath
+          );
+          if (!handler) {
+            return yield* Effect.void;
+          }
+          const inTxn = yield* FiberRef.get(inSyncTransactionFiber);
+          if (inTxn) {
+            const state = yield* runtime.getState;
+            return yield* handler(state);
+          }
+          return yield* runtimeInternals.txn.runWithStateTransaction(
+            {
+              kind: "source-refresh",
+              name: fieldPath
+            },
+            () => Effect.gen(function* () {
+              const state = yield* runtime.getState;
+              return yield* handler(state);
+            })
+          );
+        })
+      }
+    },
+    reducer,
+    use: new Proxy(() => {
+    }, {
+      apply: (_target, _thisArg, [arg]) => {
+        guardRunOnly("use_in_setup", "$.use");
+        if (isModuleLike(arg)) {
+          const domain = arg;
+          const tag = domain.tag;
+          const resolveAndBuild = resolveModuleRuntime(tag).pipe(
+            Effect.map((rt) => buildModuleHandle(tag, rt))
+          );
+          const resolveWithDescriptor = resolveModuleRuntime(tag).pipe(
+            Effect.tap((rt) => emitModuleDescriptorOnce(domain, rt)),
+            Effect.map((rt) => buildModuleHandle(tag, rt))
+          );
+          const detectAndSelect = FiberRef.get(currentDiagnosticsLevel).pipe(
+            Effect.tap((level) => {
+              cachedDiagnosticsLevel = level;
+            }),
+            Effect.flatMap(
+              (level) => level === "off" ? resolveAndBuild : resolveWithDescriptor
+            )
+          );
+          return Effect.suspend(() => {
+            if (cachedDiagnosticsLevel === "off") {
+              return resolveAndBuild;
+            }
+            if (cachedDiagnosticsLevel !== void 0) {
+              return resolveWithDescriptor;
+            }
+            return detectAndSelect;
+          });
+        }
+        if (Context.isTag(arg)) {
+          const candidate = arg;
+          if (candidate._kind === "ModuleTag") {
+            return resolveModuleRuntime(arg).pipe(
+              Effect.map(
+                (rt) => buildModuleHandle(arg, rt)
+              )
+            );
+          }
+          return arg;
+        }
+        return Effect.die("BoundApi.use: unsupported argument");
+      }
+    }),
+    onAction: new Proxy(() => {
+    }, {
+      apply: (_target, _thisArg, args) => {
+        guardRunOnly("use_in_setup", "$.onAction");
+        const arg = args[0];
+        if (typeof arg === "function") {
+          return createIntentBuilder(
+            runtime.actions$.pipe(Stream.filter(arg))
+          );
+        }
+        if (typeof arg === "string") {
+          return createIntentBuilder(
+            runtime.actions$.pipe(
+              Stream.filter((a) => a._tag === arg || a.type === arg)
+            ),
+            arg
+          );
+        }
+        if (typeof arg === "object" && arg !== null) {
+          if ("_tag" in arg) {
+            return createIntentBuilder(
+              runtime.actions$.pipe(
+                Stream.filter((a) => a._tag === arg._tag)
+              ),
+              String(arg._tag)
+            );
+          }
+          if (Schema.isSchema(arg)) {
+            return createIntentBuilder(
+              runtime.actions$.pipe(
+                Stream.filter((a) => {
+                  const result = Schema.decodeUnknownSync(
+                    arg
+                  )(a);
+                  return !!result;
+                })
+              )
+            );
+          }
+        }
+        return createIntentBuilder(runtime.actions$);
+      },
+      get: (_target, prop) => {
+        guardRunOnly("use_in_setup", "$.onAction");
+        if (typeof prop === "string") {
+          return createIntentBuilder(
+            runtime.actions$.pipe(
+              Stream.filter(
+                (a) => a._tag === prop || a.type === prop
+              )
+            ),
+            prop
+          );
+        }
+        return void 0;
+      }
+    }),
+    onState: (selector) => {
+      guardRunOnly("use_in_setup", "$.onState");
+      return createIntentBuilder(runtime.changes(selector));
+    },
+    on: (stream) => {
+      guardRunOnly("use_in_setup", "$.on");
+      return createIntentBuilder(stream);
+    }
+  };
+  setBoundInternals(api, runtimeInternals);
+  return api;
+}
+
+export {
+  mutateWithPatchPaths,
+  make2 as make
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/mutativePatches.ts", "../../../../logix-core/src/internal/runtime/BoundApiRuntime.ts"],
  "sourcesContent": ["import { create, type Patches } from \"mutative\"\n\nexport type PatchPath = string\n\nconst toPatchPathString = (path: unknown): PatchPath | \"*\" | undefined => {\n  if (typeof path === \"string\") {\n    const trimmed = path.trim()\n    return trimmed.length > 0 ? trimmed : undefined\n  }\n\n  if (!Array.isArray(path)) return undefined\n\n  const parts: Array<string> = []\n  for (const seg of path) {\n    if (typeof seg === \"string\") {\n      if (seg.length > 0) parts.push(seg)\n      continue\n    }\n    if (typeof seg === \"number\" && Number.isFinite(seg)) {\n      parts.push(String(Math.floor(seg)))\n      continue\n    }\n  }\n\n  if (parts.length === 0) return \"*\"\n  return parts.join(\".\")\n}\n\nexport const mutateWithPatchPaths = <S>(\n  base: S,\n  mutator: (draft: S) => void,\n): { readonly nextState: S; readonly patchPaths: ReadonlyArray<PatchPath | \"*\"> } => {\n  const out = create(base, mutator as any, {\n    enablePatches: {\n      pathAsArray: true,\n      arrayLengthAssignment: false,\n    },\n  }) as unknown\n\n  if (!Array.isArray(out)) {\n    return { nextState: out as S, patchPaths: [] }\n  }\n\n  const nextState = out[0] as S\n  const patches = (out[1] ?? []) as Patches<{ pathAsArray: true; arrayLengthAssignment: false }>\n\n  const set = new Set<PatchPath | \"*\">()\n  for (const patch of patches) {\n    const p = toPatchPathString((patch as any)?.path)\n    if (!p) continue\n    set.add(p)\n  }\n\n  return {\n    nextState,\n    patchPaths: Array.from(set),\n  }\n}\n\n", "import { Context, Effect, FiberRef, Option, Schema, Stream, SubscriptionRef } from \"effect\"\nimport { create } from \"mutative\"\nimport type * as Logix from \"./core/module.js\"\nimport * as Logic from \"./core/LogicMiddleware.js\"\nimport * as TaskRunner from \"./core/TaskRunner.js\"\nimport { mutateWithPatchPaths } from \"./core/mutativePatches.js\"\nimport * as FlowRuntime from \"./FlowRuntime.js\"\nimport * as MatchBuilder from \"./core/MatchBuilder.js\"\nimport * as Platform from \"./core/Platform.js\"\nimport * as Lifecycle from \"./Lifecycle.js\"\nimport * as Debug from \"./core/DebugSink.js\"\nimport * as LogicDiagnostics from \"./core/LogicDiagnostics.js\"\nimport { isDevEnv } from \"./core/env.js\"\nimport { RunSessionTag } from \"../observability/runSession.js\"\nimport type { RuntimeInternals } from \"./core/RuntimeInternals.js\"\nimport type * as ModuleTraits from \"./core/ModuleTraits.js\"\nimport {\n  getRuntimeInternals,\n  setBoundInternals,\n} from \"./core/runtimeInternalsAccessor.js\"\nimport type {\n  AnyModuleShape,\n  ModuleRuntime,\n  StateOf,\n  ActionOf,\n} from \"./core/module.js\"\n\n// \u672C\u5730\u6784\u9020 IntentBuilder \u5DE5\u5382\uFF0C\u7B49\u4EF7\u4E8E\u539F internal/dsl/LogicBuilder.makeIntentBuilderFactory\nconst LogicBuilderFactory = <Sh extends AnyModuleShape, R = never>(\n  runtime: ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>,\n  runtimeInternals: RuntimeInternals,\n) => {\n  const flowApi = FlowRuntime.make<Sh, R>(runtime, runtimeInternals)\n\n  return <T>(\n    stream: Stream.Stream<T>,\n    triggerName?: string,\n  ): Logic.IntentBuilder<T, Sh, R> => {\n    const runWithStateTransaction: TaskRunner.TaskRunnerRuntime[\"runWithStateTransaction\"] =\n      (origin, body) => runtimeInternals.txn.runWithStateTransaction(origin as any, body)\n\n\t    const taskRunnerRuntime: TaskRunner.TaskRunnerRuntime = {\n\t      moduleId: runtime.moduleId,\n\t      instanceId: runtimeInternals.instanceId,\n\t      runWithStateTransaction,\n\t      resolveConcurrencyPolicy: runtimeInternals.concurrency.resolveConcurrencyPolicy,\n\t    }\n\n\t    const builder = {\n\t      debounce: (ms: number) =>\n\t        LogicBuilderFactory<Sh, R>(runtime, runtimeInternals)(\n\t          flowApi.debounce<T>(ms)(stream),\n\t          triggerName,\n\t        ),\n\t      throttle: (ms: number) =>\n\t        LogicBuilderFactory<Sh, R>(runtime, runtimeInternals)(\n\t          flowApi.throttle<T>(ms)(stream),\n\t          triggerName,\n\t        ),\n\t      filter: (predicate: (value: T) => boolean) =>\n\t        LogicBuilderFactory<Sh, R>(runtime, runtimeInternals)(\n\t          flowApi.filter(predicate)(stream),\n\t          triggerName,\n\t        ),\n\t      map: <U>(f: (value: T) => U) =>\n\t        LogicBuilderFactory<Sh, R>(runtime, runtimeInternals)(\n\t          stream.pipe(Stream.map(f)),\n\t          triggerName,\n\t        ),\n      run<A = void, E = never, R2 = unknown>(\n        eff:\n          | Logic.Of<Sh, R & R2, A, E>\n          | ((p: T) => Logic.Of<Sh, R & R2, A, E>),\n        options?: Logic.OperationOptions,\n      ): Logic.Of<Sh, R & R2, void, E> {\n        return flowApi.run<T, A, E, R2>(eff, options)(stream)\n      },\n      runLatest<A = void, E = never, R2 = unknown>(\n        eff:\n          | Logic.Of<Sh, R & R2, A, E>\n          | ((p: T) => Logic.Of<Sh, R & R2, A, E>),\n        options?: Logic.OperationOptions,\n      ): Logic.Of<Sh, R & R2, void, E> {\n        return flowApi.runLatest<T, A, E, R2>(eff, options)(stream)\n      },\n      runExhaust<A = void, E = never, R2 = unknown>(\n        eff:\n          | Logic.Of<Sh, R & R2, A, E>\n          | ((p: T) => Logic.Of<Sh, R & R2, A, E>),\n        options?: Logic.OperationOptions,\n      ): Logic.Of<Sh, R & R2, void, E> {\n        return flowApi.runExhaust<T, A, E, R2>(eff, options)(stream)\n      },\n      runParallel<A = void, E = never, R2 = unknown>(\n        eff:\n          | Logic.Of<Sh, R & R2, A, E>\n          | ((p: T) => Logic.Of<Sh, R & R2, A, E>),\n        options?: Logic.OperationOptions,\n      ): Logic.Of<Sh, R & R2, void, E> {\n        return flowApi.runParallel<T, A, E, R2>(eff, options)(stream)\n      },\n      runFork: <A = void, E = never, R2 = unknown>(\n        eff:\n          | Logic.Of<Sh, R & R2, A, E>\n          | ((p: T) => Logic.Of<Sh, R & R2, A, E>)\n      ): Logic.Of<Sh, R & R2, void, E> =>\n        Effect.forkScoped(flowApi.run<T, A, E, R2>(eff)(stream)).pipe(\n          Effect.asVoid,\n        ) as Logic.Of<Sh, R & R2, void, E>,\n      runParallelFork: <A = void, E = never, R2 = unknown>(\n        eff:\n          | Logic.Of<Sh, R & R2, A, E>\n          | ((p: T) => Logic.Of<Sh, R & R2, A, E>)\n      ): Logic.Of<Sh, R & R2, void, E> =>\n        Effect.forkScoped(\n          flowApi.runParallel<T, A, E, R2>(eff)(stream),\n        ).pipe(\n          Effect.asVoid,\n        ) as Logic.Of<Sh, R & R2, void, E>,\n      runTask: <A = void, E = never, R2 = unknown>(\n        config: TaskRunner.TaskRunnerConfig<T, Sh, R & R2, A, E>,\n      ): Logic.Of<Sh, R & R2, void, never> =>\n        TaskRunner.makeTaskRunner<T, Sh, R & R2, A, E>(\n          stream,\n          \"task\",\n          taskRunnerRuntime,\n          {\n            ...config,\n            triggerName: config.triggerName ?? triggerName,\n          },\n        ) as Logic.Of<Sh, R & R2, void, never>,\n      runParallelTask: <A = void, E = never, R2 = unknown>(\n        config: TaskRunner.TaskRunnerConfig<T, Sh, R & R2, A, E>,\n      ): Logic.Of<Sh, R & R2, void, never> =>\n        TaskRunner.makeTaskRunner<T, Sh, R & R2, A, E>(\n          stream,\n          \"parallel\",\n          taskRunnerRuntime,\n          {\n            ...config,\n            triggerName: config.triggerName ?? triggerName,\n          },\n        ) as Logic.Of<Sh, R & R2, void, never>,\n      runLatestTask: <A = void, E = never, R2 = unknown>(\n        config: TaskRunner.TaskRunnerConfig<T, Sh, R & R2, A, E>,\n      ): Logic.Of<Sh, R & R2, void, never> =>\n        TaskRunner.makeTaskRunner<T, Sh, R & R2, A, E>(\n          stream,\n          \"latest\",\n          taskRunnerRuntime,\n          {\n            ...config,\n            triggerName: config.triggerName ?? triggerName,\n          },\n        ) as Logic.Of<Sh, R & R2, void, never>,\n      runExhaustTask: <A = void, E = never, R2 = unknown>(\n        config: TaskRunner.TaskRunnerConfig<T, Sh, R & R2, A, E>,\n      ): Logic.Of<Sh, R & R2, void, never> =>\n        TaskRunner.makeTaskRunner<T, Sh, R & R2, A, E>(\n          stream,\n          \"exhaust\",\n          taskRunnerRuntime,\n          {\n            ...config,\n            triggerName: config.triggerName ?? triggerName,\n          },\n        ) as Logic.Of<Sh, R & R2, void, never>,\n      toStream: () => stream,\n      update: (\n        reducer: (\n          prev: StateOf<Sh>,\n          payload: T\n        ) =>\n          | StateOf<Sh>\n          | Effect.Effect<StateOf<Sh>, any, any>\n      ): Logic.Of<Sh, R, void, never> =>\n        Stream.runForEach(stream, (payload) =>\n          taskRunnerRuntime.runWithStateTransaction(\n            {\n              kind: \"watcher:update\",\n              name: triggerName,\n            },\n            () =>\n              Effect.gen(function* () {\n                const prev = (yield* runtime.getState) as StateOf<Sh>\n                const next = reducer(prev, payload)\n                if (Effect.isEffect(next)) {\n                  const exit = yield* Effect.exit(\n                    next as Effect.Effect<StateOf<Sh>, any, any>,\n                  )\n                  if (exit._tag === \"Failure\") {\n                    yield* Effect.logError(\"Flow error\", exit.cause)\n                    return\n                  }\n                  yield* runtime.setState(exit.value as StateOf<Sh>)\n                  return\n                }\n                yield* runtime.setState(next as StateOf<Sh>)\n              }),\n          )\n        ).pipe(\n          Effect.catchAllCause((cause) =>\n            Effect.logError(\"Flow error\", cause)\n          )\n        ) as Logic.Of<Sh, R, void, never>,\n      mutate: (\n        reducer: (draft: Logic.Draft<StateOf<Sh>>, payload: T) => void\n      ): Logic.Of<Sh, R, void, never> =>\n        Stream.runForEach(stream, (payload) =>\n          taskRunnerRuntime.runWithStateTransaction(\n            {\n              kind: \"watcher:mutate\",\n              name: triggerName,\n            },\n            () =>\n              Effect.gen(function* () {\n                const prev = (yield* runtime.getState) as StateOf<Sh>\n                const recordPatch = runtimeInternals?.txn.recordStatePatch\n\n                const { nextState, patchPaths } = mutateWithPatchPaths(\n                  prev as StateOf<Sh>,\n                  (draft) => {\n                    reducer(draft as Logic.Draft<StateOf<Sh>>, payload)\n                  },\n                )\n\n                for (const path of patchPaths) {\n                  recordPatch?.({\n                    path,\n                    reason: \"watcher:mutate\",\n                  })\n                }\n\n                yield* runtime.setState(nextState)\n              }),\n          )\n        ).pipe(\n          Effect.catchAllCause((cause) =>\n            Effect.logError(\"Flow error\", cause)\n          )\n        ) as Logic.Of<Sh, R, void, never>,\n    } as Omit<Logic.IntentBuilder<T, Sh, R>, \"pipe\" | \"andThen\">\n\n    const andThen: Logic.IntentBuilder<T, Sh, R>[\"andThen\"] = (\n      handlerOrEff: any,\n    ): any => {\n      if (typeof handlerOrEff === \"function\") {\n        if (handlerOrEff.length >= 2) {\n          return (builder as any).update(handlerOrEff)\n        }\n        return (builder as any).run(handlerOrEff)\n      }\n      return (builder as any).run(handlerOrEff)\n    }\n\n    const pipe: Logic.IntentBuilder<T, Sh, R>[\"pipe\"] = function (this: unknown) {\n      // eslint-disable-next-line prefer-rest-params\n      const fns = arguments as unknown as ReadonlyArray<\n        (self: Logic.IntentBuilder<T, Sh, R>) => Logic.IntentBuilder<T, Sh, R>\n      >\n      let acc: Logic.IntentBuilder<T, Sh, R> = builder as Logic.IntentBuilder<\n        T,\n        Sh,\n        R\n      >\n      for (let i = 0; i < fns.length; i++) {\n        acc = fns[i](acc)\n      }\n      return acc\n    }\n\n    return Object.assign(builder, { pipe, andThen }) as Logic.IntentBuilder<\n      T,\n      Sh,\n      R\n    >\n  }\n}\nimport type { BoundApi } from \"./core/module.js\"\n\n/**\n * BoundApi \u5B9E\u73B0\uFF1A\u4E3A\u67D0\u4E00\u7C7B Store Shape + Runtime \u521B\u5EFA\u9884\u7ED1\u5B9A\u7684 `$`\u3002\n *\n * \u8BF4\u660E\uFF1A\u7C7B\u578B\u4E0E\u5165\u53E3\u7B7E\u540D\u5728 api/BoundApi.ts \u4E2D\u58F0\u660E\uFF0C\u8FD9\u91CC\u53EA\u627F\u8F7D\u5177\u4F53\u5B9E\u73B0\u3002\n */\nexport function make<Sh extends Logix.AnyModuleShape, R = never>(\n  shape: Sh,\n  runtime: Logix.ModuleRuntime<Logix.StateOf<Sh>, Logix.ActionOf<Sh>>,\n  options?: {\n    readonly getPhase?: () => \"setup\" | \"run\"\n    readonly phaseService?: LogicDiagnostics.LogicPhaseService\n    readonly moduleId?: string\n    readonly logicUnit?: LogicDiagnostics.LogicUnitService\n  }\n  ): BoundApi<Sh, R> {\n  const runtimeInternals = getRuntimeInternals(runtime as any)\n\n  const getPhase = options?.getPhase ?? (() => \"run\")\n  const getCurrentPhase = (): \"setup\" | \"run\" => {\n    const phaseService = options?.phaseService\n    const phase = phaseService?.current ?? getPhase()\n    return phase === \"setup\" ? \"setup\" : \"run\"\n  }\n  const guardRunOnly = (kind: string, api: string) => {\n    const phaseService = options?.phaseService\n    const phase = phaseService?.current ?? getPhase()\n    if (phase === \"setup\") {\n      throw LogicDiagnostics.makeLogicPhaseError(\n        kind,\n        api,\n        \"setup\",\n        options?.moduleId\n      )\n    }\n  }\n  const flowApi = FlowRuntime.make<Sh, R>(runtime, runtimeInternals)\n\n  const makeIntentBuilder = (runtime_: Logix.ModuleRuntime<any, any>) =>\n    LogicBuilderFactory<Sh, R>(runtime_, runtimeInternals)\n  const withLifecycle = <A>(\n    available: (\n      manager: Lifecycle.LifecycleManager\n    ) => Effect.Effect<A, never, any>,\n    missing: () => Effect.Effect<A, never, any>\n  ) =>\n    Effect.serviceOption(Lifecycle.LifecycleContext).pipe(\n      Effect.flatMap((maybe) =>\n        Option.match(maybe, {\n          onSome: available,\n          onNone: missing,\n        })\n      )\n    )\n  const withPlatform = (\n    invoke: (platform: Platform.Service) => Effect.Effect<void, never, any>\n  ) =>\n    Effect.serviceOption(Platform.Tag).pipe(\n      Effect.flatMap((maybe) =>\n        Option.match(maybe, {\n          onSome: invoke,\n          onNone: () => Effect.void,\n        })\n      )\n    )\n\n  const emitSetupOnlyViolation = (api: string): Effect.Effect<void> =>\n    Debug.record({\n      type: \"diagnostic\",\n      moduleId: runtime.moduleId,\n      instanceId: runtime.instanceId,\n      code: \"logic::invalid_phase\",\n      severity: \"error\",\n      message: `${api} is setup-only and is not allowed in run phase.`,\n      hint:\n        \"\u5C06 $.lifecycle.* \u8C03\u7528\u79FB\u52A8\u5230 Module.logic builder \u7684\u540C\u6B65\u90E8\u5206\uFF08return \u4E4B\u524D\uFF09\u7528\u4E8E\u6CE8\u518C\uFF1B\" +\n        \"run \u6BB5\u9700\u8981\u52A8\u6001\u8D44\u6E90\u6E05\u7406\u65F6\uFF0C\u8BF7\u4F7F\u7528 Effect.acquireRelease / Scope finalizer\uFF0C\u800C\u4E0D\u662F late \u6CE8\u518C onDestroy\u3002\",\n      kind: \"lifecycle_in_run\",\n    })\n\n  const createIntentBuilder = <T>(\n    stream: Stream.Stream<T>,\n    triggerName?: string,\n  ) => makeIntentBuilder(runtime)(stream, triggerName)\n\n  const onceInRunSession = (key: string): Effect.Effect<boolean, never, any> =>\n    Effect.serviceOption(RunSessionTag).pipe(\n      Effect.map((maybe) =>\n        Option.isSome(maybe) ? maybe.value.local.once(key) : true,\n      ),\n    )\n\n  let cachedDiagnosticsLevel: Debug.DiagnosticsLevel | undefined\n\n  const isModuleLike = (\n    value: unknown,\n  ): value is {\n    readonly _kind: \"ModuleDef\" | \"Module\"\n    readonly id: string\n    readonly tag: Context.Tag<any, Logix.ModuleRuntime<any, any>>\n    readonly schemas?: Record<string, unknown>\n    readonly meta?: Record<string, unknown>\n    readonly dev?: { readonly source?: { readonly file: string; readonly line: number; readonly column: number } }\n  } =>\n    Boolean(\n      value &&\n        typeof value === \"object\" &&\n        (((value as any)._kind === \"ModuleDef\" || (value as any)._kind === \"Module\") &&\n          \"tag\" in (value as object)) &&\n        Context.isTag((value as any).tag),\n    )\n\n  const buildModuleHandle = (\n    tag: Context.Tag<any, Logix.ModuleRuntime<any, any>>,\n    rt: Logix.ModuleRuntime<any, any>,\n  ): unknown => {\n    const actionsProxy: Logix.ModuleHandle<any>[\"actions\"] =\n      new Proxy(\n        {},\n        {\n          get: (_target, prop) =>\n            (payload: unknown) =>\n              rt.dispatch({\n                _tag: prop as string,\n                payload,\n              }),\n        },\n      ) as Logix.ModuleHandle<any>[\"actions\"]\n\n    const handle: Logix.ModuleHandle<any> = {\n      read: (selector) => Effect.map(rt.getState, selector),\n      changes: rt.changes,\n      dispatch: rt.dispatch,\n      actions$: rt.actions$,\n      actions: actionsProxy,\n    }\n\n    const EXTEND_HANDLE = Symbol.for(\"logix.module.handle.extend\")\n    const extend =\n      (tag as any)?.[EXTEND_HANDLE] as\n        | ((\n            runtime: Logix.ModuleRuntime<any, any>,\n            base: Logix.ModuleHandle<any>,\n          ) => unknown)\n        | undefined\n\n    return typeof extend === \"function\" ? (extend(rt, handle) ?? handle) : handle\n  }\n\n  const emitModuleDescriptorOnce = (\n    module: {\n      readonly id: string\n      readonly tag: any\n      readonly schemas?: Record<string, unknown>\n      readonly meta?: Record<string, unknown>\n      readonly dev?: { readonly source?: { readonly file: string; readonly line: number; readonly column: number } }\n    },\n    rt: Logix.ModuleRuntime<any, any>,\n  ): Effect.Effect<void, never, any> =>\n    Effect.gen(function* () {\n      // \u4E3A hot-path \u515C\u5E95\uFF1A\u8BCA\u65AD\u7EA7\u522B\u4E3A off \u65F6\u6C38\u4E0D\u53D1\u4E8B\u4EF6\u3002\n      if (cachedDiagnosticsLevel === \"off\") return\n\n      const key = `module_descriptor:${String(rt.instanceId ?? \"unknown\")}`\n      const shouldEmit = yield* onceInRunSession(key)\n      if (!shouldEmit) return\n\n      const actionKeys = Object.keys((module.tag as any)?.shape?.actionMap ?? {})\n\n      const internalSymbol = Symbol.for(\"logix.module.internal\")\n      const internal = (module as any)[internalSymbol] as\n        | { readonly mounted?: ReadonlyArray<any> }\n        | undefined\n\n      const logicUnits = (internal?.mounted ?? []).map((u: any) => ({\n        kind: String(u?.kind ?? \"user\"),\n        id: String(u?.id ?? \"\"),\n        derived: u?.derived ? true : undefined,\n        name: typeof u?.name === \"string\" ? u.name : undefined,\n      }))\n\n      const schemaKeys =\n        module.schemas && typeof module.schemas === \"object\"\n          ? Object.keys(module.schemas)\n          : undefined\n\n      const meta =\n        module.meta && typeof module.meta === \"object\" ? module.meta : undefined\n\n      const source = module.dev?.source\n\n      const traitsSnapshot = runtimeInternals.traits.getModuleTraitsSnapshot()\n      const traits =\n        traitsSnapshot\n          ? {\n              digest: traitsSnapshot.digest,\n              count: traitsSnapshot.traits.length,\n            }\n          : undefined\n\n      const data = {\n        id: module.id,\n        moduleId: String(rt.moduleId),\n        instanceId: String(rt.instanceId),\n        actionKeys,\n        logicUnits,\n        schemaKeys,\n        meta,\n        source,\n        traits,\n      }\n\n      yield* Debug.record({\n        type: \"trace:module:descriptor\",\n        moduleId: rt.moduleId,\n        instanceId: rt.instanceId,\n        data,\n      } as any)\n    })\n\n  /**\n   * strict\uFF1A\u53EA\u4ECE\u201C\u5F53\u524D Effect Env\u201D\u89E3\u6790\u67D0\u4E2A Module \u7684 Runtime\u3002\n   *\n   * \u8BF4\u660E\uFF1A\n   * - \u591A root / \u591A\u5B9E\u4F8B\u573A\u666F\u4E0B\uFF0C\u4EFB\u4F55\u8FDB\u7A0B\u7EA7 registry \u90FD\u65E0\u6CD5\u8868\u8FBE\u6B63\u786E\u8BED\u4E49\uFF1B\n   * - \u7F3A\u5931\u63D0\u4F9B\u8005\u5C5E\u4E8E\u88C5\u914D\u9519\u8BEF\uFF1A\u5FC5\u987B\u7A33\u5B9A\u5931\u8D25\uFF0C\u5E76\u7ED9\u51FA\u53EF\u4FEE\u590D\u7684\u63D0\u793A\uFF08dev/test \u4E0B\u66F4\u8BE6\u7EC6\uFF09\u3002\n   */\n  const resolveModuleRuntime = (\n    tag: Context.Tag<any, Logix.ModuleRuntime<any, any>>\n  ): Effect.Effect<Logix.ModuleRuntime<any, any>, never, any> =>\n    Effect.gen(function* () {\n      const requestedModuleId =\n        typeof (tag as any)?.id === \"string\"\n          ? ((tag as any).id as string)\n          : undefined\n      const fromModuleId =\n        typeof options?.moduleId === \"string\" ? options.moduleId : undefined\n\n      // 1) \u4F18\u5148\u5C1D\u8BD5\u4ECE\u5F53\u524D Context \u4E2D\u8BFB\u53D6\n      const fromEnv = yield* Effect.serviceOption(tag)\n      if (Option.isSome(fromEnv)) {\n        return fromEnv.value\n      }\n\n      // 2) \u65E0\u6CD5\u627E\u5230\u65F6\u76F4\u63A5 die \u2014\u2014 \u8FD9\u662F\u914D\u7F6E\u9519\u8BEF\uFF0C\u63D0\u793A\u8C03\u7528\u65B9\u4FEE\u6B63\u88C5\u914D\u65B9\u5F0F\n      const tokenId = requestedModuleId ?? \"<unknown module id>\"\n      const fix: string[] = isDevEnv()\n        ? [\n            \"- Provide the child implementation in the same scope (imports).\",\n            `  Example: ${fromModuleId ?? \"ParentModule\"}.implement({ imports: [${requestedModuleId ?? \"ChildModule\"}.impl], ... })`,\n            \"- If you intentionally want a root singleton, provide it at app root (Runtime.make(...,{ layer }) / root imports),\",\n            \"  and use Root.resolve(ModuleTag) (instead of $.use) at the callsite.\",\n          ]\n        : []\n\n      const err = new Error(\n        isDevEnv()\n          ? [\n              \"[MissingModuleRuntimeError] Cannot resolve ModuleRuntime for ModuleTag.\",\n              \"\",\n              `tokenId: ${tokenId}`,\n              \"entrypoint: logic.$.use\",\n              \"mode: strict\",\n              `from: ${fromModuleId ?? \"<unknown module id>\"}`,\n              `startScope: moduleId=${fromModuleId ?? \"<unknown>\"}, instanceId=${String(runtime.instanceId ?? \"<unknown>\")}`,\n              \"\",\n              \"fix:\",\n              ...fix,\n            ].join(\"\\n\")\n          : \"[MissingModuleRuntimeError] module runtime not found\",\n      )\n\n      ;(err as any).tokenId = tokenId\n      ;(err as any).entrypoint = \"logic.$.use\"\n      ;(err as any).mode = \"strict\"\n      ;(err as any).from = fromModuleId\n      ;(err as any).startScope = {\n        moduleId: fromModuleId,\n        instanceId: String(runtime.instanceId ?? \"<unknown>\"),\n      }\n      ;(err as any).fix = fix\n\n      err.name = \"MissingModuleRuntimeError\"\n      return yield* Effect.die(err)\n    })\n\n  const stateApi: BoundApi<Sh, R>[\"state\"] = {\n    read: runtime.getState,\n    update: (f) =>\n      Effect.gen(function* () {\n        const inTxn = yield* FiberRef.get(TaskRunner.inSyncTransactionFiber)\n        if (inTxn) {\n          const prev = yield* runtime.getState\n          return yield* runtime.setState(f(prev))\n        }\n\n        const body = () =>\n          Effect.flatMap(runtime.getState, (prev) => runtime.setState(f(prev)))\n\n        return yield* (runtimeInternals\n          ? runtimeInternals.txn.runWithStateTransaction(\n              { kind: \"state\", name: \"update\" } as any,\n              body,\n            )\n          : body())\n      }),\n    mutate: (f) =>\n      Effect.gen(function* () {\n        const recordPatch = runtimeInternals?.txn.recordStatePatch\n\n        const inTxn = yield* FiberRef.get(TaskRunner.inSyncTransactionFiber)\n        if (inTxn) {\n          const prev = yield* runtime.getState\n          const { nextState, patchPaths } = mutateWithPatchPaths(\n            prev as Logix.StateOf<Sh>,\n            (draft) => {\n              f(draft as Logic.Draft<Logix.StateOf<Sh>>)\n            },\n          )\n\n          for (const path of patchPaths) {\n            recordPatch?.({\n              path,\n              reason: \"state:mutate\",\n            })\n          }\n\n          return yield* runtime.setState(nextState)\n        }\n\n        const body = () =>\n          Effect.flatMap(runtime.getState, (prev) => {\n            const { nextState, patchPaths } = mutateWithPatchPaths(\n              prev as Logix.StateOf<Sh>,\n              (draft) => {\n                f(draft as Logic.Draft<Logix.StateOf<Sh>>)\n              },\n            )\n\n            for (const path of patchPaths) {\n              recordPatch?.({\n                path,\n                reason: \"state:mutate\",\n              })\n            }\n\n            return runtime.setState(nextState)\n          })\n\n        return yield* (runtimeInternals\n          ? runtimeInternals.txn.runWithStateTransaction(\n              { kind: \"state\", name: \"mutate\" } as any,\n              body,\n            )\n          : body())\n      }),\n    ref: runtime.ref,\n  }\n\n  const actionsApi = new Proxy({} as BoundApi<Sh, R>[\"actions\"], {\n    get: (_target, prop) => {\n      if (prop === \"dispatch\") {\n        return (a: Logix.ActionOf<Sh>) => runtime.dispatch(a)\n      }\n      if (prop === \"actions$\") {\n        return runtime.actions$\n      }\n      return (payload: any) =>\n        runtime.dispatch({ _tag: prop as string, payload } as Logix.ActionOf<Sh>)\n    },\n  })\n\n  const matchApi = <V>(value: V): Logic.FluentMatch<V> =>\n    MatchBuilder.makeMatch(value)\n\n  const matchTagApi = <V extends { _tag: string }>(\n    value: V\n  ): Logic.FluentMatchTag<V> => MatchBuilder.makeMatchTag(value)\n\n  // Primary Reducer \u6CE8\u518C\uFF1A\u901A\u8FC7 runtime \u4E0A\u7684\u5185\u90E8\u6CE8\u518C\u51FD\u6570\uFF08\u82E5\u5B58\u5728\uFF09\u5199\u5165 reducer \u6620\u5C04\u3002\n  const reducer: BoundApi<Sh, R>[\"reducer\"] = (tag, fn) => {\n    return Effect.sync(() => {\n      runtimeInternals.txn.registerReducer(String(tag), fn as any)\n    }) as any\n  }\n\n  const api: BoundApi<Sh, R> = {\n    state: stateApi,\n    actions: actionsApi,\n    flow: flowApi,\n    match: matchApi,\n    matchTag: matchTagApi,\n    lifecycle: {\n      onInitRequired: (eff: Logic.Of<Sh, R, void, never>) => {\n        if (getCurrentPhase() === \"run\") {\n          return emitSetupOnlyViolation(\"$.lifecycle.onInitRequired\") as any\n        }\n        runtimeInternals.lifecycle.registerInitRequired(eff as any)\n        return Effect.void as any\n      },\n      onStart: (eff: Logic.Of<Sh, R, void, never>) => {\n        if (getCurrentPhase() === \"run\") {\n          return emitSetupOnlyViolation(\"$.lifecycle.onStart\") as any\n        }\n        runtimeInternals.lifecycle.registerStart(eff as any)\n        return Effect.void as any\n      },\n      onInit: (eff: Logic.Of<Sh, R, void, never>) => {\n        // legacy alias\uFF1A\u8BED\u4E49\u7B49\u540C\u4E8E onInitRequired\uFF08\u4E3A\u4E86\u8FC1\u79FB\u671F\u51CF\u5C11\u6469\u64E6\uFF09\u3002\n        if (getCurrentPhase() === \"run\") {\n          return emitSetupOnlyViolation(\"$.lifecycle.onInit\") as any\n        }\n        runtimeInternals.lifecycle.registerInitRequired(eff as any)\n        return Effect.void as any\n      },\n      onDestroy: (eff: Logic.Of<Sh, R, void, never>) => {\n        if (getCurrentPhase() === \"run\") {\n          return emitSetupOnlyViolation(\"$.lifecycle.onDestroy\") as any\n        }\n        runtimeInternals.lifecycle.registerDestroy(eff as any)\n        return Effect.void as any\n      },\n      onError: (\n        handler: (\n          cause: import(\"effect\").Cause.Cause<unknown>,\n          context: Lifecycle.ErrorContext,\n        ) => Effect.Effect<void, never, R>,\n      ) => {\n        if (getCurrentPhase() === \"run\") {\n          return emitSetupOnlyViolation(\"$.lifecycle.onError\") as any\n        }\n        runtimeInternals.lifecycle.registerOnError(handler as any)\n        return Effect.void as any\n      },\n      onSuspend: (\n        eff: Logic.Of<Sh, R, void, never>,\n      ) => {\n        if (getCurrentPhase() === \"run\") {\n          return emitSetupOnlyViolation(\"$.lifecycle.onSuspend\") as any\n        }\n        runtimeInternals.lifecycle.registerPlatformSuspend(\n          Effect.asVoid(eff as Effect.Effect<void, never, any>),\n        )\n        return Effect.void as any\n      },\n      onResume: (\n        eff: Logic.Of<Sh, R, void, never>,\n      ) => {\n        if (getCurrentPhase() === \"run\") {\n          return emitSetupOnlyViolation(\"$.lifecycle.onResume\") as any\n        }\n        runtimeInternals.lifecycle.registerPlatformResume(\n          Effect.asVoid(eff as Effect.Effect<void, never, any>),\n        )\n        return Effect.void as any\n      },\n      onReset: (\n        eff: Logic.Of<Sh, R, void, never>,\n      ) => {\n        if (getCurrentPhase() === \"run\") {\n          return emitSetupOnlyViolation(\"$.lifecycle.onReset\") as any\n        }\n        runtimeInternals.lifecycle.registerPlatformReset(\n          Effect.asVoid(eff as Effect.Effect<void, never, any>),\n        )\n        return Effect.void as any\n      },\n    },\n    traits: {\n      declare: (traits: ModuleTraits.TraitSpec) => {\n        if (getCurrentPhase() === \"run\") {\n          throw LogicDiagnostics.makeLogicPhaseError(\n            \"traits_declare_in_run\",\n            \"$.traits.declare\",\n            \"run\",\n            options?.moduleId,\n          )\n        }\n\n        if (!traits || typeof traits !== \"object\") {\n          throw new Error(\n            \"[InvalidTraitsDeclaration] $.traits.declare expects an object.\",\n          )\n        }\n\n        const logicUnit = options?.logicUnit ?? {\n          logicUnitId: \"unknown\",\n          logicUnitIdKind: \"derived\" as const,\n          logicUnitLabel: \"logicUnit:unknown\",\n          path: undefined as string | undefined,\n        }\n\n        runtimeInternals.traits.registerModuleTraitsContribution({\n          traits,\n          provenance: {\n            originType: \"logicUnit\",\n            originId: logicUnit.logicUnitId,\n            originIdKind: logicUnit.logicUnitIdKind,\n            originLabel: logicUnit.logicUnitLabel,\n            path: logicUnit.path,\n          },\n        })\n\n        return Effect.void as any\n      },\n      source: {\n        refresh: (fieldPath: string) =>\n          Effect.gen(function* () {\n            const handler = (runtimeInternals.traits.getSourceRefreshHandler(\n              fieldPath,\n            ) as\n              | ((state: Logix.StateOf<Sh>) => Effect.Effect<void, never, any>)\n              | undefined)\n            if (!handler) {\n              // \u82E5\u672A\u6CE8\u518C\u5237\u65B0\u903B\u8F91\uFF0C\u5219\u89C6\u4E3A no-op\uFF0C\u907F\u514D\u5728\u672A\u6302 StateTraitProgram \u65F6\u629B\u9519\u3002\n              return yield* Effect.void\n            }\n\n            // \u4E8B\u52A1\u7A97\u53E3\u5185\u7981\u6B62\u518D\u8D70 enqueueTransaction\uFF08\u4F1A\u5BFC\u81F4\u6B7B\u9501\uFF09\uFF1A\n            // - \u76F4\u63A5\u5728\u5F53\u524D\u4E8B\u52A1\u5185\u6267\u884C handler\uFF0C\u4F7F\u5176\u901A\u8FC7 bound.state.mutate \u5199\u5165 draft\uFF1B\n            // - \u7531\u5916\u5C42\u540C\u4E00\u4E8B\u52A1\u7A97\u53E3\u8D1F\u8D23 commit + debug \u805A\u5408\u3002\n            const inTxn = yield* FiberRef.get(TaskRunner.inSyncTransactionFiber)\n            if (inTxn) {\n              const state = (yield* runtime.getState) as Logix.StateOf<Sh>\n              return yield* handler(state)\n            }\n\n            // \u5C06\u4E00\u6B21 source-refresh \u89C6\u4E3A\u5355\u72EC\u7684\u4E8B\u52A1\u5165\u53E3\u3002\n            return yield* runtimeInternals.txn.runWithStateTransaction(\n              {\n                kind: \"source-refresh\",\n                name: fieldPath,\n              } as any,\n              () =>\n                Effect.gen(function* () {\n                  const state = (yield* runtime.getState) as Logix.StateOf<Sh>\n                  return yield* handler(state)\n                }),\n            )\n          }),\n      },\n    },\n    reducer,\n    use: new Proxy(() => {}, {\n      apply: (_target, _thisArg, [arg]) => {\n        guardRunOnly(\"use_in_setup\", \"$.use\")\n        if (isModuleLike(arg)) {\n          const domain = arg\n          const tag = domain.tag as unknown as Context.Tag<\n            any,\n            Logix.ModuleRuntime<any, any>\n          >\n\n          const resolveAndBuild = resolveModuleRuntime(tag).pipe(\n            Effect.map((rt) => buildModuleHandle(tag, rt)),\n          )\n\n          const resolveWithDescriptor = resolveModuleRuntime(tag).pipe(\n            Effect.tap((rt) => emitModuleDescriptorOnce(domain, rt)),\n            Effect.map((rt) => buildModuleHandle(tag, rt)),\n          )\n\n          const detectAndSelect = FiberRef.get(Debug.currentDiagnosticsLevel).pipe(\n            Effect.tap((level) => {\n              cachedDiagnosticsLevel = level\n            }),\n            Effect.flatMap((level) =>\n              level === \"off\" ? resolveAndBuild : resolveWithDescriptor,\n            ),\n          )\n\n          // 022 perf gate\uFF1Adiagnostics off \u65F6\uFF0C$.use(module) \u4E0E $.use(module.tag) \u5FC5\u987B\u7B49\u4EF7\u4E14\u96F6\u989D\u5916\u5F00\u9500\u3002\n          // \u7EA6\u675F\uFF1AEffect \u662F\u503C\uFF08\u53EF\u590D\u7528\uFF09\uFF1B\u56E0\u6B64\u5FC5\u987B\u5728\u6267\u884C\u671F\u505A\u4E00\u6B21\u6027\u7F13\u5B58\uFF0C\u800C\u4E0D\u80FD\u5728\u6784\u9020\u671F\u56FA\u5B9A\u5206\u652F\u3002\n\t          return Effect.suspend(() => {\n\t            if (cachedDiagnosticsLevel === \"off\") {\n\t              return resolveAndBuild\n\t            }\n\n\t            if (cachedDiagnosticsLevel !== undefined) {\n\t              return resolveWithDescriptor\n\t            }\n\n\t            return detectAndSelect\n\t          }) as unknown as Logic.Of<Sh, R, any, never>\n\t        }\n        if (Context.isTag(arg)) {\n          const candidate = arg as { _kind?: unknown }\n\n          // Module\uFF1A\u8FD4\u56DE\u53EA\u8BFB ModuleHandle \u89C6\u56FE\n          if (candidate._kind === \"ModuleTag\") {\n            return resolveModuleRuntime(arg as any).pipe(\n              Effect.map((rt: Logix.ModuleRuntime<any, any>) =>\n                buildModuleHandle(arg as any, rt),\n              ),\n            ) as unknown as Logic.Of<Sh, R, any, never>\n          }\n\n          // \u666E\u901A Service Tag\uFF1A\u76F4\u63A5\u4ECE Env \u83B7\u53D6 Service\n          return arg as unknown as Logic.Of<Sh, R, any, never>\n        }\n        return Effect.die(\"BoundApi.use: unsupported argument\") as unknown as Logic.Of<\n          Sh,\n          R,\n          any,\n          never\n        >\n      },\n    }) as unknown as BoundApi<Sh, R>[\"use\"],\n    onAction: new Proxy(() => {}, {\n      apply: (_target, _thisArg, args) => {\n        guardRunOnly(\"use_in_setup\", \"$.onAction\")\n        const arg = args[0]\n        if (typeof arg === \"function\") {\n          return createIntentBuilder(\n            runtime.actions$.pipe(Stream.filter(arg))\n          )\n        }\n        if (typeof arg === \"string\") {\n          return createIntentBuilder(\n            runtime.actions$.pipe(\n              Stream.filter((a: any) => a._tag === arg || a.type === arg)\n            ),\n            arg,\n          )\n        }\n        if (typeof arg === \"object\" && arg !== null) {\n          if (\"_tag\" in arg) {\n            return createIntentBuilder(\n              runtime.actions$.pipe(\n                Stream.filter((a: any) => a._tag === (arg as any)._tag)\n              ),\n              String((arg as any)._tag),\n            )\n          }\n          if (Schema.isSchema(arg)) {\n            return createIntentBuilder(\n              runtime.actions$.pipe(\n                Stream.filter((a: any) => {\n                  const result = Schema.decodeUnknownSync(\n                    arg as Schema.Schema<any, any, never>\n                  )(a)\n                  return !!result\n                })\n              )\n            )\n          }\n        }\n        return createIntentBuilder(runtime.actions$)\n      },\n      get: (_target, prop) => {\n        guardRunOnly(\"use_in_setup\", \"$.onAction\")\n        if (typeof prop === \"string\") {\n          return createIntentBuilder(\n            runtime.actions$.pipe(\n              Stream.filter(\n                (a: any) => a._tag === prop || a.type === prop\n              )\n            ),\n            prop,\n          )\n        }\n        return undefined\n      },\n    }) as unknown as BoundApi<Sh, R>[\"onAction\"],\n    onState: (\n      selector: (s: Logix.StateOf<Sh>) => any,\n    ) => {\n      guardRunOnly(\"use_in_setup\", \"$.onState\")\n      return createIntentBuilder(runtime.changes(selector))\n    },\n    on: (\n      stream: Stream.Stream<any>,\n    ) => {\n      guardRunOnly(\"use_in_setup\", \"$.on\")\n      return createIntentBuilder(stream)\n    },\n  } as any\n\n  setBoundInternals(api as any, runtimeInternals)\n\n  return api\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,IAAM,oBAAoB,CAAC,SAA+C;AACxE,MAAI,OAAO,SAAS,UAAU;AAC5B,UAAM,UAAU,KAAK,KAAK;AAC1B,WAAO,QAAQ,SAAS,IAAI,UAAU;AAAA,EACxC;AAEA,MAAI,CAAC,MAAM,QAAQ,IAAI,EAAG,QAAO;AAEjC,QAAM,QAAuB,CAAC;AAC9B,aAAW,OAAO,MAAM;AACtB,QAAI,OAAO,QAAQ,UAAU;AAC3B,UAAI,IAAI,SAAS,EAAG,OAAM,KAAK,GAAG;AAClC;AAAA,IACF;AACA,QAAI,OAAO,QAAQ,YAAY,OAAO,SAAS,GAAG,GAAG;AACnD,YAAM,KAAK,OAAO,KAAK,MAAM,GAAG,CAAC,CAAC;AAClC;AAAA,IACF;AAAA,EACF;AAEA,MAAI,MAAM,WAAW,EAAG,QAAO;AAC/B,SAAO,MAAM,KAAK,GAAG;AACvB;AAEO,IAAM,uBAAuB,CAClC,MACA,YACmF;AACnF,QAAM,MAAM,OAAO,MAAM,SAAgB;AAAA,IACvC,eAAe;AAAA,MACb,aAAa;AAAA,MACb,uBAAuB;AAAA,IACzB;AAAA,EACF,CAAC;AAED,MAAI,CAAC,MAAM,QAAQ,GAAG,GAAG;AACvB,WAAO,EAAE,WAAW,KAAU,YAAY,CAAC,EAAE;AAAA,EAC/C;AAEA,QAAM,YAAY,IAAI,CAAC;AACvB,QAAM,UAAW,IAAI,CAAC,KAAK,CAAC;AAE5B,QAAM,MAAM,oBAAI,IAAqB;AACrC,aAAW,SAAS,SAAS;AAC3B,UAAM,IAAI,kBAAmB,OAAe,IAAI;AAChD,QAAI,CAAC,EAAG;AACR,QAAI,IAAI,CAAC;AAAA,EACX;AAEA,SAAO;AAAA,IACL;AAAA,IACA,YAAY,MAAM,KAAK,GAAG;AAAA,EAC5B;AACF;;;ACzDA,SAAS,SAAS,QAAQ,UAAU,QAAQ,QAAQ,cAA+B;AA4BnF,IAAM,sBAAsB,CAC1B,SACA,qBACG;AACH,QAAM,UAAsB,KAAY,SAAS,gBAAgB;AAEjE,SAAO,CACL,QACA,gBACkC;AAClC,UAAM,0BACJ,CAAC,QAAQ,SAAS,iBAAiB,IAAI,wBAAwB,QAAe,IAAI;AAEnF,UAAM,oBAAkD;AAAA,MACtD,UAAU,QAAQ;AAAA,MAClB,YAAY,iBAAiB;AAAA,MAC7B;AAAA,MACA,0BAA0B,iBAAiB,YAAY;AAAA,IACzD;AAEA,UAAM,UAAU;AAAA,MACd,UAAU,CAAC,OACT,oBAA2B,SAAS,gBAAgB;AAAA,QAClD,QAAQ,SAAY,EAAE,EAAE,MAAM;AAAA,QAC9B;AAAA,MACF;AAAA,MACF,UAAU,CAAC,OACT,oBAA2B,SAAS,gBAAgB;AAAA,QAClD,QAAQ,SAAY,EAAE,EAAE,MAAM;AAAA,QAC9B;AAAA,MACF;AAAA,MACF,QAAQ,CAAC,cACP,oBAA2B,SAAS,gBAAgB;AAAA,QAClD,QAAQ,OAAO,SAAS,EAAE,MAAM;AAAA,QAChC;AAAA,MACF;AAAA,MACF,KAAK,CAAI,MACP,oBAA2B,SAAS,gBAAgB;AAAA,QAClD,OAAO,KAAK,OAAO,IAAI,CAAC,CAAC;AAAA,QACzB;AAAA,MACF;AAAA,MACH,IACE,KAGA,SAC+B;AAC/B,eAAO,QAAQ,IAAiB,KAAK,OAAO,EAAE,MAAM;AAAA,MACtD;AAAA,MACA,UACE,KAGA,SAC+B;AAC/B,eAAO,QAAQ,UAAuB,KAAK,OAAO,EAAE,MAAM;AAAA,MAC5D;AAAA,MACA,WACE,KAGA,SAC+B;AAC/B,eAAO,QAAQ,WAAwB,KAAK,OAAO,EAAE,MAAM;AAAA,MAC7D;AAAA,MACA,YACE,KAGA,SAC+B;AAC/B,eAAO,QAAQ,YAAyB,KAAK,OAAO,EAAE,MAAM;AAAA,MAC9D;AAAA,MACA,SAAS,CACP,QAIA,OAAO,WAAW,QAAQ,IAAiB,GAAG,EAAE,MAAM,CAAC,EAAE;AAAA,QACvD,OAAO;AAAA,MACT;AAAA,MACF,iBAAiB,CACf,QAIA,OAAO;AAAA,QACL,QAAQ,YAAyB,GAAG,EAAE,MAAM;AAAA,MAC9C,EAAE;AAAA,QACA,OAAO;AAAA,MACT;AAAA,MACF,SAAS,CACP,WAEW;AAAA,QACT;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,UACE,GAAG;AAAA,UACH,aAAa,OAAO,eAAe;AAAA,QACrC;AAAA,MACF;AAAA,MACF,iBAAiB,CACf,WAEW;AAAA,QACT;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,UACE,GAAG;AAAA,UACH,aAAa,OAAO,eAAe;AAAA,QACrC;AAAA,MACF;AAAA,MACF,eAAe,CACb,WAEW;AAAA,QACT;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,UACE,GAAG;AAAA,UACH,aAAa,OAAO,eAAe;AAAA,QACrC;AAAA,MACF;AAAA,MACF,gBAAgB,CACd,WAEW;AAAA,QACT;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,UACE,GAAG;AAAA,UACH,aAAa,OAAO,eAAe;AAAA,QACrC;AAAA,MACF;AAAA,MACF,UAAU,MAAM;AAAA,MAChB,QAAQ,CACN,YAOA,OAAO;AAAA,QAAW;AAAA,QAAQ,CAAC,YACzB,kBAAkB;AAAA,UAChB;AAAA,YACE,MAAM;AAAA,YACN,MAAM;AAAA,UACR;AAAA,UACA,MACE,OAAO,IAAI,aAAa;AACtB,kBAAM,OAAQ,OAAO,QAAQ;AAC7B,kBAAM,OAAO,QAAQ,MAAM,OAAO;AAClC,gBAAI,OAAO,SAAS,IAAI,GAAG;AACzB,oBAAM,OAAO,OAAO,OAAO;AAAA,gBACzB;AAAA,cACF;AACA,kBAAI,KAAK,SAAS,WAAW;AAC3B,uBAAO,OAAO,SAAS,cAAc,KAAK,KAAK;AAC/C;AAAA,cACF;AACA,qBAAO,QAAQ,SAAS,KAAK,KAAoB;AACjD;AAAA,YACF;AACA,mBAAO,QAAQ,SAAS,IAAmB;AAAA,UAC7C,CAAC;AAAA,QACL;AAAA,MACF,EAAE;AAAA,QACA,OAAO;AAAA,UAAc,CAAC,UACpB,OAAO,SAAS,cAAc,KAAK;AAAA,QACrC;AAAA,MACF;AAAA,MACF,QAAQ,CACN,YAEA,OAAO;AAAA,QAAW;AAAA,QAAQ,CAAC,YACzB,kBAAkB;AAAA,UAChB;AAAA,YACE,MAAM;AAAA,YACN,MAAM;AAAA,UACR;AAAA,UACA,MACE,OAAO,IAAI,aAAa;AACtB,kBAAM,OAAQ,OAAO,QAAQ;AAC7B,kBAAM,cAAc,kBAAkB,IAAI;AAE1C,kBAAM,EAAE,WAAW,WAAW,IAAI;AAAA,cAChC;AAAA,cACA,CAAC,UAAU;AACT,wBAAQ,OAAmC,OAAO;AAAA,cACpD;AAAA,YACF;AAEA,uBAAW,QAAQ,YAAY;AAC7B,4BAAc;AAAA,gBACZ;AAAA,gBACA,QAAQ;AAAA,cACV,CAAC;AAAA,YACH;AAEA,mBAAO,QAAQ,SAAS,SAAS;AAAA,UACnC,CAAC;AAAA,QACL;AAAA,MACF,EAAE;AAAA,QACA,OAAO;AAAA,UAAc,CAAC,UACpB,OAAO,SAAS,cAAc,KAAK;AAAA,QACrC;AAAA,MACF;AAAA,IACJ;AAEA,UAAM,UAAoD,CACxD,iBACQ;AACR,UAAI,OAAO,iBAAiB,YAAY;AACtC,YAAI,aAAa,UAAU,GAAG;AAC5B,iBAAQ,QAAgB,OAAO,YAAY;AAAA,QAC7C;AACA,eAAQ,QAAgB,IAAI,YAAY;AAAA,MAC1C;AACA,aAAQ,QAAgB,IAAI,YAAY;AAAA,IAC1C;AAEA,UAAM,OAA8C,WAAyB;AAE3E,YAAM,MAAM;AAGZ,UAAI,MAAqC;AAKzC,eAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AACnC,cAAM,IAAI,CAAC,EAAE,GAAG;AAAA,MAClB;AACA,aAAO;AAAA,IACT;AAEA,WAAO,OAAO,OAAO,SAAS,EAAE,MAAM,QAAQ,CAAC;AAAA,EAKjD;AACF;AAQO,SAASA,MACd,OACA,SACA,SAMmB;AACnB,QAAM,mBAAmB,oBAAoB,OAAc;AAE3D,QAAM,WAAW,SAAS,aAAa,MAAM;AAC7C,QAAM,kBAAkB,MAAuB;AAC7C,UAAM,eAAe,SAAS;AAC9B,UAAM,QAAQ,cAAc,WAAW,SAAS;AAChD,WAAO,UAAU,UAAU,UAAU;AAAA,EACvC;AACA,QAAM,eAAe,CAAC,MAAcC,SAAgB;AAClD,UAAM,eAAe,SAAS;AAC9B,UAAM,QAAQ,cAAc,WAAW,SAAS;AAChD,QAAI,UAAU,SAAS;AACrB,YAAuB;AAAA,QACrB;AAAA,QACAA;AAAA,QACA;AAAA,QACA,SAAS;AAAA,MACX;AAAA,IACF;AAAA,EACF;AACA,QAAM,UAAsB,KAAY,SAAS,gBAAgB;AAEjE,QAAM,oBAAoB,CAAC,aACzB,oBAA2B,UAAU,gBAAgB;AACvD,QAAM,gBAAgB,CACpB,WAGA,YAEA,OAAO,cAAwB,gBAAgB,EAAE;AAAA,IAC/C,OAAO;AAAA,MAAQ,CAAC,UACd,OAAO,MAAM,OAAO;AAAA,QAClB,QAAQ;AAAA,QACR,QAAQ;AAAA,MACV,CAAC;AAAA,IACH;AAAA,EACF;AACF,QAAM,eAAe,CACnB,WAEA,OAAO,cAAuB,GAAG,EAAE;AAAA,IACjC,OAAO;AAAA,MAAQ,CAAC,UACd,OAAO,MAAM,OAAO;AAAA,QAClB,QAAQ;AAAA,QACR,QAAQ,MAAM,OAAO;AAAA,MACvB,CAAC;AAAA,IACH;AAAA,EACF;AAEF,QAAM,yBAAyB,CAACA,SACxB,OAAO;AAAA,IACX,MAAM;AAAA,IACN,UAAU,QAAQ;AAAA,IAClB,YAAY,QAAQ;AAAA,IACpB,MAAM;AAAA,IACN,UAAU;AAAA,IACV,SAAS,GAAGA,IAAG;AAAA,IACf,MACE;AAAA,IAEF,MAAM;AAAA,EACR,CAAC;AAEH,QAAM,sBAAsB,CAC1B,QACA,gBACG,kBAAkB,OAAO,EAAE,QAAQ,WAAW;AAEnD,QAAM,mBAAmB,CAAC,QACxB,OAAO,cAAc,aAAa,EAAE;AAAA,IAClC,OAAO;AAAA,MAAI,CAAC,UACV,OAAO,OAAO,KAAK,IAAI,MAAM,MAAM,MAAM,KAAK,GAAG,IAAI;AAAA,IACvD;AAAA,EACF;AAEF,MAAI;AAEJ,QAAM,eAAe,CACnB,UASA;AAAA,IACE,SACE,OAAO,UAAU,cACd,MAAc,UAAU,eAAgB,MAAc,UAAU,aACjE,SAAU,UACZ,QAAQ,MAAO,MAAc,GAAG;AAAA,EACpC;AAEF,QAAM,oBAAoB,CACxB,KACA,OACY;AACZ,UAAM,eACJ,IAAI;AAAA,MACF,CAAC;AAAA,MACD;AAAA,QACE,KAAK,CAAC,SAAS,SACb,CAAC,YACC,GAAG,SAAS;AAAA,UACV,MAAM;AAAA,UACN;AAAA,QACF,CAAC;AAAA,MACP;AAAA,IACF;AAEF,UAAM,SAAkC;AAAA,MACtC,MAAM,CAAC,aAAa,OAAO,IAAI,GAAG,UAAU,QAAQ;AAAA,MACpD,SAAS,GAAG;AAAA,MACZ,UAAU,GAAG;AAAA,MACb,UAAU,GAAG;AAAA,MACb,SAAS;AAAA,IACX;AAEA,UAAM,gBAAgB,uBAAO,IAAI,4BAA4B;AAC7D,UAAM,SACH,MAAc,aAAa;AAO9B,WAAO,OAAO,WAAW,aAAc,OAAO,IAAI,MAAM,KAAK,SAAU;AAAA,EACzE;AAEA,QAAM,2BAA2B,CAC/B,QAOA,OAEA,OAAO,IAAI,aAAa;AAEtB,QAAI,2BAA2B,MAAO;AAEtC,UAAM,MAAM,qBAAqB,OAAO,GAAG,cAAc,SAAS,CAAC;AACnE,UAAM,aAAa,OAAO,iBAAiB,GAAG;AAC9C,QAAI,CAAC,WAAY;AAEjB,UAAM,aAAa,OAAO,KAAM,OAAO,KAAa,OAAO,aAAa,CAAC,CAAC;AAE1E,UAAM,iBAAiB,uBAAO,IAAI,uBAAuB;AACzD,UAAM,WAAY,OAAe,cAAc;AAI/C,UAAM,cAAc,UAAU,WAAW,CAAC,GAAG,IAAI,CAAC,OAAY;AAAA,MAC5D,MAAM,OAAO,GAAG,QAAQ,MAAM;AAAA,MAC9B,IAAI,OAAO,GAAG,MAAM,EAAE;AAAA,MACtB,SAAS,GAAG,UAAU,OAAO;AAAA,MAC7B,MAAM,OAAO,GAAG,SAAS,WAAW,EAAE,OAAO;AAAA,IAC/C,EAAE;AAEF,UAAM,aACJ,OAAO,WAAW,OAAO,OAAO,YAAY,WACxC,OAAO,KAAK,OAAO,OAAO,IAC1B;AAEN,UAAM,OACJ,OAAO,QAAQ,OAAO,OAAO,SAAS,WAAW,OAAO,OAAO;AAEjE,UAAM,SAAS,OAAO,KAAK;AAE3B,UAAM,iBAAiB,iBAAiB,OAAO,wBAAwB;AACvE,UAAM,SACJ,iBACI;AAAA,MACE,QAAQ,eAAe;AAAA,MACvB,OAAO,eAAe,OAAO;AAAA,IAC/B,IACA;AAEN,UAAM,OAAO;AAAA,MACX,IAAI,OAAO;AAAA,MACX,UAAU,OAAO,GAAG,QAAQ;AAAA,MAC5B,YAAY,OAAO,GAAG,UAAU;AAAA,MAChC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAEA,WAAa,OAAO;AAAA,MAClB,MAAM;AAAA,MACN,UAAU,GAAG;AAAA,MACb,YAAY,GAAG;AAAA,MACf;AAAA,IACF,CAAQ;AAAA,EACV,CAAC;AASH,QAAM,uBAAuB,CAC3B,QAEA,OAAO,IAAI,aAAa;AACtB,UAAM,oBACJ,OAAQ,KAAa,OAAO,WACtB,IAAY,KACd;AACN,UAAM,eACJ,OAAO,SAAS,aAAa,WAAW,QAAQ,WAAW;AAG7D,UAAM,UAAU,OAAO,OAAO,cAAc,GAAG;AAC/C,QAAI,OAAO,OAAO,OAAO,GAAG;AAC1B,aAAO,QAAQ;AAAA,IACjB;AAGA,UAAM,UAAU,qBAAqB;AACrC,UAAM,MAAgB,SAAS,IAC3B;AAAA,MACE;AAAA,MACA,cAAc,gBAAgB,cAAc,0BAA0B,qBAAqB,aAAa;AAAA,MACxG;AAAA,MACA;AAAA,IACF,IACA,CAAC;AAEL,UAAM,MAAM,IAAI;AAAA,MACd,SAAS,IACL;AAAA,QACE;AAAA,QACA;AAAA,QACA,YAAY,OAAO;AAAA,QACnB;AAAA,QACA;AAAA,QACA,SAAS,gBAAgB,qBAAqB;AAAA,QAC9C,wBAAwB,gBAAgB,WAAW,gBAAgB,OAAO,QAAQ,cAAc,WAAW,CAAC;AAAA,QAC5G;AAAA,QACA;AAAA,QACA,GAAG;AAAA,MACL,EAAE,KAAK,IAAI,IACX;AAAA,IACN;AAEC,IAAC,IAAY,UAAU;AACvB,IAAC,IAAY,aAAa;AAC1B,IAAC,IAAY,OAAO;AACpB,IAAC,IAAY,OAAO;AACpB,IAAC,IAAY,aAAa;AAAA,MACzB,UAAU;AAAA,MACV,YAAY,OAAO,QAAQ,cAAc,WAAW;AAAA,IACtD;AACC,IAAC,IAAY,MAAM;AAEpB,QAAI,OAAO;AACX,WAAO,OAAO,OAAO,IAAI,GAAG;AAAA,EAC9B,CAAC;AAEH,QAAM,WAAqC;AAAA,IACzC,MAAM,QAAQ;AAAA,IACd,QAAQ,CAAC,MACP,OAAO,IAAI,aAAa;AACtB,YAAM,QAAQ,OAAO,SAAS,IAAe,sBAAsB;AACnE,UAAI,OAAO;AACT,cAAM,OAAO,OAAO,QAAQ;AAC5B,eAAO,OAAO,QAAQ,SAAS,EAAE,IAAI,CAAC;AAAA,MACxC;AAEA,YAAM,OAAO,MACX,OAAO,QAAQ,QAAQ,UAAU,CAAC,SAAS,QAAQ,SAAS,EAAE,IAAI,CAAC,CAAC;AAEtE,aAAO,OAAQ,mBACX,iBAAiB,IAAI;AAAA,QACnB,EAAE,MAAM,SAAS,MAAM,SAAS;AAAA,QAChC;AAAA,MACF,IACA,KAAK;AAAA,IACX,CAAC;AAAA,IACH,QAAQ,CAAC,MACP,OAAO,IAAI,aAAa;AACtB,YAAM,cAAc,kBAAkB,IAAI;AAE1C,YAAM,QAAQ,OAAO,SAAS,IAAe,sBAAsB;AACnE,UAAI,OAAO;AACT,cAAM,OAAO,OAAO,QAAQ;AAC5B,cAAM,EAAE,WAAW,WAAW,IAAI;AAAA,UAChC;AAAA,UACA,CAAC,UAAU;AACT,cAAE,KAAuC;AAAA,UAC3C;AAAA,QACF;AAEA,mBAAW,QAAQ,YAAY;AAC7B,wBAAc;AAAA,YACZ;AAAA,YACA,QAAQ;AAAA,UACV,CAAC;AAAA,QACH;AAEA,eAAO,OAAO,QAAQ,SAAS,SAAS;AAAA,MAC1C;AAEA,YAAM,OAAO,MACX,OAAO,QAAQ,QAAQ,UAAU,CAAC,SAAS;AACzC,cAAM,EAAE,WAAW,WAAW,IAAI;AAAA,UAChC;AAAA,UACA,CAAC,UAAU;AACT,cAAE,KAAuC;AAAA,UAC3C;AAAA,QACF;AAEA,mBAAW,QAAQ,YAAY;AAC7B,wBAAc;AAAA,YACZ;AAAA,YACA,QAAQ;AAAA,UACV,CAAC;AAAA,QACH;AAEA,eAAO,QAAQ,SAAS,SAAS;AAAA,MACnC,CAAC;AAEH,aAAO,OAAQ,mBACX,iBAAiB,IAAI;AAAA,QACnB,EAAE,MAAM,SAAS,MAAM,SAAS;AAAA,QAChC;AAAA,MACF,IACA,KAAK;AAAA,IACX,CAAC;AAAA,IACH,KAAK,QAAQ;AAAA,EACf;AAEA,QAAM,aAAa,IAAI,MAAM,CAAC,GAAiC;AAAA,IAC7D,KAAK,CAAC,SAAS,SAAS;AACtB,UAAI,SAAS,YAAY;AACvB,eAAO,CAAC,MAA0B,QAAQ,SAAS,CAAC;AAAA,MACtD;AACA,UAAI,SAAS,YAAY;AACvB,eAAO,QAAQ;AAAA,MACjB;AACA,aAAO,CAAC,YACN,QAAQ,SAAS,EAAE,MAAM,MAAgB,QAAQ,CAAuB;AAAA,IAC5E;AAAA,EACF,CAAC;AAED,QAAM,WAAW,CAAI,UACN,UAAU,KAAK;AAE9B,QAAM,cAAc,CAClB,UACyC,aAAa,KAAK;AAG7D,QAAM,UAAsC,CAAC,KAAK,OAAO;AACvD,WAAO,OAAO,KAAK,MAAM;AACvB,uBAAiB,IAAI,gBAAgB,OAAO,GAAG,GAAG,EAAS;AAAA,IAC7D,CAAC;AAAA,EACH;AAEA,QAAM,MAAuB;AAAA,IAC3B,OAAO;AAAA,IACP,SAAS;AAAA,IACT,MAAM;AAAA,IACN,OAAO;AAAA,IACP,UAAU;AAAA,IACV,WAAW;AAAA,MACT,gBAAgB,CAAC,QAAsC;AACrD,YAAI,gBAAgB,MAAM,OAAO;AAC/B,iBAAO,uBAAuB,4BAA4B;AAAA,QAC5D;AACA,yBAAiB,UAAU,qBAAqB,GAAU;AAC1D,eAAO,OAAO;AAAA,MAChB;AAAA,MACA,SAAS,CAAC,QAAsC;AAC9C,YAAI,gBAAgB,MAAM,OAAO;AAC/B,iBAAO,uBAAuB,qBAAqB;AAAA,QACrD;AACA,yBAAiB,UAAU,cAAc,GAAU;AACnD,eAAO,OAAO;AAAA,MAChB;AAAA,MACA,QAAQ,CAAC,QAAsC;AAE7C,YAAI,gBAAgB,MAAM,OAAO;AAC/B,iBAAO,uBAAuB,oBAAoB;AAAA,QACpD;AACA,yBAAiB,UAAU,qBAAqB,GAAU;AAC1D,eAAO,OAAO;AAAA,MAChB;AAAA,MACA,WAAW,CAAC,QAAsC;AAChD,YAAI,gBAAgB,MAAM,OAAO;AAC/B,iBAAO,uBAAuB,uBAAuB;AAAA,QACvD;AACA,yBAAiB,UAAU,gBAAgB,GAAU;AACrD,eAAO,OAAO;AAAA,MAChB;AAAA,MACA,SAAS,CACP,YAIG;AACH,YAAI,gBAAgB,MAAM,OAAO;AAC/B,iBAAO,uBAAuB,qBAAqB;AAAA,QACrD;AACA,yBAAiB,UAAU,gBAAgB,OAAc;AACzD,eAAO,OAAO;AAAA,MAChB;AAAA,MACA,WAAW,CACT,QACG;AACH,YAAI,gBAAgB,MAAM,OAAO;AAC/B,iBAAO,uBAAuB,uBAAuB;AAAA,QACvD;AACA,yBAAiB,UAAU;AAAA,UACzB,OAAO,OAAO,GAAsC;AAAA,QACtD;AACA,eAAO,OAAO;AAAA,MAChB;AAAA,MACA,UAAU,CACR,QACG;AACH,YAAI,gBAAgB,MAAM,OAAO;AAC/B,iBAAO,uBAAuB,sBAAsB;AAAA,QACtD;AACA,yBAAiB,UAAU;AAAA,UACzB,OAAO,OAAO,GAAsC;AAAA,QACtD;AACA,eAAO,OAAO;AAAA,MAChB;AAAA,MACA,SAAS,CACP,QACG;AACH,YAAI,gBAAgB,MAAM,OAAO;AAC/B,iBAAO,uBAAuB,qBAAqB;AAAA,QACrD;AACA,yBAAiB,UAAU;AAAA,UACzB,OAAO,OAAO,GAAsC;AAAA,QACtD;AACA,eAAO,OAAO;AAAA,MAChB;AAAA,IACF;AAAA,IACA,QAAQ;AAAA,MACN,SAAS,CAAC,WAAmC;AAC3C,YAAI,gBAAgB,MAAM,OAAO;AAC/B,gBAAuB;AAAA,YACrB;AAAA,YACA;AAAA,YACA;AAAA,YACA,SAAS;AAAA,UACX;AAAA,QACF;AAEA,YAAI,CAAC,UAAU,OAAO,WAAW,UAAU;AACzC,gBAAM,IAAI;AAAA,YACR;AAAA,UACF;AAAA,QACF;AAEA,cAAM,YAAY,SAAS,aAAa;AAAA,UACtC,aAAa;AAAA,UACb,iBAAiB;AAAA,UACjB,gBAAgB;AAAA,UAChB,MAAM;AAAA,QACR;AAEA,yBAAiB,OAAO,iCAAiC;AAAA,UACvD;AAAA,UACA,YAAY;AAAA,YACV,YAAY;AAAA,YACZ,UAAU,UAAU;AAAA,YACpB,cAAc,UAAU;AAAA,YACxB,aAAa,UAAU;AAAA,YACvB,MAAM,UAAU;AAAA,UAClB;AAAA,QACF,CAAC;AAED,eAAO,OAAO;AAAA,MAChB;AAAA,MACA,QAAQ;AAAA,QACN,SAAS,CAAC,cACR,OAAO,IAAI,aAAa;AACtB,gBAAM,UAAW,iBAAiB,OAAO;AAAA,YACvC;AAAA,UACF;AAGA,cAAI,CAAC,SAAS;AAEZ,mBAAO,OAAO,OAAO;AAAA,UACvB;AAKA,gBAAM,QAAQ,OAAO,SAAS,IAAe,sBAAsB;AACnE,cAAI,OAAO;AACT,kBAAM,QAAS,OAAO,QAAQ;AAC9B,mBAAO,OAAO,QAAQ,KAAK;AAAA,UAC7B;AAGA,iBAAO,OAAO,iBAAiB,IAAI;AAAA,YACjC;AAAA,cACE,MAAM;AAAA,cACN,MAAM;AAAA,YACR;AAAA,YACA,MACE,OAAO,IAAI,aAAa;AACtB,oBAAM,QAAS,OAAO,QAAQ;AAC9B,qBAAO,OAAO,QAAQ,KAAK;AAAA,YAC7B,CAAC;AAAA,UACL;AAAA,QACF,CAAC;AAAA,MACL;AAAA,IACF;AAAA,IACA;AAAA,IACA,KAAK,IAAI,MAAM,MAAM;AAAA,IAAC,GAAG;AAAA,MACvB,OAAO,CAAC,SAAS,UAAU,CAAC,GAAG,MAAM;AACnC,qBAAa,gBAAgB,OAAO;AACpC,YAAI,aAAa,GAAG,GAAG;AACrB,gBAAM,SAAS;AACf,gBAAM,MAAM,OAAO;AAKnB,gBAAM,kBAAkB,qBAAqB,GAAG,EAAE;AAAA,YAChD,OAAO,IAAI,CAAC,OAAO,kBAAkB,KAAK,EAAE,CAAC;AAAA,UAC/C;AAEA,gBAAM,wBAAwB,qBAAqB,GAAG,EAAE;AAAA,YACtD,OAAO,IAAI,CAAC,OAAO,yBAAyB,QAAQ,EAAE,CAAC;AAAA,YACvD,OAAO,IAAI,CAAC,OAAO,kBAAkB,KAAK,EAAE,CAAC;AAAA,UAC/C;AAEA,gBAAM,kBAAkB,SAAS,IAAU,uBAAuB,EAAE;AAAA,YAClE,OAAO,IAAI,CAAC,UAAU;AACpB,uCAAyB;AAAA,YAC3B,CAAC;AAAA,YACD,OAAO;AAAA,cAAQ,CAAC,UACd,UAAU,QAAQ,kBAAkB;AAAA,YACtC;AAAA,UACF;AAIC,iBAAO,OAAO,QAAQ,MAAM;AAC1B,gBAAI,2BAA2B,OAAO;AACpC,qBAAO;AAAA,YACT;AAEA,gBAAI,2BAA2B,QAAW;AACxC,qBAAO;AAAA,YACT;AAEA,mBAAO;AAAA,UACT,CAAC;AAAA,QACH;AACD,YAAI,QAAQ,MAAM,GAAG,GAAG;AACtB,gBAAM,YAAY;AAGlB,cAAI,UAAU,UAAU,aAAa;AACnC,mBAAO,qBAAqB,GAAU,EAAE;AAAA,cACtC,OAAO;AAAA,gBAAI,CAAC,OACV,kBAAkB,KAAY,EAAE;AAAA,cAClC;AAAA,YACF;AAAA,UACF;AAGA,iBAAO;AAAA,QACT;AACA,eAAO,OAAO,IAAI,oCAAoC;AAAA,MAMxD;AAAA,IACF,CAAC;AAAA,IACD,UAAU,IAAI,MAAM,MAAM;AAAA,IAAC,GAAG;AAAA,MAC5B,OAAO,CAAC,SAAS,UAAU,SAAS;AAClC,qBAAa,gBAAgB,YAAY;AACzC,cAAM,MAAM,KAAK,CAAC;AAClB,YAAI,OAAO,QAAQ,YAAY;AAC7B,iBAAO;AAAA,YACL,QAAQ,SAAS,KAAK,OAAO,OAAO,GAAG,CAAC;AAAA,UAC1C;AAAA,QACF;AACA,YAAI,OAAO,QAAQ,UAAU;AAC3B,iBAAO;AAAA,YACL,QAAQ,SAAS;AAAA,cACf,OAAO,OAAO,CAAC,MAAW,EAAE,SAAS,OAAO,EAAE,SAAS,GAAG;AAAA,YAC5D;AAAA,YACA;AAAA,UACF;AAAA,QACF;AACA,YAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAC3C,cAAI,UAAU,KAAK;AACjB,mBAAO;AAAA,cACL,QAAQ,SAAS;AAAA,gBACf,OAAO,OAAO,CAAC,MAAW,EAAE,SAAU,IAAY,IAAI;AAAA,cACxD;AAAA,cACA,OAAQ,IAAY,IAAI;AAAA,YAC1B;AAAA,UACF;AACA,cAAI,OAAO,SAAS,GAAG,GAAG;AACxB,mBAAO;AAAA,cACL,QAAQ,SAAS;AAAA,gBACf,OAAO,OAAO,CAAC,MAAW;AACxB,wBAAM,SAAS,OAAO;AAAA,oBACpB;AAAA,kBACF,EAAE,CAAC;AACH,yBAAO,CAAC,CAAC;AAAA,gBACX,CAAC;AAAA,cACH;AAAA,YACF;AAAA,UACF;AAAA,QACF;AACA,eAAO,oBAAoB,QAAQ,QAAQ;AAAA,MAC7C;AAAA,MACA,KAAK,CAAC,SAAS,SAAS;AACtB,qBAAa,gBAAgB,YAAY;AACzC,YAAI,OAAO,SAAS,UAAU;AAC5B,iBAAO;AAAA,YACL,QAAQ,SAAS;AAAA,cACf,OAAO;AAAA,gBACL,CAAC,MAAW,EAAE,SAAS,QAAQ,EAAE,SAAS;AAAA,cAC5C;AAAA,YACF;AAAA,YACA;AAAA,UACF;AAAA,QACF;AACA,eAAO;AAAA,MACT;AAAA,IACF,CAAC;AAAA,IACD,SAAS,CACP,aACG;AACH,mBAAa,gBAAgB,WAAW;AACxC,aAAO,oBAAoB,QAAQ,QAAQ,QAAQ,CAAC;AAAA,IACtD;AAAA,IACA,IAAI,CACF,WACG;AACH,mBAAa,gBAAgB,MAAM;AACnC,aAAO,oBAAoB,MAAM;AAAA,IACnC;AAAA,EACF;AAEA,oBAAkB,KAAY,gBAAgB;AAE9C,SAAO;AACT;",
  "names": ["make", "api"]
}
