@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/logix-core/Module.js

@@ -1,28 +1,34 @@
 // @logixjs/core subpath bundles for @logixjs/sandbox
 
+import {
+  installOne,
+  mountAll
+} from "../chunks/chunk-DM7C5NP5.js";
+import "../chunks/chunk-UZZBHWIO.js";
 import {
   Reducer,
   make
-} from "../chunks/chunk-SUXDGXVE.js";
-import "../chunks/chunk-CDLXJHXY.js";
-import "../chunks/chunk-YF6IO732.js";
+} from "../chunks/chunk-WNOBN3DX.js";
+import "../chunks/chunk-NE447XAF.js";
+import "../chunks/chunk-5GEYCJW2.js";
+import "../chunks/chunk-KTFZSXOW.js";
+import "../chunks/chunk-FQRUTYAD.js";
+import "../chunks/chunk-C2MYMMO4.js";
 import {
   attachLogicUnitMeta,
   getLogicUnitMeta,
   updateLogicUnitMeta
-} from "../chunks/chunk-PQ652ULI.js";
-import "../chunks/chunk-MPUSOFJ3.js";
-import "../chunks/chunk-HFV5GJPK.js";
-import "../chunks/chunk-CEGSWZ5S.js";
-import "../chunks/chunk-ZUBABAAO.js";
-import "../chunks/chunk-4LRLOTMA.js";
-import "../chunks/chunk-HNEDTEGQ.js";
+} from "../chunks/chunk-BJOWSSEL.js";
+import "../chunks/chunk-KDJR27JV.js";
+import "../chunks/chunk-EZTMVCJF.js";
+import "../chunks/chunk-6TUOP63Q.js";
+import "../chunks/chunk-L4PNO2H6.js";
 import "../chunks/chunk-NTN6T6I6.js";
-import "../chunks/chunk-JIXTOQXJ.js";
+import "../chunks/chunk-RIWOEI3T.js";
 import "../chunks/chunk-KE2H62D6.js";
-import "../chunks/chunk-WFV5PPWJ.js";
 import "../chunks/chunk-CTSYKMM6.js";
-import "../chunks/chunk-RJQ4PG2F.js";
+import "../chunks/chunk-NWCJJZNQ.js";
+import "../chunks/chunk-UBMUY7WO.js";
 import "../chunks/chunk-GFOF7NCX.js";
 import {
   isActionToken,
@@ -31,22 +37,24 @@ import {
 import {
   internal,
   record
-} from "../chunks/chunk-S4EXG3OS.js";
-import "../chunks/chunk-A6JFUNQQ.js";
-import "../chunks/chunk-ON2LY6HJ.js";
+} from "../chunks/chunk-RBB6SHW2.js";
+import "../chunks/chunk-74C5VW7Z.js";
+import "../chunks/chunk-4MY35XR3.js";
 import "../chunks/chunk-2LZ43SWS.js";
-import "../chunks/chunk-IP63FME6.js";
-import "../chunks/chunk-UCFEP3BH.js";
+import "../chunks/chunk-X2Z5VYG3.js";
+import "../chunks/chunk-ASVMK364.js";
+import "../chunks/chunk-7GPAF2UK.js";
 import {
   isDevEnv
-} from "../chunks/chunk-CZRI7MHA.js";
-import "../chunks/chunk-VLYP4WUS.js";
-import "../chunks/chunk-UMVN3AWO.js";
-import "../chunks/chunk-UKYAF3NL.js";
-import "../chunks/chunk-S46P7MC6.js";
-import "../chunks/chunk-3LX3KIQQ.js";
-import "../chunks/chunk-BWSNPKO5.js";
-import "../chunks/chunk-TOQ6SJ6O.js";
+} from "../chunks/chunk-YMVMZA3U.js";
+import "../chunks/chunk-NMGFJZ4I.js";
+import "../chunks/chunk-UJGVDFZN.js";
+import "../chunks/chunk-2XVE7F26.js";
+import "../chunks/chunk-W365QUZ5.js";
+import "../chunks/chunk-SH7TP5CJ.js";
+import "../chunks/chunk-SI5OKFFY.js";
+import "../chunks/chunk-LWI7BXFN.js";
+import "../chunks/chunk-DT7YIIWE.js";
 
 // ../logix-core/src/Module.ts
 import { Context, Effect, FiberRef } from "../effect.js";
@@ -380,6 +388,7 @@ function make2(id, def, extend) {
     const imports = config.imports;
     const processes = config.processes;
     const stateTransaction = config.stateTransaction;
+    const workflowDefs = Array.isArray(config.__logix_workflowDefs) ? config.__logix_workflowDefs : [];
     const mountedResult = (config.logics ?? []).reduce(
       (acc, logic) => mountLogicUnit(acc.mounted, acc.overrides, { logic }),
       { mounted: [], overrides: [] }
@@ -409,6 +418,7 @@ function make2(id, def, extend) {
         mounted: state.mounted,
         overrides: state.overrides,
         layers: state.layers,
+        workflowDefs: state.workflowDefs,
         rebuild: () => buildImpl(state)
       };
       const mod = {
@@ -433,7 +443,8 @@ function make2(id, def, extend) {
         return createModule({
           mounted: next.mounted,
           overrides: next.overrides,
-          layers: current.layers
+          layers: current.layers,
+          workflowDefs: current.workflowDefs
         });
       };
       mod.withLayer = (layer) => {
@@ -441,18 +452,70 @@ function make2(id, def, extend) {
         return createModule({
           mounted: current.mounted,
           overrides: current.overrides,
-          layers: [...current.layers, layer]
+          layers: [...current.layers, layer],
+          workflowDefs: current.workflowDefs
         });
       };
       mod.withLayers = (...layers) => layers.reduce((acc, layer) => acc.withLayer(layer), mod);
+      mod.withWorkflow = (workflow) => {
+        const install = workflow?.install;
+        const logic = typeof install === "function" ? install(mod.tag) : installOne({ moduleTag: mod.tag, program: workflow });
+        const current = mod[MODULE_INTERNAL];
+        const next = mountLogicUnit(current.mounted, current.overrides, { logic });
+        const nextWorkflowDefs = [...current.workflowDefs, workflow.def];
+        return createModule({
+          mounted: next.mounted,
+          overrides: next.overrides,
+          layers: current.layers,
+          workflowDefs: nextWorkflowDefs
+        });
+      };
+      mod.withWorkflows = (workflows) => {
+        if (!Array.isArray(workflows) || workflows.length === 0) return mod;
+        const logic = mountAll({ moduleTag: mod.tag, programs: workflows });
+        const current = mod[MODULE_INTERNAL];
+        const next = mountLogicUnit(current.mounted, current.overrides, { logic });
+        const nextWorkflowDefs = [...current.workflowDefs, ...workflows.map((w) => w.def)];
+        return createModule({
+          mounted: next.mounted,
+          overrides: next.overrides,
+          layers: current.layers,
+          workflowDefs: nextWorkflowDefs
+        });
+      };
       return mod;
     };
     return createModule({
       mounted: mountedResult.mounted,
       overrides: mountedResult.overrides,
-      layers: []
+      layers: [],
+      workflowDefs
     });
   };
+  const baseImplement = base.implement;
+  const withExtraLogics = (extraLogics, extraWorkflowDefs) => {
+    const next = { ...base };
+    next.withWorkflow = (workflow) => {
+      const install = workflow?.install;
+      const logic = typeof install === "function" ? install(next.tag) : installOne({ moduleTag: next.tag, program: workflow });
+      return withExtraLogics([...extraLogics, logic], [...extraWorkflowDefs, workflow.def]);
+    };
+    next.withWorkflows = (workflows) => {
+      if (!Array.isArray(workflows) || workflows.length === 0) return next;
+      const logic = mountAll({ moduleTag: next.tag, programs: workflows });
+      return withExtraLogics(
+        [...extraLogics, logic],
+        [...extraWorkflowDefs, ...workflows.map((w) => w.def)]
+      );
+    };
+    next.implement = (config) => {
+      const mergedLogics = [...config.logics ?? [], ...extraLogics];
+      return baseImplement({ ...config, logics: mergedLogics, __logix_workflowDefs: extraWorkflowDefs });
+    };
+    return next;
+  };
+  base.withWorkflow = (workflow) => withExtraLogics([], []).withWorkflow(workflow);
+  base.withWorkflows = (workflows) => withExtraLogics([], []).withWorkflows(workflows);
   return base;
 }
 var Manage = {
@@ -471,4 +534,4 @@ export {
   unwrapImpl,
   unwrapTag
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/Module.ts"],
  "sourcesContent": ["import { Context, Effect, FiberRef, Layer, Schema } from 'effect'\nimport * as Debug from './Debug.js'\nimport * as Logic from './Logic.js'\nimport * as ModuleTagNS from './ModuleTag.js'\nimport * as Action from './internal/action.js'\nimport { isDevEnv } from './internal/runtime/core/env.js'\nimport * as LogicUnitMetaInternal from './internal/runtime/core/LogicUnitMeta.js'\nimport type {\n  ActionsFromMap,\n  ActionOf,\n  AnyModuleShape,\n  AnySchema,\n  BoundApi,\n  ModuleLike,\n  ModuleHandle,\n  ModuleImpl,\n  ModuleImplementStateTransactionOptions,\n  ModuleLogic,\n  ModuleRuntime,\n  ModuleTag,\n  ModuleShape,\n  MutatorsFromMap,\n  ReducersFromMap,\n  StateChangeWithMeta,\n  StateCommitMeta,\n  StateCommitMode,\n  StateCommitPriority,\n  StateOf,\n} from './internal/module.js'\n\n/**\n * Module (definition object) public API.\n *\n * - Domain factories (Form / CRUD / ...) should return this object.\n * - `.tag` is the identity anchor (ModuleTag/Context.Tag), used by `$.use(...)` and Env injection.\n * - `.impl` is the assembly blueprint (ModuleImpl), consumed by React/Runtime entry points.\n * - `.logic()` only produces the logic value; `.withLogic/withLayer(s)` changes the runnable shape (immutable: returns a new object).\n */\n\nexport type {\n  AnySchema,\n  AnyModuleShape,\n  ModuleShape,\n  ModuleLogic,\n  ModuleImpl,\n  ModuleRuntime,\n  ModuleHandle,\n  ModuleTag,\n  StateOf,\n  ActionOf,\n  ActionsFromMap,\n  MutatorsFromMap,\n  ReducersFromMap,\n  BoundApi,\n  StateCommitMode,\n  StateCommitPriority,\n  StateCommitMeta,\n  StateChangeWithMeta,\n} from './internal/module.js'\n\nexport interface DevSource {\n  readonly file: string\n  readonly line: number\n  readonly column: number\n}\n\nexport interface ModuleDev {\n  readonly source?: DevSource\n}\n\nexport interface LogicUnitOptions {\n  readonly id?: string\n  readonly kind?: string\n  readonly name?: string\n  readonly source?: DevSource\n}\n\nexport interface MountedLogicUnitSummary {\n  readonly kind: string\n  readonly id: string\n  readonly derived?: boolean\n  readonly name?: string\n}\n\nexport interface ModuleDescriptor {\n  readonly id: string\n  readonly moduleId: string\n  readonly instanceId: string\n  readonly actionKeys: ReadonlyArray<string>\n  readonly logicUnits: ReadonlyArray<MountedLogicUnitSummary>\n  readonly schemaKeys?: ReadonlyArray<string>\n  readonly meta?: Record<string, unknown>\n  readonly source?: DevSource\n}\n\nexport type HandleExtendFn<Sh extends AnyModuleShape, Ext extends object> = (\n  runtime: ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>,\n  base: ModuleHandle<Sh>,\n) => Ext | (ModuleHandle<Sh> & Ext) | null | undefined\n\ntype LogicUnitMeta = LogicUnitMetaInternal.LogicUnitMeta\nconst attachLogicUnitMeta = <L extends object>(logic: L, meta: LogicUnitMeta): L =>\n  LogicUnitMetaInternal.attachLogicUnitMeta(logic, meta as any) as any\n\ntype NoInfer_<T> = [T][T extends any ? 0 : never]\n\ntype MountedLogicUnit<Sh extends AnyModuleShape> = {\n  readonly id: string\n  readonly derived: boolean\n  readonly kind: string\n  readonly name?: string\n  readonly source?: DevSource\n  readonly logic: ModuleLogic<Sh, any, any>\n  readonly origin?: {\n    readonly explicitId?: string\n    readonly defaultId?: string\n    readonly derivedBase?: string\n  }\n}\n\ntype LogicOverrideWarning = {\n  readonly id: string\n  readonly from: Pick<MountedLogicUnit<any>, 'kind' | 'name' | 'source'> & {\n    readonly order: number\n  }\n  readonly to: Pick<MountedLogicUnit<any>, 'kind' | 'name' | 'source'> & {\n    readonly order: number\n  }\n}\n\ntype ModuleInternal<Id extends string, Sh extends AnyModuleShape> = {\n  readonly initial: StateOf<Sh>\n  readonly imports?: ReadonlyArray<Layer.Layer<any, any, any> | ModuleImpl<any, AnyModuleShape, any>>\n  readonly processes?: ReadonlyArray<Effect.Effect<void, any, any>>\n  readonly stateTransaction?: ModuleImplementStateTransactionOptions\n  readonly mounted: ReadonlyArray<MountedLogicUnit<Sh>>\n  readonly overrides: ReadonlyArray<LogicOverrideWarning>\n  readonly layers: ReadonlyArray<Layer.Layer<any, never, any>>\n  readonly rebuild: () => ModuleImpl<Id, Sh, any>\n}\n\nconst MODULE_INTERNAL = Symbol.for('logix.module.internal')\nconst MODULE_DECLARED_EFFECTS = Symbol.for('logix.module.effects.declared')\n\ntype ModuleDefBase<\n  Id extends string = string,\n  Sh extends AnyModuleShape = AnyModuleShape,\n  Ext extends object = {},\n> = ModuleLike<Id, Sh, Ext> & {\n  readonly shape: Sh\n  readonly stateSchema: Sh['stateSchema']\n  readonly actionSchema: Sh['actionSchema']\n  /**\n   * Raw ActionMap (tag -> payload schema).\n   * - Mainly for DX/reflection; runtime contract is still based on tag.shape/actionSchema.\n   */\n  readonly actions: Sh['actionMap']\n  /**\n   * Raw reducers (if provided by the definition).\n   * - Mainly for DX/reflection; runtime normalizes them into primary reducers inside ModuleTag/ModuleFactory.\n   */\n  readonly reducers?: ReducersFromMap<Sh['stateSchema'], Sh['actionMap']>\n  readonly live: <R = never, E = never>(\n    initial: StateOf<Sh>,\n    ...logics: Array<ModuleLogic<Sh, R, E>>\n  ) => Layer.Layer<ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>, E, R>\n  readonly schemas?: Record<string, unknown>\n  readonly meta?: Record<string, unknown>\n  readonly services?: Record<string, Context.Tag<any, any>>\n  readonly dev?: ModuleDev\n  readonly logic: <R = never, E = unknown>(\n    build: (\n      api: BoundApi<Sh, R> & {\n        readonly self: Logic.Of<Sh, R, ModuleHandle<Sh> & Ext, never>\n      },\n    ) => ModuleLogic<Sh, R, E>,\n    options?: LogicUnitOptions,\n  ) => ModuleLogic<Sh, R, E>\n}\n\nexport type AnyModule = {\n  readonly _kind: 'Module'\n  readonly id: string\n  readonly tag: ModuleTag<string, AnyModuleShape>\n  readonly impl: ModuleImpl<any, AnyModuleShape, any>\n  readonly actions: Record<string, AnySchema>\n  readonly reducers?: Record<string, unknown>\n  readonly schemas?: Record<string, unknown>\n  readonly meta?: Record<string, unknown>\n  readonly services?: Record<string, Context.Tag<any, any>>\n  readonly dev?: ModuleDev\n}\n\nexport type Module<Id extends string, Sh extends AnyModuleShape, Ext extends object = {}, R = never> = ModuleDefBase<\n  Id,\n  Sh,\n  Ext\n> & {\n  readonly _kind: 'Module'\n  readonly impl: ModuleImpl<Id, Sh, R>\n  readonly withLogic: (logic: ModuleLogic<Sh, any, any>, options?: LogicUnitOptions) => Module<Id, Sh, Ext, R>\n  readonly withLogics: (...inputs: ReadonlyArray<MountInput<Sh>>) => Module<Id, Sh, Ext, R>\n  readonly withLayer: (layer: Layer.Layer<any, never, any>) => Module<Id, Sh, Ext, R>\n  readonly withLayers: (...layers: ReadonlyArray<Layer.Layer<any, never, any>>) => Module<Id, Sh, Ext, R>\n}\n\nexport type ModuleDef<Id extends string, Sh extends AnyModuleShape, Ext extends object = {}> = ModuleDefBase<\n  Id,\n  Sh,\n  Ext\n> & {\n  readonly _kind: 'ModuleDef'\n  readonly implement: <R = never>(config: {\n    readonly initial: StateOf<Sh>\n    readonly logics?: Array<ModuleLogic<Sh, R, any>>\n    readonly imports?: ReadonlyArray<Layer.Layer<any, any, any> | ModuleImpl<any, AnyModuleShape, any>>\n    readonly processes?: ReadonlyArray<Effect.Effect<void, any, any>>\n    readonly stateTransaction?: ModuleImplementStateTransactionOptions\n  }) => Module<Id, Sh, Ext, R>\n}\n\nexport const is = (value: unknown): value is ModuleDefBase => {\n  if (!value || typeof value !== 'object') return false\n  const kind = (value as any)._kind\n  if (kind !== 'ModuleDef' && kind !== 'Module') return false\n  return Context.isTag((value as any).tag)\n}\n\nexport const hasImpl = (value: unknown): value is AnyModule => {\n  if (!is(value)) return false\n  return (\n    typeof (value as any).impl === 'object' && (value as any).impl !== null && (value as any).impl._tag === 'ModuleImpl'\n  )\n}\n\nexport const unwrapTag = <Id extends string, Sh extends AnyModuleShape>(\n  module: ModuleLike<Id, Sh, any>,\n): ModuleTag<Id, Sh> => module.tag\n\nexport const unwrapImpl = <Id extends string, Sh extends AnyModuleShape>(\n  module: AnyModule & { readonly id: Id; readonly tag: ModuleTag<Id, Sh> },\n): ModuleImpl<Id, Sh, any> => (module as any).impl as ModuleImpl<Id, Sh, any>\n\nexport const descriptor = (\n  module: ModuleDefBase<string, AnyModuleShape, any>,\n  runtime: ModuleRuntime<any, any>,\n): ModuleDescriptor => {\n  const actionKeys = Object.keys((module.tag as any).shape?.actionMap ?? {})\n\n  const internal = (module as any)[MODULE_INTERNAL] as ModuleInternal<string, AnyModuleShape> | undefined\n\n  const logicUnits: ReadonlyArray<MountedLogicUnitSummary> = internal\n    ? internal.mounted.map((u) => ({\n        kind: u.kind,\n        id: u.id,\n        derived: u.derived ? true : undefined,\n        name: u.name,\n      }))\n    : []\n\n  const schemaKeys = module.schemas && typeof module.schemas === 'object' ? Object.keys(module.schemas) : undefined\n\n  const meta = module.meta && typeof module.meta === 'object' ? module.meta : undefined\n\n  const source = module.dev?.source\n\n  return {\n    id: module.id,\n    moduleId: String(runtime.moduleId),\n    instanceId: String(runtime.instanceId),\n    actionKeys,\n    logicUnits,\n    schemaKeys,\n    meta,\n    source,\n  }\n}\n\ntype MountInput<Sh extends AnyModuleShape> =\n  | ModuleLogic<Sh, any, any>\n  | readonly [ModuleLogic<Sh, any, any>, LogicUnitOptions]\n\nconst normalizeMountInput = <Sh extends AnyModuleShape>(\n  input: MountInput<Sh>,\n): { readonly logic: ModuleLogic<Sh, any, any>; readonly options?: LogicUnitOptions } => {\n  if (Array.isArray(input)) {\n    return { logic: input[0], options: input[1] }\n  }\n  return { logic: input as ModuleLogic<Sh, any, any> }\n}\n\nconst resolveLogicUnit = <Sh extends AnyModuleShape>(\n  existing: ReadonlyArray<MountedLogicUnit<Sh>>,\n  logic: ModuleLogic<Sh, any, any>,\n  options?: LogicUnitOptions,\n): MountedLogicUnit<Sh> => {\n  const meta = LogicUnitMetaInternal.getLogicUnitMeta(logic)\n  const explicitId = options?.id\n  const defaultId = meta?.id\n\n  const kind = (options?.kind ?? meta?.kind ?? 'user').trim() || 'user'\n  const name =\n    options?.name ?? meta?.name ?? (typeof defaultId === 'string' && defaultId.length > 0 ? defaultId : undefined)\n\n  const source = options?.source ?? meta?.source\n\n  if (typeof explicitId === 'string' && explicitId.trim().length > 0) {\n    return {\n      id: explicitId.trim(),\n      derived: false,\n      kind,\n      name,\n      source,\n      logic,\n      origin: { explicitId: explicitId.trim(), defaultId },\n    }\n  }\n\n  if (typeof defaultId === 'string' && defaultId.trim().length > 0) {\n    return {\n      id: defaultId.trim(),\n      derived: false,\n      kind,\n      name,\n      source,\n      logic,\n      origin: { defaultId: defaultId.trim() },\n    }\n  }\n\n  // Derived id: reproducible within the same composition order.\n  const used = new Set(existing.map((u) => u.id))\n  const baseRaw = (name ?? kind ?? 'logic').trim() || 'logic'\n  const base = baseRaw.replace(/\\s+/g, '_')\n\n  let n = 1\n  while (used.has(`${base}#${n}`)) n += 1\n  const derivedId = `${base}#${n}`\n\n  return {\n    id: derivedId,\n    derived: true,\n    kind,\n    name: name ?? baseRaw,\n    source,\n    logic,\n    origin: { derivedBase: baseRaw },\n  }\n}\n\nconst mountLogicUnit = <Sh extends AnyModuleShape>(\n  current: ReadonlyArray<MountedLogicUnit<Sh>>,\n  overrides: ReadonlyArray<LogicOverrideWarning>,\n  input: { readonly logic: ModuleLogic<Sh, any, any>; readonly options?: LogicUnitOptions },\n): {\n  readonly mounted: ReadonlyArray<MountedLogicUnit<Sh>>\n  readonly overrides: ReadonlyArray<LogicOverrideWarning>\n} => {\n  const nextUnit = resolveLogicUnit(current, input.logic, input.options)\n  // Write the resolved verdict back to logic meta for provenance/diagnostics (aligned with 022-module).\n  LogicUnitMetaInternal.updateLogicUnitMeta(nextUnit.logic as any, {\n    resolvedId: nextUnit.id,\n    resolvedIdKind: nextUnit.derived ? 'derived' : 'explicit',\n    resolvedKind: nextUnit.kind,\n    resolvedName: nextUnit.name,\n    resolvedSource: nextUnit.source as any,\n  })\n\n  const prevIndex = current.findIndex((u) => u.id === nextUnit.id)\n  if (prevIndex < 0) {\n    return { mounted: [...current, nextUnit], overrides }\n  }\n\n  const prev = current[prevIndex]\n  const nextMounted = [...current.slice(0, prevIndex), ...current.slice(prevIndex + 1), nextUnit]\n\n  const nextOverrides: ReadonlyArray<LogicOverrideWarning> = [\n    ...overrides,\n    {\n      id: nextUnit.id,\n      from: {\n        kind: prev.kind,\n        name: prev.name,\n        source: prev.source,\n        order: prevIndex,\n      },\n      to: {\n        kind: nextUnit.kind,\n        name: nextUnit.name,\n        source: nextUnit.source,\n        order: nextMounted.length - 1,\n      },\n    },\n  ]\n\n  return { mounted: nextMounted, overrides: nextOverrides }\n}\n\nconst formatSource = (source?: DevSource): string => {\n  if (!source) return 'unknown'\n  return `${source.file}:${source.line}:${source.column}`\n}\n\nconst makeOverrideDiagnosticsLogic = (\n  tag: ModuleTag<any, AnyModuleShape>,\n  overrides: ReadonlyArray<LogicOverrideWarning>,\n): ModuleLogic<any, any, never> => {\n  if (overrides.length === 0) {\n    return Effect.void as any\n  }\n\n  return tag.logic(() =>\n    Effect.gen(function* () {\n      if (!isDevEnv()) return\n\n      const diagnosticsLevel = yield* FiberRef.get(Debug.internal.currentDiagnosticsLevel as any)\n      if (diagnosticsLevel === 'off') return\n\n      const runtime = (yield* tag) as ModuleRuntime<any, any>\n\n      yield* Effect.forEach(\n        overrides,\n        (o) =>\n          Debug.record({\n            type: 'diagnostic',\n            moduleId: runtime.moduleId,\n            instanceId: runtime.instanceId,\n            code: 'module_logic::override',\n            severity: 'warning',\n            message: `logicUnitId \"${o.id}\" overridden (last-write-wins).`,\n            hint:\n              `from(#${o.from.order}) kind=${o.from.kind} name=${o.from.name ?? 'unknown'} source=${formatSource(o.from.source)}\\n` +\n              `to(#${o.to.order}) kind=${o.to.kind} name=${o.to.name ?? 'unknown'} source=${formatSource(o.to.source)}`,\n            kind: 'logic_unit_override',\n          }),\n        { discard: true },\n      )\n    }),\n  )\n}\n\nconst makeDeclaredEffectsLogic = (\n  tag: ModuleTag<any, AnyModuleShape>,\n  effects: Record<string, ReadonlyArray<unknown> | undefined> | undefined,\n  moduleId: string,\n): ModuleLogic<any, any, never> => {\n  if (!effects || typeof effects !== 'object' || Object.keys(effects).length === 0) {\n    return Effect.void as any\n  }\n\n  const logic = tag.logic(($) => ({\n    setup: Effect.gen(function* () {\n      const actions = ($ as any).actions as Record<string, Action.AnyActionToken>\n      const effectApi = ($ as any).effect as\n        | ((token: unknown, handler: (payload: unknown) => Effect.Effect<void, any, any>) => Effect.Effect<void, never, any>)\n        | undefined\n      if (typeof effectApi !== 'function') return\n\n      const wrappedHandlers = new WeakMap<(...args: any[]) => any, (payload: unknown) => Effect.Effect<void, any, any>>()\n\n      for (const actionTag of Object.keys(effects).sort()) {\n        const token = actions[actionTag]\n        if (!Action.isActionToken(token)) continue\n\n        const handlers = effects[actionTag]\n        if (!Array.isArray(handlers)) continue\n\n        for (const handler of handlers) {\n          if (typeof handler !== 'function') continue\n          let wrapped = wrappedHandlers.get(handler)\n          if (!wrapped) {\n            wrapped = (payload: unknown) => (handler as any)($, payload)\n            wrappedHandlers.set(handler, wrapped)\n          }\n          yield* effectApi(token, wrapped)\n        }\n      }\n    }),\n    run: Effect.void,\n  })) as ModuleLogic<any, any, never>\n\n  LogicUnitMetaInternal.attachLogicUnitMeta(logic as any, {\n    id: '__logix_internal:effects:declared',\n    kind: 'internal',\n    name: 'effects:declared',\n    moduleId,\n  })\n\n  return logic\n}\n\nconst makeLogicFactory = <Id extends string, Sh extends AnyModuleShape, Ext extends object>(\n  selfModule: ModuleDefBase<Id, Sh, Ext>,\n): ModuleDefBase<Id, Sh, Ext>['logic'] => {\n  const tag = selfModule.tag\n  return (build, options) => {\n    const eff = tag.logic((api) => {\n      const withSelf = Object.create(api) as BoundApi<Sh, any> & {\n        readonly self: Logic.Of<Sh, any, ModuleHandle<Sh> & Ext, never>\n      }\n      ;(withSelf as any).self = Effect.suspend(() => (api as any).use(selfModule as any))\n      return build(withSelf as any)\n    }) as ModuleLogic<Sh, any, any>\n\n    const meta: LogicUnitMeta = {\n      id: options?.id,\n      kind: options?.kind,\n      name: options?.name,\n      source: options?.source,\n      moduleId: selfModule.id,\n    }\n\n    return attachLogicUnitMeta(eff as any, meta) as any\n  }\n}\n\ntype MakeDef<Id extends string, SSchema extends AnySchema, AMap extends Action.ActionDefs> = {\n  readonly state: SSchema\n  readonly actions: AMap\n  readonly reducers?: ReducersFromMap<SSchema, NoInfer_<AMap>>\n  readonly immerReducers?: MutatorsFromMap<SSchema, NoInfer_<AMap>>\n  readonly effects?: EffectsFromMap<NoInfer_<AMap>>\n  readonly traits?: unknown\n  readonly schemas?: Record<string, unknown>\n  readonly meta?: Record<string, unknown>\n  readonly services?: Record<string, Context.Tag<any, any>>\n  readonly dev?: ModuleDev\n}\n\ntype AnyActionMap = Action.ActionDefs\ntype EmptyActionMap = Record<never, never>\n\ntype PayloadOfActionDef<V> = V extends Schema.Schema<any, any, any>\n  ? Schema.Schema.Type<V>\n  : V extends Action.ActionToken<any, infer P, any>\n    ? P\n    : never\n\ntype DeclaredEffectHandler<Payload> = ($: unknown, payload: Payload) => Effect.Effect<void, any, any>\n\ntype EffectsFromMap<M extends AnyActionMap> = {\n  readonly [K in keyof M]?: ReadonlyArray<DeclaredEffectHandler<PayloadOfActionDef<M[K]>>>\n}\n\ntype MergeActionMap<Base extends AnyActionMap, Ext extends AnyActionMap> = {\n  readonly [K in keyof Base | keyof Ext]: K extends keyof Ext ? Ext[K] : K extends keyof Base ? Base[K] : never\n}\n\n/**\n * Module.make \"app-side extension/override\" parameters (a two-stage responsibility split: domain library author \u2192 app developer).\n *\n * - `actions`: add-only (cannot override existing action schema); used to extend actionMap.\n * - `reducers`: add and override; used to override domain reducers or provide reducers for new actions.\n * - Other reflective fields (schemas/meta/services/dev) are shallow-merged (last-write-wins).\n */\nexport type MakeExtendDef<\n  SSchema extends AnySchema,\n  BaseActions extends AnyActionMap,\n  ExtActions extends AnyActionMap = EmptyActionMap,\n> = {\n  readonly actions?: ExtActions\n  readonly reducers?: ReducersFromMap<SSchema, MergeActionMap<BaseActions, ExtActions>>\n  readonly immerReducers?: MutatorsFromMap<SSchema, MergeActionMap<BaseActions, ExtActions>>\n  readonly effects?: EffectsFromMap<MergeActionMap<BaseActions, ExtActions>>\n  readonly schemas?: Record<string, unknown>\n  readonly meta?: Record<string, unknown>\n  readonly services?: Record<string, Context.Tag<any, any>>\n  readonly dev?: ModuleDev\n}\n\nconst mergeMakeDef = <\n  Id extends string,\n  SSchema extends AnySchema,\n  BaseActions extends AnyActionMap,\n  ExtActions extends AnyActionMap,\n>(\n  base: MakeDef<Id, SSchema, BaseActions>,\n  extend?: MakeExtendDef<SSchema, BaseActions, ExtActions>,\n): MakeDef<Id, SSchema, MergeActionMap<BaseActions, ExtActions>> => {\n  const baseActions = base.actions as Record<string, AnySchema>\n  const extActions = (extend?.actions ?? {}) as Record<string, AnySchema>\n\n  for (const key of Object.keys(extActions)) {\n    if (key in baseActions && baseActions[key] !== extActions[key]) {\n      throw new Error(\n        `[Logix.Module.make] action key \"${key}\" already exists; overriding action schemas is not supported (define a new action tag instead).`,\n      )\n    }\n  }\n\n  const mergedActionDefs = { ...(base.actions as any), ...(extend?.actions as any) } as MergeActionMap<\n    BaseActions,\n    ExtActions\n  >\n  const actions = Action.normalizeActions(mergedActionDefs)\n\n  const mergeEffects = (): Record<string, ReadonlyArray<unknown>> | undefined => {\n    const baseEffects = (base.effects ?? {}) as Record<string, unknown>\n    const extEffects = (extend?.effects ?? {}) as Record<string, unknown>\n\n    const keys = Array.from(new Set([...Object.keys(baseEffects), ...Object.keys(extEffects)])).sort()\n    if (keys.length === 0) return undefined\n\n    const out: Record<string, ReadonlyArray<unknown>> = {}\n    for (const key of keys) {\n      if (!(key in actions)) {\n        throw new Error(`[Logix.Module.make] effect key \"${key}\" does not exist in actionMap.`)\n      }\n\n      const baseValue = baseEffects[key]\n      const extValue = extEffects[key]\n      const baseArr = Array.isArray(baseValue) ? baseValue : baseValue === undefined ? [] : null\n      const extArr = Array.isArray(extValue) ? extValue : extValue === undefined ? [] : null\n\n      if (baseArr === null) {\n        throw new Error(`[Logix.Module.make] effects[\"${key}\"] must be an array of handlers.`)\n      }\n      if (extArr === null) {\n        throw new Error(`[Logix.Module.make] effects[\"${key}\"] must be an array of handlers.`)\n      }\n\n      const merged = [...baseArr, ...extArr].filter((h) => h !== undefined)\n      for (const h of merged) {\n        if (typeof h !== 'function') {\n          throw new Error(`[Logix.Module.make] effects[\"${key}\"] handlers must be functions.`)\n        }\n      }\n\n      if (merged.length > 0) {\n        out[key] = merged as ReadonlyArray<unknown>\n      }\n    }\n\n    return Object.keys(out).length > 0 ? out : undefined\n  }\n\n  const effects = mergeEffects()\n\n  const wrapImmerReducers = (mutators?: Record<string, ((draft: unknown, payload: unknown) => void) | undefined>) => {\n    if (!mutators) return {}\n    const out: Record<string, unknown> = {}\n    for (const key of Object.keys(mutators)) {\n      const mutator = mutators[key]\n      if (typeof mutator !== 'function') continue\n      out[key] = ModuleTagNS.Reducer.mutate(mutator as any)\n    }\n    return out\n  }\n\n  const reducers = {\n    ...wrapImmerReducers(base.immerReducers as any),\n    ...(base.reducers ?? {}),\n    ...wrapImmerReducers(extend?.immerReducers as any),\n    ...(extend?.reducers ?? {}),\n  } as Record<string, unknown>\n\n  for (const key of Object.keys(reducers)) {\n    if (!(key in actions)) {\n      throw new Error(`[Logix.Module.make] reducer key \"${key}\" does not exist in actionMap.`)\n    }\n  }\n\n  const schemas =\n    base.schemas || extend?.schemas ? { ...(base.schemas ?? {}), ...(extend?.schemas ?? {}) } : undefined\n\n  const meta = base.meta || extend?.meta ? { ...(base.meta ?? {}), ...(extend?.meta ?? {}) } : undefined\n\n  const services =\n    base.services || extend?.services ? { ...(base.services ?? {}), ...(extend?.services ?? {}) } : undefined\n\n  const dev = base.dev || extend?.dev ? { ...(base.dev ?? {}), ...(extend?.dev ?? {}) } : undefined\n\n  return {\n    ...base,\n    actions: actions as any,\n    reducers: Object.keys(reducers).length > 0 ? (reducers as any) : undefined,\n    effects: effects as any,\n    schemas,\n    meta,\n    services,\n    dev,\n  } as any\n}\n\nexport const Reducer = ModuleTagNS.Reducer\n\nexport type Shape<S extends AnySchema, M extends Action.ActionDefs> = ModuleShape<\n  S,\n  Schema.Schema<ActionsFromMap<Action.NormalizedActionTokens<M>>>,\n  Action.NormalizedActionTokens<M>\n>\n\nexport function make<\n  Id extends string,\n  SSchema extends AnySchema,\n  AMap extends Action.ActionDefs,\n  Ext extends object = {},\n>(\n  id: Id,\n  def: MakeDef<Id, SSchema, AMap>,\n): ModuleDef<\n  Id,\n  ModuleShape<\n    SSchema,\n    Schema.Schema<ActionsFromMap<Action.NormalizedActionTokens<AMap>>>,\n    Action.NormalizedActionTokens<AMap>\n  >,\n  Ext\n>\n\nexport function make<\n  Id extends string,\n  SSchema extends AnySchema,\n  AMap extends Action.ActionDefs,\n  Ext extends object = {},\n  ExtActions extends Action.ActionDefs = EmptyActionMap,\n>(\n  id: Id,\n  def: MakeDef<Id, SSchema, AMap>,\n  extend: MakeExtendDef<SSchema, NoInfer_<AMap>, ExtActions>,\n): ModuleDef<\n  Id,\n  ModuleShape<\n    SSchema,\n    Schema.Schema<ActionsFromMap<Action.NormalizedActionTokens<MergeActionMap<AMap, ExtActions>>>>,\n    Action.NormalizedActionTokens<MergeActionMap<AMap, ExtActions>>\n  >,\n  Ext\n>\n\nexport function make(id: any, def: any, extend?: any): any {\n  const merged = mergeMakeDef(def as any, extend as any)\n\n  const tag = ModuleTagNS.make(id, {\n    state: merged.state,\n    actions: merged.actions,\n    reducers: merged.reducers,\n    traits: merged.traits,\n  }) as unknown as ModuleTag<any, AnyModuleShape>\n\n  if (merged.effects && typeof merged.effects === 'object' && Object.keys(merged.effects).length > 0) {\n    Object.defineProperty(tag as any, MODULE_DECLARED_EFFECTS, {\n      value: merged.effects,\n      enumerable: false,\n      configurable: true,\n      writable: false,\n    })\n  }\n\n  const base: any = {\n    _kind: 'ModuleDef' as const,\n    id,\n    tag,\n    shape: tag.shape,\n    stateSchema: tag.stateSchema,\n    actionSchema: tag.actionSchema,\n    actions: merged.actions,\n    reducers: merged.reducers,\n    effects: merged.effects,\n    live: tag.live,\n    schemas: merged.schemas,\n    meta: merged.meta,\n    services: merged.services,\n    dev: merged.dev,\n  }\n\n  base.logic = makeLogicFactory(base as any)\n\n  base.implement = (config: any) => {\n    type Sh = AnyModuleShape\n\n    const initial = config.initial as any\n    const imports = config.imports as any\n    const processes = config.processes as any\n    const stateTransaction = config.stateTransaction as any\n\n    const mountedResult = (config.logics ?? []).reduce(\n      (\n        acc: {\n          mounted: ReadonlyArray<MountedLogicUnit<any>>\n          overrides: ReadonlyArray<LogicOverrideWarning>\n        },\n        logic: any,\n      ) => mountLogicUnit(acc.mounted, acc.overrides, { logic }),\n      { mounted: [] as const, overrides: [] as const },\n    )\n\n    type State = {\n      readonly mounted: ReadonlyArray<MountedLogicUnit<any>>\n      readonly overrides: ReadonlyArray<LogicOverrideWarning>\n      readonly layers: ReadonlyArray<Layer.Layer<any, never, any>>\n    }\n\n    const buildImpl = (state: State): ModuleImpl<any, AnyModuleShape, any> => {\n      const diagnosticsLogic = makeOverrideDiagnosticsLogic(tag as any, state.overrides)\n      const declaredEffectsLogic = makeDeclaredEffectsLogic(tag as any, merged.effects, id)\n      const allLogics = [...state.mounted.map((u) => u.logic), declaredEffectsLogic, diagnosticsLogic]\n\n      let impl = (tag as any).implement({\n        initial,\n        logics: allLogics,\n        imports,\n        processes,\n        stateTransaction,\n      }) as ModuleImpl<any, AnyModuleShape, any>\n\n      for (const layer of state.layers) {\n        impl = impl.withLayer(layer)\n      }\n\n      return impl\n    }\n\n    const createModule = (state: State): any => {\n      const internal: ModuleInternal<any, AnyModuleShape> = {\n        initial,\n        imports,\n        processes,\n        stateTransaction,\n        mounted: state.mounted,\n        overrides: state.overrides,\n        layers: state.layers,\n        rebuild: () => buildImpl(state),\n      }\n\n      const mod: any = {\n        ...base,\n        _kind: 'Module' as const,\n        impl: buildImpl(state),\n      }\n\n      Object.defineProperty(mod, MODULE_INTERNAL, {\n        value: internal,\n        enumerable: false,\n        configurable: true,\n      })\n\n      mod.logic = makeLogicFactory(mod)\n\n      mod.withLogic = (logic: any, options?: LogicUnitOptions) => mod.withLogics([logic, options] as any)\n\n      mod.withLogics = (...inputs: ReadonlyArray<MountInput<any>>) => {\n        const current = (mod as any)[MODULE_INTERNAL] as ModuleInternal<any, AnyModuleShape>\n        const normalized = inputs.map(normalizeMountInput)\n        const next = normalized.reduce((acc, item) => mountLogicUnit(acc.mounted, acc.overrides, item as any), {\n          mounted: current.mounted,\n          overrides: current.overrides,\n        })\n\n        return createModule({\n          mounted: next.mounted,\n          overrides: next.overrides,\n          layers: current.layers,\n        })\n      }\n\n      mod.withLayer = (layer: Layer.Layer<any, never, any>) => {\n        const current = (mod as any)[MODULE_INTERNAL] as ModuleInternal<any, AnyModuleShape>\n        return createModule({\n          mounted: current.mounted,\n          overrides: current.overrides,\n          layers: [...current.layers, layer],\n        })\n      }\n\n      mod.withLayers = (...layers: ReadonlyArray<Layer.Layer<any, never, any>>) =>\n        layers.reduce((acc, layer) => acc.withLayer(layer), mod as any)\n\n      return mod as any\n    }\n\n    return createModule({\n      mounted: mountedResult.mounted,\n      overrides: mountedResult.overrides,\n      layers: [],\n    })\n  }\n\n  return base\n}\n\nexport const Manage = {\n  make: <D extends (...args: any[]) => AnyModule>(config: {\n    readonly kind?: string\n    readonly define: D\n  }): { readonly kind?: string; readonly make: D } => ({\n    kind: config.kind,\n    make: config.define,\n  }),\n} as const\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAS,SAAS,QAAQ,gBAA+B;AAqGzD,IAAMA,uBAAsB,CAAmB,OAAU,SACjC,oBAAoB,OAAO,IAAW;AAuC9D,IAAM,kBAAkB,uBAAO,IAAI,uBAAuB;AAC1D,IAAM,0BAA0B,uBAAO,IAAI,+BAA+B;AA+EnE,IAAM,KAAK,CAAC,UAA2C;AAC5D,MAAI,CAAC,SAAS,OAAO,UAAU,SAAU,QAAO;AAChD,QAAM,OAAQ,MAAc;AAC5B,MAAI,SAAS,eAAe,SAAS,SAAU,QAAO;AACtD,SAAO,QAAQ,MAAO,MAAc,GAAG;AACzC;AAEO,IAAM,UAAU,CAAC,UAAuC;AAC7D,MAAI,CAAC,GAAG,KAAK,EAAG,QAAO;AACvB,SACE,OAAQ,MAAc,SAAS,YAAa,MAAc,SAAS,QAAS,MAAc,KAAK,SAAS;AAE5G;AAEO,IAAM,YAAY,CACvB,WACsB,OAAO;AAExB,IAAM,aAAa,CACxB,WAC6B,OAAe;AAEvC,IAAM,aAAa,CACxB,QACA,YACqB;AACrB,QAAM,aAAa,OAAO,KAAM,OAAO,IAAY,OAAO,aAAa,CAAC,CAAC;AAEzE,QAAMC,YAAY,OAAe,eAAe;AAEhD,QAAM,aAAqDA,YACvDA,UAAS,QAAQ,IAAI,CAAC,OAAO;AAAA,IAC3B,MAAM,EAAE;AAAA,IACR,IAAI,EAAE;AAAA,IACN,SAAS,EAAE,UAAU,OAAO;AAAA,IAC5B,MAAM,EAAE;AAAA,EACV,EAAE,IACF,CAAC;AAEL,QAAM,aAAa,OAAO,WAAW,OAAO,OAAO,YAAY,WAAW,OAAO,KAAK,OAAO,OAAO,IAAI;AAExG,QAAM,OAAO,OAAO,QAAQ,OAAO,OAAO,SAAS,WAAW,OAAO,OAAO;AAE5E,QAAM,SAAS,OAAO,KAAK;AAE3B,SAAO;AAAA,IACL,IAAI,OAAO;AAAA,IACX,UAAU,OAAO,QAAQ,QAAQ;AAAA,IACjC,YAAY,OAAO,QAAQ,UAAU;AAAA,IACrC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAMA,IAAM,sBAAsB,CAC1B,UACuF;AACvF,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,WAAO,EAAE,OAAO,MAAM,CAAC,GAAG,SAAS,MAAM,CAAC,EAAE;AAAA,EAC9C;AACA,SAAO,EAAE,OAAO,MAAmC;AACrD;AAEA,IAAM,mBAAmB,CACvB,UACA,OACA,YACyB;AACzB,QAAM,OAA6B,iBAAiB,KAAK;AACzD,QAAM,aAAa,SAAS;AAC5B,QAAM,YAAY,MAAM;AAExB,QAAM,QAAQ,SAAS,QAAQ,MAAM,QAAQ,QAAQ,KAAK,KAAK;AAC/D,QAAM,OACJ,SAAS,QAAQ,MAAM,SAAS,OAAO,cAAc,YAAY,UAAU,SAAS,IAAI,YAAY;AAEtG,QAAM,SAAS,SAAS,UAAU,MAAM;AAExC,MAAI,OAAO,eAAe,YAAY,WAAW,KAAK,EAAE,SAAS,GAAG;AAClE,WAAO;AAAA,MACL,IAAI,WAAW,KAAK;AAAA,MACpB,SAAS;AAAA,MACT;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,QAAQ,EAAE,YAAY,WAAW,KAAK,GAAG,UAAU;AAAA,IACrD;AAAA,EACF;AAEA,MAAI,OAAO,cAAc,YAAY,UAAU,KAAK,EAAE,SAAS,GAAG;AAChE,WAAO;AAAA,MACL,IAAI,UAAU,KAAK;AAAA,MACnB,SAAS;AAAA,MACT;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,QAAQ,EAAE,WAAW,UAAU,KAAK,EAAE;AAAA,IACxC;AAAA,EACF;AAGA,QAAM,OAAO,IAAI,IAAI,SAAS,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;AAC9C,QAAM,WAAW,QAAQ,QAAQ,SAAS,KAAK,KAAK;AACpD,QAAM,OAAO,QAAQ,QAAQ,QAAQ,GAAG;AAExC,MAAI,IAAI;AACR,SAAO,KAAK,IAAI,GAAG,IAAI,IAAI,CAAC,EAAE,EAAG,MAAK;AACtC,QAAM,YAAY,GAAG,IAAI,IAAI,CAAC;AAE9B,SAAO;AAAA,IACL,IAAI;AAAA,IACJ,SAAS;AAAA,IACT;AAAA,IACA,MAAM,QAAQ;AAAA,IACd;AAAA,IACA;AAAA,IACA,QAAQ,EAAE,aAAa,QAAQ;AAAA,EACjC;AACF;AAEA,IAAM,iBAAiB,CACrB,SACA,WACA,UAIG;AACH,QAAM,WAAW,iBAAiB,SAAS,MAAM,OAAO,MAAM,OAAO;AAErE,EAAsB,oBAAoB,SAAS,OAAc;AAAA,IAC/D,YAAY,SAAS;AAAA,IACrB,gBAAgB,SAAS,UAAU,YAAY;AAAA,IAC/C,cAAc,SAAS;AAAA,IACvB,cAAc,SAAS;AAAA,IACvB,gBAAgB,SAAS;AAAA,EAC3B,CAAC;AAED,QAAM,YAAY,QAAQ,UAAU,CAAC,MAAM,EAAE,OAAO,SAAS,EAAE;AAC/D,MAAI,YAAY,GAAG;AACjB,WAAO,EAAE,SAAS,CAAC,GAAG,SAAS,QAAQ,GAAG,UAAU;AAAA,EACtD;AAEA,QAAM,OAAO,QAAQ,SAAS;AAC9B,QAAM,cAAc,CAAC,GAAG,QAAQ,MAAM,GAAG,SAAS,GAAG,GAAG,QAAQ,MAAM,YAAY,CAAC,GAAG,QAAQ;AAE9F,QAAM,gBAAqD;AAAA,IACzD,GAAG;AAAA,IACH;AAAA,MACE,IAAI,SAAS;AAAA,MACb,MAAM;AAAA,QACJ,MAAM,KAAK;AAAA,QACX,MAAM,KAAK;AAAA,QACX,QAAQ,KAAK;AAAA,QACb,OAAO;AAAA,MACT;AAAA,MACA,IAAI;AAAA,QACF,MAAM,SAAS;AAAA,QACf,MAAM,SAAS;AAAA,QACf,QAAQ,SAAS;AAAA,QACjB,OAAO,YAAY,SAAS;AAAA,MAC9B;AAAA,IACF;AAAA,EACF;AAEA,SAAO,EAAE,SAAS,aAAa,WAAW,cAAc;AAC1D;AAEA,IAAM,eAAe,CAAC,WAA+B;AACnD,MAAI,CAAC,OAAQ,QAAO;AACpB,SAAO,GAAG,OAAO,IAAI,IAAI,OAAO,IAAI,IAAI,OAAO,MAAM;AACvD;AAEA,IAAM,+BAA+B,CACnC,KACA,cACiC;AACjC,MAAI,UAAU,WAAW,GAAG;AAC1B,WAAO,OAAO;AAAA,EAChB;AAEA,SAAO,IAAI;AAAA,IAAM,MACf,OAAO,IAAI,aAAa;AACtB,UAAI,CAAC,SAAS,EAAG;AAEjB,YAAM,mBAAmB,OAAO,SAAS,IAAU,SAAS,uBAA8B;AAC1F,UAAI,qBAAqB,MAAO;AAEhC,YAAM,UAAW,OAAO;AAExB,aAAO,OAAO;AAAA,QACZ;AAAA,QACA,CAAC,MACO,OAAO;AAAA,UACX,MAAM;AAAA,UACN,UAAU,QAAQ;AAAA,UAClB,YAAY,QAAQ;AAAA,UACpB,MAAM;AAAA,UACN,UAAU;AAAA,UACV,SAAS,gBAAgB,EAAE,EAAE;AAAA,UAC7B,MACE,SAAS,EAAE,KAAK,KAAK,UAAU,EAAE,KAAK,IAAI,SAAS,EAAE,KAAK,QAAQ,SAAS,WAAW,aAAa,EAAE,KAAK,MAAM,CAAC;AAAA,MAC1G,EAAE,GAAG,KAAK,UAAU,EAAE,GAAG,IAAI,SAAS,EAAE,GAAG,QAAQ,SAAS,WAAW,aAAa,EAAE,GAAG,MAAM,CAAC;AAAA,UACzG,MAAM;AAAA,QACR,CAAC;AAAA,QACH,EAAE,SAAS,KAAK;AAAA,MAClB;AAAA,IACF,CAAC;AAAA,EACH;AACF;AAEA,IAAM,2BAA2B,CAC/B,KACA,SACA,aACiC;AACjC,MAAI,CAAC,WAAW,OAAO,YAAY,YAAY,OAAO,KAAK,OAAO,EAAE,WAAW,GAAG;AAChF,WAAO,OAAO;AAAA,EAChB;AAEA,QAAM,QAAQ,IAAI,MAAM,CAAC,OAAO;AAAA,IAC9B,OAAO,OAAO,IAAI,aAAa;AAC7B,YAAM,UAAW,EAAU;AAC3B,YAAM,YAAa,EAAU;AAG7B,UAAI,OAAO,cAAc,WAAY;AAErC,YAAM,kBAAkB,oBAAI,QAAsF;AAElH,iBAAW,aAAa,OAAO,KAAK,OAAO,EAAE,KAAK,GAAG;AACnD,cAAM,QAAQ,QAAQ,SAAS;AAC/B,YAAI,CAAQ,cAAc,KAAK,EAAG;AAElC,cAAM,WAAW,QAAQ,SAAS;AAClC,YAAI,CAAC,MAAM,QAAQ,QAAQ,EAAG;AAE9B,mBAAW,WAAW,UAAU;AAC9B,cAAI,OAAO,YAAY,WAAY;AACnC,cAAI,UAAU,gBAAgB,IAAI,OAAO;AACzC,cAAI,CAAC,SAAS;AACZ,sBAAU,CAAC,YAAsB,QAAgB,GAAG,OAAO;AAC3D,4BAAgB,IAAI,SAAS,OAAO;AAAA,UACtC;AACA,iBAAO,UAAU,OAAO,OAAO;AAAA,QACjC;AAAA,MACF;AAAA,IACF,CAAC;AAAA,IACD,KAAK,OAAO;AAAA,EACd,EAAE;AAEF,EAAsB,oBAAoB,OAAc;AAAA,IACtD,IAAI;AAAA,IACJ,MAAM;AAAA,IACN,MAAM;AAAA,IACN;AAAA,EACF,CAAC;AAED,SAAO;AACT;AAEA,IAAM,mBAAmB,CACvB,eACwC;AACxC,QAAM,MAAM,WAAW;AACvB,SAAO,CAAC,OAAO,YAAY;AACzB,UAAM,MAAM,IAAI,MAAM,CAAC,QAAQ;AAC7B,YAAM,WAAW,OAAO,OAAO,GAAG;AAGjC,MAAC,SAAiB,OAAO,OAAO,QAAQ,MAAO,IAAY,IAAI,UAAiB,CAAC;AAClF,aAAO,MAAM,QAAe;AAAA,IAC9B,CAAC;AAED,UAAM,OAAsB;AAAA,MAC1B,IAAI,SAAS;AAAA,MACb,MAAM,SAAS;AAAA,MACf,MAAM,SAAS;AAAA,MACf,QAAQ,SAAS;AAAA,MACjB,UAAU,WAAW;AAAA,IACvB;AAEA,WAAOD,qBAAoB,KAAY,IAAI;AAAA,EAC7C;AACF;AAwDA,IAAM,eAAe,CAMnB,MACA,WACkE;AAClE,QAAM,cAAc,KAAK;AACzB,QAAM,aAAc,QAAQ,WAAW,CAAC;AAExC,aAAW,OAAO,OAAO,KAAK,UAAU,GAAG;AACzC,QAAI,OAAO,eAAe,YAAY,GAAG,MAAM,WAAW,GAAG,GAAG;AAC9D,YAAM,IAAI;AAAA,QACR,mCAAmC,GAAG;AAAA,MACxC;AAAA,IACF;AAAA,EACF;AAEA,QAAM,mBAAmB,EAAE,GAAI,KAAK,SAAiB,GAAI,QAAQ,QAAgB;AAIjF,QAAM,UAAiB,iBAAiB,gBAAgB;AAExD,QAAM,eAAe,MAA0D;AAC7E,UAAM,cAAe,KAAK,WAAW,CAAC;AACtC,UAAM,aAAc,QAAQ,WAAW,CAAC;AAExC,UAAM,OAAO,MAAM,KAAK,oBAAI,IAAI,CAAC,GAAG,OAAO,KAAK,WAAW,GAAG,GAAG,OAAO,KAAK,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK;AACjG,QAAI,KAAK,WAAW,EAAG,QAAO;AAE9B,UAAM,MAA8C,CAAC;AACrD,eAAW,OAAO,MAAM;AACtB,UAAI,EAAE,OAAO,UAAU;AACrB,cAAM,IAAI,MAAM,mCAAmC,GAAG,gCAAgC;AAAA,MACxF;AAEA,YAAM,YAAY,YAAY,GAAG;AACjC,YAAM,WAAW,WAAW,GAAG;AAC/B,YAAM,UAAU,MAAM,QAAQ,SAAS,IAAI,YAAY,cAAc,SAAY,CAAC,IAAI;AACtF,YAAM,SAAS,MAAM,QAAQ,QAAQ,IAAI,WAAW,aAAa,SAAY,CAAC,IAAI;AAElF,UAAI,YAAY,MAAM;AACpB,cAAM,IAAI,MAAM,gCAAgC,GAAG,kCAAkC;AAAA,MACvF;AACA,UAAI,WAAW,MAAM;AACnB,cAAM,IAAI,MAAM,gCAAgC,GAAG,kCAAkC;AAAA,MACvF;AAEA,YAAM,SAAS,CAAC,GAAG,SAAS,GAAG,MAAM,EAAE,OAAO,CAAC,MAAM,MAAM,MAAS;AACpE,iBAAW,KAAK,QAAQ;AACtB,YAAI,OAAO,MAAM,YAAY;AAC3B,gBAAM,IAAI,MAAM,gCAAgC,GAAG,gCAAgC;AAAA,QACrF;AAAA,MACF;AAEA,UAAI,OAAO,SAAS,GAAG;AACrB,YAAI,GAAG,IAAI;AAAA,MACb;AAAA,IACF;AAEA,WAAO,OAAO,KAAK,GAAG,EAAE,SAAS,IAAI,MAAM;AAAA,EAC7C;AAEA,QAAM,UAAU,aAAa;AAE7B,QAAM,oBAAoB,CAAC,aAAwF;AACjH,QAAI,CAAC,SAAU,QAAO,CAAC;AACvB,UAAM,MAA+B,CAAC;AACtC,eAAW,OAAO,OAAO,KAAK,QAAQ,GAAG;AACvC,YAAM,UAAU,SAAS,GAAG;AAC5B,UAAI,OAAO,YAAY,WAAY;AACnC,UAAI,GAAG,IAAgB,QAAQ,OAAO,OAAc;AAAA,IACtD;AACA,WAAO;AAAA,EACT;AAEA,QAAM,WAAW;AAAA,IACf,GAAG,kBAAkB,KAAK,aAAoB;AAAA,IAC9C,GAAI,KAAK,YAAY,CAAC;AAAA,IACtB,GAAG,kBAAkB,QAAQ,aAAoB;AAAA,IACjD,GAAI,QAAQ,YAAY,CAAC;AAAA,EAC3B;AAEA,aAAW,OAAO,OAAO,KAAK,QAAQ,GAAG;AACvC,QAAI,EAAE,OAAO,UAAU;AACrB,YAAM,IAAI,MAAM,oCAAoC,GAAG,gCAAgC;AAAA,IACzF;AAAA,EACF;AAEA,QAAM,UACJ,KAAK,WAAW,QAAQ,UAAU,EAAE,GAAI,KAAK,WAAW,CAAC,GAAI,GAAI,QAAQ,WAAW,CAAC,EAAG,IAAI;AAE9F,QAAM,OAAO,KAAK,QAAQ,QAAQ,OAAO,EAAE,GAAI,KAAK,QAAQ,CAAC,GAAI,GAAI,QAAQ,QAAQ,CAAC,EAAG,IAAI;AAE7F,QAAM,WACJ,KAAK,YAAY,QAAQ,WAAW,EAAE,GAAI,KAAK,YAAY,CAAC,GAAI,GAAI,QAAQ,YAAY,CAAC,EAAG,IAAI;AAElG,QAAM,MAAM,KAAK,OAAO,QAAQ,MAAM,EAAE,GAAI,KAAK,OAAO,CAAC,GAAI,GAAI,QAAQ,OAAO,CAAC,EAAG,IAAI;AAExF,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,IACA,UAAU,OAAO,KAAK,QAAQ,EAAE,SAAS,IAAK,WAAmB;AAAA,IACjE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAEO,IAAME,WAAsB;AA8C5B,SAASC,MAAK,IAAS,KAAU,QAAmB;AACzD,QAAM,SAAS,aAAa,KAAY,MAAa;AAErD,QAAM,MAAkB,KAAK,IAAI;AAAA,IAC/B,OAAO,OAAO;AAAA,IACd,SAAS,OAAO;AAAA,IAChB,UAAU,OAAO;AAAA,IACjB,QAAQ,OAAO;AAAA,EACjB,CAAC;AAED,MAAI,OAAO,WAAW,OAAO,OAAO,YAAY,YAAY,OAAO,KAAK,OAAO,OAAO,EAAE,SAAS,GAAG;AAClG,WAAO,eAAe,KAAY,yBAAyB;AAAA,MACzD,OAAO,OAAO;AAAA,MACd,YAAY;AAAA,MACZ,cAAc;AAAA,MACd,UAAU;AAAA,IACZ,CAAC;AAAA,EACH;AAEA,QAAM,OAAY;AAAA,IAChB,OAAO;AAAA,IACP;AAAA,IACA;AAAA,IACA,OAAO,IAAI;AAAA,IACX,aAAa,IAAI;AAAA,IACjB,cAAc,IAAI;AAAA,IAClB,SAAS,OAAO;AAAA,IAChB,UAAU,OAAO;AAAA,IACjB,SAAS,OAAO;AAAA,IAChB,MAAM,IAAI;AAAA,IACV,SAAS,OAAO;AAAA,IAChB,MAAM,OAAO;AAAA,IACb,UAAU,OAAO;AAAA,IACjB,KAAK,OAAO;AAAA,EACd;AAEA,OAAK,QAAQ,iBAAiB,IAAW;AAEzC,OAAK,YAAY,CAAC,WAAgB;AAGhC,UAAM,UAAU,OAAO;AACvB,UAAM,UAAU,OAAO;AACvB,UAAM,YAAY,OAAO;AACzB,UAAM,mBAAmB,OAAO;AAEhC,UAAM,iBAAiB,OAAO,UAAU,CAAC,GAAG;AAAA,MAC1C,CACE,KAIA,UACG,eAAe,IAAI,SAAS,IAAI,WAAW,EAAE,MAAM,CAAC;AAAA,MACzD,EAAE,SAAS,CAAC,GAAY,WAAW,CAAC,EAAW;AAAA,IACjD;AAQA,UAAM,YAAY,CAAC,UAAuD;AACxE,YAAM,mBAAmB,6BAA6B,KAAY,MAAM,SAAS;AACjF,YAAM,uBAAuB,yBAAyB,KAAY,OAAO,SAAS,EAAE;AACpF,YAAM,YAAY,CAAC,GAAG,MAAM,QAAQ,IAAI,CAAC,MAAM,EAAE,KAAK,GAAG,sBAAsB,gBAAgB;AAE/F,UAAI,OAAQ,IAAY,UAAU;AAAA,QAChC;AAAA,QACA,QAAQ;AAAA,QACR;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AAED,iBAAW,SAAS,MAAM,QAAQ;AAChC,eAAO,KAAK,UAAU,KAAK;AAAA,MAC7B;AAEA,aAAO;AAAA,IACT;AAEA,UAAM,eAAe,CAAC,UAAsB;AAC1C,YAAMF,YAAgD;AAAA,QACpD;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,SAAS,MAAM;AAAA,QACf,WAAW,MAAM;AAAA,QACjB,QAAQ,MAAM;AAAA,QACd,SAAS,MAAM,UAAU,KAAK;AAAA,MAChC;AAEA,YAAM,MAAW;AAAA,QACf,GAAG;AAAA,QACH,OAAO;AAAA,QACP,MAAM,UAAU,KAAK;AAAA,MACvB;AAEA,aAAO,eAAe,KAAK,iBAAiB;AAAA,QAC1C,OAAOA;AAAA,QACP,YAAY;AAAA,QACZ,cAAc;AAAA,MAChB,CAAC;AAED,UAAI,QAAQ,iBAAiB,GAAG;AAEhC,UAAI,YAAY,CAAC,OAAY,YAA+B,IAAI,WAAW,CAAC,OAAO,OAAO,CAAQ;AAElG,UAAI,aAAa,IAAI,WAA2C;AAC9D,cAAM,UAAW,IAAY,eAAe;AAC5C,cAAM,aAAa,OAAO,IAAI,mBAAmB;AACjD,cAAM,OAAO,WAAW,OAAO,CAAC,KAAK,SAAS,eAAe,IAAI,SAAS,IAAI,WAAW,IAAW,GAAG;AAAA,UACrG,SAAS,QAAQ;AAAA,UACjB,WAAW,QAAQ;AAAA,QACrB,CAAC;AAED,eAAO,aAAa;AAAA,UAClB,SAAS,KAAK;AAAA,UACd,WAAW,KAAK;AAAA,UAChB,QAAQ,QAAQ;AAAA,QAClB,CAAC;AAAA,MACH;AAEA,UAAI,YAAY,CAAC,UAAwC;AACvD,cAAM,UAAW,IAAY,eAAe;AAC5C,eAAO,aAAa;AAAA,UAClB,SAAS,QAAQ;AAAA,UACjB,WAAW,QAAQ;AAAA,UACnB,QAAQ,CAAC,GAAG,QAAQ,QAAQ,KAAK;AAAA,QACnC,CAAC;AAAA,MACH;AAEA,UAAI,aAAa,IAAI,WACnB,OAAO,OAAO,CAAC,KAAK,UAAU,IAAI,UAAU,KAAK,GAAG,GAAU;AAEhE,aAAO;AAAA,IACT;AAEA,WAAO,aAAa;AAAA,MAClB,SAAS,cAAc;AAAA,MACvB,WAAW,cAAc;AAAA,MACzB,QAAQ,CAAC;AAAA,IACX,CAAC;AAAA,EACH;AAEA,SAAO;AACT;AAEO,IAAM,SAAS;AAAA,EACpB,MAAM,CAA0C,YAGK;AAAA,IACnD,MAAM,OAAO;AAAA,IACb,MAAM,OAAO;AAAA,EACf;AACF;",
  "names": ["attachLogicUnitMeta", "internal", "Reducer", "make"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/Module.ts"],
  "sourcesContent": ["import { Context, Effect, FiberRef, Layer, Schema } from 'effect'\nimport * as Debug from './Debug.js'\nimport * as Logic from './Logic.js'\nimport * as ModuleTagNS from './ModuleTag.js'\nimport type { Workflow } from './Workflow.js'\nimport * as Action from './internal/action.js'\nimport type { JsonValue } from './internal/observability/jsonValue.js'\nimport * as WorkflowRuntime from './internal/runtime/core/WorkflowRuntime.js'\nimport { isDevEnv } from './internal/runtime/core/env.js'\nimport * as LogicUnitMetaInternal from './internal/runtime/core/LogicUnitMeta.js'\nimport type {\n  ActionsFromMap,\n  ActionOf,\n  AnyModuleShape,\n  AnySchema,\n  BoundApi,\n  LogicEffect,\n  ModuleLike,\n  ModuleHandle,\n  ModuleImpl,\n  ModuleImplementStateTransactionOptions,\n  ModuleLogic,\n  ModuleRuntime,\n  ModuleRuntimeOfShape,\n  ModuleTag,\n  ModuleShape,\n  MutatorsFromMap,\n  ReducersFromMap,\n  StateChangeWithMeta,\n  StateCommitMeta,\n  StateCommitMode,\n  StateCommitPriority,\n  StateOf,\n} from './internal/module.js'\n\n/**\n * Module (definition object) public API.\n *\n * - Domain factories (Form / CRUD / ...) should return this object.\n * - `.tag` is the identity anchor (ModuleTag/Context.Tag), used by `$.use(...)` and Env injection.\n * - `.impl` is the assembly blueprint (ModuleImpl), consumed by React/Runtime entry points.\n * - `.logic()` only produces the logic value; `.withLogic/withLayer(s)` changes the runnable shape (immutable: returns a new object).\n */\n\nexport type {\n  AnySchema,\n  AnyModuleShape,\n  ModuleShape,\n  ModuleLogic,\n  ModuleImpl,\n  ModuleRuntime,\n  ModuleRuntimeOfShape,\n  ModuleHandle,\n  ModuleTag,\n  StateOf,\n  ActionOf,\n  ActionsFromMap,\n  MutatorsFromMap,\n  ReducersFromMap,\n  BoundApi,\n  LogicEffect,\n  DispatchEffect,\n  ActionForTag,\n  BoundApiRootApi,\n  BoundApiStateApi,\n  BoundApiDispatchersApi,\n  BoundApiDispatchApi,\n  BoundApiLifecycleApi,\n  BoundApiUseApi,\n  BoundApiTraitsApi,\n  BoundApiReducerApi,\n  StateCommitMode,\n  StateCommitPriority,\n  StateCommitMeta,\n  StateChangeWithMeta,\n} from './internal/module.js'\n\nexport interface DevSource {\n  readonly file: string\n  readonly line: number\n  readonly column: number\n}\n\nexport interface ModuleDev {\n  readonly source?: DevSource\n}\n\nexport interface LogicUnitOptions {\n  readonly id?: string\n  readonly kind?: string\n  readonly name?: string\n  readonly source?: DevSource\n}\n\nexport interface MountedLogicUnitSummary {\n  readonly kind: string\n  readonly id: string\n  readonly derived?: boolean\n  readonly name?: string\n}\n\nexport interface ModuleDescriptor {\n  readonly id: string\n  readonly moduleId: string\n  readonly instanceId: string\n  readonly actionKeys: ReadonlyArray<string>\n  readonly logicUnits: ReadonlyArray<MountedLogicUnitSummary>\n  readonly schemaKeys?: ReadonlyArray<string>\n  readonly meta?: Record<string, JsonValue>\n  readonly source?: DevSource\n}\n\nexport type HandleExtendFn<Sh extends AnyModuleShape, Ext extends object> = (\n  runtime: ModuleRuntimeOfShape<Sh>,\n  base: ModuleHandle<Sh>,\n) => Ext | (ModuleHandle<Sh> & Ext) | null | undefined\n\nexport type ModuleSelfHandleEffect<Sh extends AnyModuleShape, R = never, Ext extends object = {}> = LogicEffect<\n  Sh,\n  R,\n  ModuleHandle<Sh> & Ext,\n  never\n>\n\nexport type ModuleLogicApi<Sh extends AnyModuleShape, R = never, Ext extends object = {}> = BoundApi<Sh, R> & {\n  readonly self: ModuleSelfHandleEffect<Sh, R, Ext>\n}\n\ntype LogicUnitMeta = LogicUnitMetaInternal.LogicUnitMeta\nconst attachLogicUnitMeta = <L extends object>(logic: L, meta: LogicUnitMeta): L =>\n  LogicUnitMetaInternal.attachLogicUnitMeta(logic, meta as any) as any\n\ntype NoInfer_<T> = [T][T extends any ? 0 : never]\n\ntype MountedLogicUnit<Sh extends AnyModuleShape> = {\n  readonly id: string\n  readonly derived: boolean\n  readonly kind: string\n  readonly name?: string\n  readonly source?: DevSource\n  readonly logic: ModuleLogic<Sh, any, any>\n  readonly origin?: {\n    readonly explicitId?: string\n    readonly defaultId?: string\n    readonly derivedBase?: string\n  }\n}\n\ntype LogicOverrideWarning = {\n  readonly id: string\n  readonly from: Pick<MountedLogicUnit<any>, 'kind' | 'name' | 'source'> & {\n    readonly order: number\n  }\n  readonly to: Pick<MountedLogicUnit<any>, 'kind' | 'name' | 'source'> & {\n    readonly order: number\n  }\n}\n\ntype WorkflowDef = Workflow['def']\n\ntype ModuleInternal<Id extends string, Sh extends AnyModuleShape> = {\n  readonly initial: StateOf<Sh>\n  readonly imports?: ReadonlyArray<Layer.Layer<any, any, any> | ModuleImpl<any, AnyModuleShape, any>>\n  readonly processes?: ReadonlyArray<Effect.Effect<void, any, any>>\n  readonly stateTransaction?: ModuleImplementStateTransactionOptions\n  readonly mounted: ReadonlyArray<MountedLogicUnit<Sh>>\n  readonly overrides: ReadonlyArray<LogicOverrideWarning>\n  readonly layers: ReadonlyArray<Layer.Layer<any, never, any>>\n  readonly workflowDefs: ReadonlyArray<WorkflowDef>\n  readonly rebuild: () => ModuleImpl<Id, Sh, any>\n}\n\nconst MODULE_INTERNAL = Symbol.for('logix.module.internal')\nconst MODULE_DECLARED_EFFECTS = Symbol.for('logix.module.effects.declared')\n\ntype ModuleDefBase<\n  Id extends string = string,\n  Sh extends AnyModuleShape = AnyModuleShape,\n  Ext extends object = {},\n> = ModuleLike<Id, Sh, Ext> & {\n  readonly shape: Sh\n  readonly stateSchema: Sh['stateSchema']\n  readonly actionSchema: Sh['actionSchema']\n  /**\n   * Raw ActionMap (tag -> payload schema).\n   * - Mainly for DX/reflection; runtime contract is still based on tag.shape/actionSchema.\n   */\n  readonly actions: Sh['actionMap']\n  /**\n   * Raw reducers (if provided by the definition).\n   * - Mainly for DX/reflection; runtime normalizes them into primary reducers inside ModuleTag/ModuleFactory.\n   */\n  readonly reducers?: ReducersFromMap<Sh['stateSchema'], Sh['actionMap']>\n  readonly live: <R = never, E = never>(\n    initial: StateOf<Sh>,\n    ...logics: Array<ModuleLogic<Sh, R, E>>\n  ) => Layer.Layer<ModuleRuntimeOfShape<Sh>, E, R>\n  readonly schemas?: Record<string, unknown>\n  readonly meta?: Record<string, JsonValue>\n  readonly services?: Record<string, Context.Tag<any, any>>\n  readonly dev?: ModuleDev\n  readonly logic: <R = never, E = unknown>(\n    build: (\n      api: ModuleLogicApi<Sh, R, Ext>,\n    ) => ModuleLogic<Sh, R, E>,\n    options?: LogicUnitOptions,\n  ) => ModuleLogic<Sh, R, E>\n}\n\nexport type AnyModule = {\n  readonly _kind: 'Module'\n  readonly id: string\n  readonly tag: ModuleTag<string, AnyModuleShape>\n  readonly impl: ModuleImpl<any, AnyModuleShape, any>\n  readonly actions: Record<string, AnySchema>\n  readonly reducers?: Record<string, unknown>\n  readonly schemas?: Record<string, unknown>\n  readonly meta?: Record<string, JsonValue>\n  readonly services?: Record<string, Context.Tag<any, any>>\n  readonly dev?: ModuleDev\n}\n\nexport type Module<Id extends string, Sh extends AnyModuleShape, Ext extends object = {}, R = never> = ModuleDefBase<\n  Id,\n  Sh,\n  Ext\n> & {\n  readonly _kind: 'Module'\n  readonly impl: ModuleImpl<Id, Sh, R>\n  readonly withLogic: (logic: ModuleLogic<Sh, any, any>, options?: LogicUnitOptions) => Module<Id, Sh, Ext, R>\n  readonly withLogics: (...inputs: ReadonlyArray<MountInput<Sh>>) => Module<Id, Sh, Ext, R>\n  readonly withWorkflow: (workflow: Workflow) => Module<Id, Sh, Ext, R>\n  readonly withWorkflows: (workflows: ReadonlyArray<Workflow>) => Module<Id, Sh, Ext, R>\n  readonly withLayer: (layer: Layer.Layer<any, never, any>) => Module<Id, Sh, Ext, R>\n  readonly withLayers: (...layers: ReadonlyArray<Layer.Layer<any, never, any>>) => Module<Id, Sh, Ext, R>\n}\n\nexport type ModuleDef<Id extends string, Sh extends AnyModuleShape, Ext extends object = {}> = ModuleDefBase<\n  Id,\n  Sh,\n  Ext\n> & {\n  readonly _kind: 'ModuleDef'\n  readonly withWorkflow: (workflow: Workflow) => ModuleDef<Id, Sh, Ext>\n  readonly withWorkflows: (workflows: ReadonlyArray<Workflow>) => ModuleDef<Id, Sh, Ext>\n  readonly implement: <R = never>(config: {\n    readonly initial: StateOf<Sh>\n    readonly logics?: Array<ModuleLogic<Sh, R, any>>\n    readonly imports?: ReadonlyArray<Layer.Layer<any, any, any> | ModuleImpl<any, AnyModuleShape, any>>\n    readonly processes?: ReadonlyArray<Effect.Effect<void, any, any>>\n    readonly stateTransaction?: ModuleImplementStateTransactionOptions\n  }) => Module<Id, Sh, Ext, R>\n}\n\nexport const is = (value: unknown): value is ModuleDefBase => {\n  if (!value || typeof value !== 'object') return false\n  const kind = (value as any)._kind\n  if (kind !== 'ModuleDef' && kind !== 'Module') return false\n  return Context.isTag((value as any).tag)\n}\n\nexport const hasImpl = (value: unknown): value is AnyModule => {\n  if (!is(value)) return false\n  return (\n    typeof (value as any).impl === 'object' && (value as any).impl !== null && (value as any).impl._tag === 'ModuleImpl'\n  )\n}\n\nexport const unwrapTag = <Id extends string, Sh extends AnyModuleShape>(\n  module: ModuleLike<Id, Sh, any>,\n): ModuleTag<Id, Sh> => module.tag\n\nexport const unwrapImpl = <Id extends string, Sh extends AnyModuleShape>(\n  module: AnyModule & { readonly id: Id; readonly tag: ModuleTag<Id, Sh> },\n): ModuleImpl<Id, Sh, any> => (module as any).impl as ModuleImpl<Id, Sh, any>\n\nexport const descriptor = (\n  module: ModuleDefBase<string, AnyModuleShape, any>,\n  runtime: ModuleRuntime<any, any>,\n): ModuleDescriptor => {\n  const actionKeys = Object.keys((module.tag as any).shape?.actionMap ?? {})\n\n  const internal = (module as any)[MODULE_INTERNAL] as ModuleInternal<string, AnyModuleShape> | undefined\n\n  const logicUnits: ReadonlyArray<MountedLogicUnitSummary> = internal\n    ? internal.mounted.map((u) => ({\n        kind: u.kind,\n        id: u.id,\n        derived: u.derived ? true : undefined,\n        name: u.name,\n      }))\n    : []\n\n  const schemaKeys = module.schemas && typeof module.schemas === 'object' ? Object.keys(module.schemas) : undefined\n\n  const meta = module.meta && typeof module.meta === 'object' ? module.meta : undefined\n\n  const source = module.dev?.source\n\n  return {\n    id: module.id,\n    moduleId: String(runtime.moduleId),\n    instanceId: String(runtime.instanceId),\n    actionKeys,\n    logicUnits,\n    schemaKeys,\n    meta,\n    source,\n  }\n}\n\ntype MountInput<Sh extends AnyModuleShape> =\n  | ModuleLogic<Sh, any, any>\n  | readonly [ModuleLogic<Sh, any, any>, LogicUnitOptions]\n\nconst normalizeMountInput = <Sh extends AnyModuleShape>(\n  input: MountInput<Sh>,\n): { readonly logic: ModuleLogic<Sh, any, any>; readonly options?: LogicUnitOptions } => {\n  if (Array.isArray(input)) {\n    return { logic: input[0], options: input[1] }\n  }\n  return { logic: input as ModuleLogic<Sh, any, any> }\n}\n\nconst resolveLogicUnit = <Sh extends AnyModuleShape>(\n  existing: ReadonlyArray<MountedLogicUnit<Sh>>,\n  logic: ModuleLogic<Sh, any, any>,\n  options?: LogicUnitOptions,\n): MountedLogicUnit<Sh> => {\n  const meta = LogicUnitMetaInternal.getLogicUnitMeta(logic)\n  const explicitId = options?.id\n  const defaultId = meta?.id\n\n  const kind = (options?.kind ?? meta?.kind ?? 'user').trim() || 'user'\n  const name =\n    options?.name ?? meta?.name ?? (typeof defaultId === 'string' && defaultId.length > 0 ? defaultId : undefined)\n\n  const source = options?.source ?? meta?.source\n\n  if (typeof explicitId === 'string' && explicitId.trim().length > 0) {\n    return {\n      id: explicitId.trim(),\n      derived: false,\n      kind,\n      name,\n      source,\n      logic,\n      origin: { explicitId: explicitId.trim(), defaultId },\n    }\n  }\n\n  if (typeof defaultId === 'string' && defaultId.trim().length > 0) {\n    return {\n      id: defaultId.trim(),\n      derived: false,\n      kind,\n      name,\n      source,\n      logic,\n      origin: { defaultId: defaultId.trim() },\n    }\n  }\n\n  // Derived id: reproducible within the same composition order.\n  const used = new Set(existing.map((u) => u.id))\n  const baseRaw = (name ?? kind ?? 'logic').trim() || 'logic'\n  const base = baseRaw.replace(/\\s+/g, '_')\n\n  let n = 1\n  while (used.has(`${base}#${n}`)) n += 1\n  const derivedId = `${base}#${n}`\n\n  return {\n    id: derivedId,\n    derived: true,\n    kind,\n    name: name ?? baseRaw,\n    source,\n    logic,\n    origin: { derivedBase: baseRaw },\n  }\n}\n\nconst mountLogicUnit = <Sh extends AnyModuleShape>(\n  current: ReadonlyArray<MountedLogicUnit<Sh>>,\n  overrides: ReadonlyArray<LogicOverrideWarning>,\n  input: { readonly logic: ModuleLogic<Sh, any, any>; readonly options?: LogicUnitOptions },\n): {\n  readonly mounted: ReadonlyArray<MountedLogicUnit<Sh>>\n  readonly overrides: ReadonlyArray<LogicOverrideWarning>\n} => {\n  const nextUnit = resolveLogicUnit(current, input.logic, input.options)\n  // Write the resolved verdict back to logic meta for provenance/diagnostics (aligned with 022-module).\n  LogicUnitMetaInternal.updateLogicUnitMeta(nextUnit.logic as any, {\n    resolvedId: nextUnit.id,\n    resolvedIdKind: nextUnit.derived ? 'derived' : 'explicit',\n    resolvedKind: nextUnit.kind,\n    resolvedName: nextUnit.name,\n    resolvedSource: nextUnit.source as any,\n  })\n\n  const prevIndex = current.findIndex((u) => u.id === nextUnit.id)\n  if (prevIndex < 0) {\n    return { mounted: [...current, nextUnit], overrides }\n  }\n\n  const prev = current[prevIndex]\n  const nextMounted = [...current.slice(0, prevIndex), ...current.slice(prevIndex + 1), nextUnit]\n\n  const nextOverrides: ReadonlyArray<LogicOverrideWarning> = [\n    ...overrides,\n    {\n      id: nextUnit.id,\n      from: {\n        kind: prev.kind,\n        name: prev.name,\n        source: prev.source,\n        order: prevIndex,\n      },\n      to: {\n        kind: nextUnit.kind,\n        name: nextUnit.name,\n        source: nextUnit.source,\n        order: nextMounted.length - 1,\n      },\n    },\n  ]\n\n  return { mounted: nextMounted, overrides: nextOverrides }\n}\n\nconst formatSource = (source?: DevSource): string => {\n  if (!source) return 'unknown'\n  return `${source.file}:${source.line}:${source.column}`\n}\n\nconst makeOverrideDiagnosticsLogic = (\n  tag: ModuleTag<any, AnyModuleShape>,\n  overrides: ReadonlyArray<LogicOverrideWarning>,\n): ModuleLogic<any, any, never> => {\n  if (overrides.length === 0) {\n    return Effect.void as any\n  }\n\n  return tag.logic(() =>\n    Effect.gen(function* () {\n      if (!isDevEnv()) return\n\n      const diagnosticsLevel = yield* FiberRef.get(Debug.internal.currentDiagnosticsLevel as any)\n      if (diagnosticsLevel === 'off') return\n\n      const runtime = (yield* tag) as ModuleRuntime<any, any>\n\n      yield* Effect.forEach(\n        overrides,\n        (o) =>\n          Debug.record({\n            type: 'diagnostic',\n            moduleId: runtime.moduleId,\n            instanceId: runtime.instanceId,\n            code: 'module_logic::override',\n            severity: 'warning',\n            message: `logicUnitId \"${o.id}\" overridden (last-write-wins).`,\n            hint:\n              `from(#${o.from.order}) kind=${o.from.kind} name=${o.from.name ?? 'unknown'} source=${formatSource(o.from.source)}\\n` +\n              `to(#${o.to.order}) kind=${o.to.kind} name=${o.to.name ?? 'unknown'} source=${formatSource(o.to.source)}`,\n            kind: 'logic_unit_override',\n          }),\n        { discard: true },\n      )\n    }),\n  )\n}\n\nconst makeDeclaredEffectsLogic = (\n  tag: ModuleTag<any, AnyModuleShape>,\n  effects: Record<string, ReadonlyArray<unknown> | undefined> | undefined,\n  moduleId: string,\n): ModuleLogic<any, any, never> => {\n  if (!effects || typeof effects !== 'object' || Object.keys(effects).length === 0) {\n    return Effect.void as any\n  }\n\n  const logic = tag.logic(($) => ({\n    setup: Effect.gen(function* () {\n      const actions = ($ as any).actions as Record<string, Action.AnyActionToken>\n      const effectApi = ($ as any).effect as\n        | ((token: unknown, handler: (payload: unknown) => Effect.Effect<void, any, any>) => Effect.Effect<void, never, any>)\n        | undefined\n      if (typeof effectApi !== 'function') return\n\n      const wrappedHandlers = new WeakMap<(...args: any[]) => any, (payload: unknown) => Effect.Effect<void, any, any>>()\n\n      for (const actionTag of Object.keys(effects).sort()) {\n        const token = actions[actionTag]\n        if (!Action.isActionToken(token)) continue\n\n        const handlers = effects[actionTag]\n        if (!Array.isArray(handlers)) continue\n\n        for (const handler of handlers) {\n          if (typeof handler !== 'function') continue\n          let wrapped = wrappedHandlers.get(handler)\n          if (!wrapped) {\n            wrapped = (payload: unknown) => (handler as any)($, payload)\n            wrappedHandlers.set(handler, wrapped)\n          }\n          yield* effectApi(token, wrapped)\n        }\n      }\n    }),\n    run: Effect.void,\n  })) as ModuleLogic<any, any, never>\n\n  LogicUnitMetaInternal.attachLogicUnitMeta(logic as any, {\n    id: '__logix_internal:effects:declared',\n    kind: 'internal',\n    name: 'effects:declared',\n    moduleId,\n  })\n\n  return logic\n}\n\nconst makeLogicFactory = <Id extends string, Sh extends AnyModuleShape, Ext extends object>(\n  selfModule: ModuleDefBase<Id, Sh, Ext>,\n): ModuleDefBase<Id, Sh, Ext>['logic'] => {\n  const tag = selfModule.tag\n  return (build, options) => {\n    const eff = tag.logic((api) => {\n      const withSelf = Object.create(api) as ModuleLogicApi<Sh, any, Ext>\n      ;(withSelf as any).self = Effect.suspend(() => (api as any).use(selfModule as any))\n      return build(withSelf as any)\n    }) as ModuleLogic<Sh, any, any>\n\n    const meta: LogicUnitMeta = {\n      id: options?.id,\n      kind: options?.kind,\n      name: options?.name,\n      source: options?.source,\n      moduleId: selfModule.id,\n    }\n\n    return attachLogicUnitMeta(eff as any, meta) as any\n  }\n}\n\ntype MakeDef<Id extends string, SSchema extends AnySchema, AMap extends Action.ActionDefs> = {\n  readonly state: SSchema\n  readonly actions: AMap\n  readonly reducers?: ReducersFromMap<SSchema, NoInfer_<AMap>>\n  readonly immerReducers?: MutatorsFromMap<SSchema, NoInfer_<AMap>>\n  readonly effects?: EffectsFromMap<NoInfer_<AMap>>\n  readonly traits?: unknown\n  readonly schemas?: Record<string, unknown>\n  readonly meta?: Record<string, JsonValue>\n  readonly services?: Record<string, Context.Tag<any, any>>\n  readonly dev?: ModuleDev\n}\n\ntype AnyActionMap = Action.ActionDefs\ntype EmptyActionMap = Record<never, never>\n\ntype PayloadOfActionDef<V> = V extends Schema.Schema<any, any, any>\n  ? Schema.Schema.Type<V>\n  : V extends Action.ActionToken<any, infer P, any>\n    ? P\n    : never\n\ntype DeclaredEffectHandler<Payload> = ($: unknown, payload: Payload) => Effect.Effect<void, any, any>\n\ntype EffectsFromMap<M extends AnyActionMap> = {\n  readonly [K in keyof M]?: ReadonlyArray<DeclaredEffectHandler<PayloadOfActionDef<M[K]>>>\n}\n\ntype MergeActionMap<Base extends AnyActionMap, Ext extends AnyActionMap> = {\n  readonly [K in keyof Base | keyof Ext]: K extends keyof Ext ? Ext[K] : K extends keyof Base ? Base[K] : never\n}\n\n/**\n * Module.make \"app-side extension/override\" parameters (a two-stage responsibility split: domain library author \u2192 app developer).\n *\n * - `actions`: add-only (cannot override existing action schema); used to extend actionMap.\n * - `reducers`: add and override; used to override domain reducers or provide reducers for new actions.\n * - Other reflective fields (schemas/meta/services/dev) are shallow-merged (last-write-wins).\n */\nexport type MakeExtendDef<\n  SSchema extends AnySchema,\n  BaseActions extends AnyActionMap,\n  ExtActions extends AnyActionMap = EmptyActionMap,\n> = {\n  readonly actions?: ExtActions\n  readonly reducers?: ReducersFromMap<SSchema, MergeActionMap<BaseActions, ExtActions>>\n  readonly immerReducers?: MutatorsFromMap<SSchema, MergeActionMap<BaseActions, ExtActions>>\n  readonly effects?: EffectsFromMap<MergeActionMap<BaseActions, ExtActions>>\n  readonly schemas?: Record<string, unknown>\n  readonly meta?: Record<string, JsonValue>\n  readonly services?: Record<string, Context.Tag<any, any>>\n  readonly dev?: ModuleDev\n}\n\nconst mergeMakeDef = <\n  Id extends string,\n  SSchema extends AnySchema,\n  BaseActions extends AnyActionMap,\n  ExtActions extends AnyActionMap,\n>(\n  base: MakeDef<Id, SSchema, BaseActions>,\n  extend?: MakeExtendDef<SSchema, BaseActions, ExtActions>,\n): MakeDef<Id, SSchema, MergeActionMap<BaseActions, ExtActions>> => {\n  const baseActions = base.actions as Record<string, AnySchema>\n  const extActions = (extend?.actions ?? {}) as Record<string, AnySchema>\n\n  for (const key of Object.keys(extActions)) {\n    if (key in baseActions && baseActions[key] !== extActions[key]) {\n      throw new Error(\n        `[Logix.Module.make] action key \"${key}\" already exists; overriding action schemas is not supported (define a new action tag instead).`,\n      )\n    }\n  }\n\n  const mergedActionDefs = { ...(base.actions as any), ...(extend?.actions as any) } as MergeActionMap<\n    BaseActions,\n    ExtActions\n  >\n  const actions = Action.normalizeActions(mergedActionDefs)\n\n  const mergeEffects = (): Record<string, ReadonlyArray<unknown>> | undefined => {\n    const baseEffects = (base.effects ?? {}) as Record<string, unknown>\n    const extEffects = (extend?.effects ?? {}) as Record<string, unknown>\n\n    const keys = Array.from(new Set([...Object.keys(baseEffects), ...Object.keys(extEffects)])).sort()\n    if (keys.length === 0) return undefined\n\n    const out: Record<string, ReadonlyArray<unknown>> = {}\n    for (const key of keys) {\n      if (!(key in actions)) {\n        throw new Error(`[Logix.Module.make] effect key \"${key}\" does not exist in actionMap.`)\n      }\n\n      const baseValue = baseEffects[key]\n      const extValue = extEffects[key]\n      const baseArr = Array.isArray(baseValue) ? baseValue : baseValue === undefined ? [] : null\n      const extArr = Array.isArray(extValue) ? extValue : extValue === undefined ? [] : null\n\n      if (baseArr === null) {\n        throw new Error(`[Logix.Module.make] effects[\"${key}\"] must be an array of handlers.`)\n      }\n      if (extArr === null) {\n        throw new Error(`[Logix.Module.make] effects[\"${key}\"] must be an array of handlers.`)\n      }\n\n      const merged = [...baseArr, ...extArr].filter((h) => h !== undefined)\n      for (const h of merged) {\n        if (typeof h !== 'function') {\n          throw new Error(`[Logix.Module.make] effects[\"${key}\"] handlers must be functions.`)\n        }\n      }\n\n      if (merged.length > 0) {\n        out[key] = merged as ReadonlyArray<unknown>\n      }\n    }\n\n    return Object.keys(out).length > 0 ? out : undefined\n  }\n\n  const effects = mergeEffects()\n\n  const wrapImmerReducers = (mutators?: Record<string, ((draft: unknown, payload: unknown) => void) | undefined>) => {\n    if (!mutators) return {}\n    const out: Record<string, unknown> = {}\n    for (const key of Object.keys(mutators)) {\n      const mutator = mutators[key]\n      if (typeof mutator !== 'function') continue\n      out[key] = ModuleTagNS.Reducer.mutate(mutator as any)\n    }\n    return out\n  }\n\n  const reducers = {\n    ...wrapImmerReducers(base.immerReducers as any),\n    ...(base.reducers ?? {}),\n    ...wrapImmerReducers(extend?.immerReducers as any),\n    ...(extend?.reducers ?? {}),\n  } as Record<string, unknown>\n\n  for (const key of Object.keys(reducers)) {\n    if (!(key in actions)) {\n      throw new Error(`[Logix.Module.make] reducer key \"${key}\" does not exist in actionMap.`)\n    }\n  }\n\n  const schemas =\n    base.schemas || extend?.schemas ? { ...(base.schemas ?? {}), ...(extend?.schemas ?? {}) } : undefined\n\n  const meta = base.meta || extend?.meta ? { ...(base.meta ?? {}), ...(extend?.meta ?? {}) } : undefined\n\n  const services =\n    base.services || extend?.services ? { ...(base.services ?? {}), ...(extend?.services ?? {}) } : undefined\n\n  const dev = base.dev || extend?.dev ? { ...(base.dev ?? {}), ...(extend?.dev ?? {}) } : undefined\n\n  return {\n    ...base,\n    actions: actions as any,\n    reducers: Object.keys(reducers).length > 0 ? (reducers as any) : undefined,\n    effects: effects as any,\n    schemas,\n    meta,\n    services,\n    dev,\n  } as any\n}\n\nexport const Reducer = ModuleTagNS.Reducer\n\nexport type ActionTokenMap<ADefs extends Action.ActionDefs> = Action.NormalizedActionTokens<ADefs>\n\nexport type ActionUnionOf<ADefs extends Action.ActionDefs> = ActionsFromMap<ActionTokenMap<ADefs>>\n\nexport type ActionSchemaOf<ADefs extends Action.ActionDefs> = Schema.Schema<ActionUnionOf<ADefs>>\n\nexport type Shape<SSchema extends AnySchema, ADefs extends Action.ActionDefs> = ModuleShape<\n  SSchema,\n  ActionSchemaOf<ADefs>,\n  ActionTokenMap<ADefs>\n>\n\nexport function make<\n  Id extends string,\n  SSchema extends AnySchema,\n  AMap extends Action.ActionDefs,\n  Ext extends object = {},\n>(\n  id: Id,\n  def: MakeDef<Id, SSchema, AMap>,\n): ModuleDef<Id, Shape<SSchema, AMap>, Ext>\n\nexport function make<\n  Id extends string,\n  SSchema extends AnySchema,\n  AMap extends Action.ActionDefs,\n  Ext extends object = {},\n  ExtActions extends Action.ActionDefs = EmptyActionMap,\n>(\n  id: Id,\n  def: MakeDef<Id, SSchema, AMap>,\n  extend: MakeExtendDef<SSchema, NoInfer_<AMap>, ExtActions>,\n): ModuleDef<Id, Shape<SSchema, MergeActionMap<AMap, ExtActions>>, Ext>\n\nexport function make(id: any, def: any, extend?: any): any {\n  const merged = mergeMakeDef(def as any, extend as any)\n\n  const tag = ModuleTagNS.make(id, {\n    state: merged.state,\n    actions: merged.actions,\n    reducers: merged.reducers,\n    traits: merged.traits,\n  }) as unknown as ModuleTag<any, AnyModuleShape>\n\n  if (merged.effects && typeof merged.effects === 'object' && Object.keys(merged.effects).length > 0) {\n    Object.defineProperty(tag as any, MODULE_DECLARED_EFFECTS, {\n      value: merged.effects,\n      enumerable: false,\n      configurable: true,\n      writable: false,\n    })\n  }\n\n  const base: any = {\n    _kind: 'ModuleDef' as const,\n    id,\n    tag,\n    shape: tag.shape,\n    stateSchema: tag.stateSchema,\n    actionSchema: tag.actionSchema,\n    actions: merged.actions,\n    reducers: merged.reducers,\n    effects: merged.effects,\n    live: tag.live,\n    schemas: merged.schemas,\n    meta: merged.meta,\n    services: merged.services,\n    dev: merged.dev,\n  }\n\n  base.logic = makeLogicFactory(base as any)\n\n  base.implement = (config: any) => {\n    type Sh = AnyModuleShape\n\n    const initial = config.initial as any\n    const imports = config.imports as any\n    const processes = config.processes as any\n    const stateTransaction = config.stateTransaction as any\n    const workflowDefs: ReadonlyArray<WorkflowDef> = Array.isArray(config.__logix_workflowDefs)\n      ? (config.__logix_workflowDefs as ReadonlyArray<WorkflowDef>)\n      : []\n\n    const mountedResult = (config.logics ?? []).reduce(\n      (\n        acc: {\n          mounted: ReadonlyArray<MountedLogicUnit<any>>\n          overrides: ReadonlyArray<LogicOverrideWarning>\n        },\n        logic: any,\n      ) => mountLogicUnit(acc.mounted, acc.overrides, { logic }),\n      { mounted: [] as const, overrides: [] as const },\n    )\n\n    type State = {\n      readonly mounted: ReadonlyArray<MountedLogicUnit<any>>\n      readonly overrides: ReadonlyArray<LogicOverrideWarning>\n      readonly layers: ReadonlyArray<Layer.Layer<any, never, any>>\n      readonly workflowDefs: ReadonlyArray<WorkflowDef>\n    }\n\n    const buildImpl = (state: State): ModuleImpl<any, AnyModuleShape, any> => {\n      const diagnosticsLogic = makeOverrideDiagnosticsLogic(tag as any, state.overrides)\n      const declaredEffectsLogic = makeDeclaredEffectsLogic(tag as any, merged.effects, id)\n      const allLogics = [...state.mounted.map((u) => u.logic), declaredEffectsLogic, diagnosticsLogic]\n\n      let impl = (tag as any).implement({\n        initial,\n        logics: allLogics,\n        imports,\n        processes,\n        stateTransaction,\n      }) as ModuleImpl<any, AnyModuleShape, any>\n\n      for (const layer of state.layers) {\n        impl = impl.withLayer(layer)\n      }\n\n      return impl\n    }\n\n    const createModule = (state: State): any => {\n      const internal: ModuleInternal<any, AnyModuleShape> = {\n        initial,\n        imports,\n        processes,\n        stateTransaction,\n        mounted: state.mounted,\n        overrides: state.overrides,\n        layers: state.layers,\n        workflowDefs: state.workflowDefs,\n        rebuild: () => buildImpl(state),\n      }\n\n      const mod: any = {\n        ...base,\n        _kind: 'Module' as const,\n        impl: buildImpl(state),\n      }\n\n      Object.defineProperty(mod, MODULE_INTERNAL, {\n        value: internal,\n        enumerable: false,\n        configurable: true,\n      })\n\n      mod.logic = makeLogicFactory(mod)\n\n      mod.withLogic = (logic: any, options?: LogicUnitOptions) => mod.withLogics([logic, options] as any)\n\n      mod.withLogics = (...inputs: ReadonlyArray<MountInput<any>>) => {\n        const current = (mod as any)[MODULE_INTERNAL] as ModuleInternal<any, AnyModuleShape>\n        const normalized = inputs.map(normalizeMountInput)\n        const next = normalized.reduce((acc, item) => mountLogicUnit(acc.mounted, acc.overrides, item as any), {\n          mounted: current.mounted,\n          overrides: current.overrides,\n        })\n\n        return createModule({\n          mounted: next.mounted,\n          overrides: next.overrides,\n          layers: current.layers,\n          workflowDefs: current.workflowDefs,\n        })\n      }\n\n      mod.withLayer = (layer: Layer.Layer<any, never, any>) => {\n        const current = (mod as any)[MODULE_INTERNAL] as ModuleInternal<any, AnyModuleShape>\n        return createModule({\n          mounted: current.mounted,\n          overrides: current.overrides,\n          layers: [...current.layers, layer],\n          workflowDefs: current.workflowDefs,\n        })\n      }\n\n      mod.withLayers = (...layers: ReadonlyArray<Layer.Layer<any, never, any>>) =>\n        layers.reduce((acc, layer) => acc.withLayer(layer), mod as any)\n\n      mod.withWorkflow = (workflow: Workflow) => {\n        const install = (workflow as any)?.install\n        const logic =\n          typeof install === 'function'\n            ? install(mod.tag)\n            : WorkflowRuntime.installOne({ moduleTag: mod.tag as any, program: workflow as any })\n\n        const current = (mod as any)[MODULE_INTERNAL] as ModuleInternal<any, AnyModuleShape>\n        const next = mountLogicUnit(current.mounted, current.overrides, { logic } as any)\n        const nextWorkflowDefs = [...current.workflowDefs, (workflow as any).def as WorkflowDef]\n        return createModule({\n          mounted: next.mounted,\n          overrides: next.overrides,\n          layers: current.layers,\n          workflowDefs: nextWorkflowDefs,\n        })\n      }\n\n      mod.withWorkflows = (workflows: ReadonlyArray<Workflow>) => {\n        if (!Array.isArray(workflows) || workflows.length === 0) return mod as any\n        const logic = WorkflowRuntime.mountAll({ moduleTag: mod.tag as any, programs: workflows as any })\n        const current = (mod as any)[MODULE_INTERNAL] as ModuleInternal<any, AnyModuleShape>\n        const next = mountLogicUnit(current.mounted, current.overrides, { logic } as any)\n        const nextWorkflowDefs = [...current.workflowDefs, ...workflows.map((w) => (w as any).def as WorkflowDef)]\n\n        return createModule({\n          mounted: next.mounted,\n          overrides: next.overrides,\n          layers: current.layers,\n          workflowDefs: nextWorkflowDefs,\n        })\n      }\n\n      return mod as any\n    }\n\n    return createModule({\n      mounted: mountedResult.mounted,\n      overrides: mountedResult.overrides,\n      layers: [],\n      workflowDefs,\n    })\n  }\n\n  const baseImplement = base.implement\n\n  const withExtraLogics = (\n    extraLogics: ReadonlyArray<ModuleLogic<any, any, any>>,\n    extraWorkflowDefs: ReadonlyArray<WorkflowDef>,\n  ): any => {\n    const next: any = { ...base }\n\n    next.withWorkflow = (workflow: Workflow) => {\n      const install = (workflow as any)?.install\n      const logic =\n        typeof install === 'function'\n          ? install(next.tag)\n          : WorkflowRuntime.installOne({ moduleTag: next.tag as any, program: workflow as any })\n      return withExtraLogics([...extraLogics, logic as any], [...extraWorkflowDefs, (workflow as any).def as WorkflowDef])\n    }\n\n    next.withWorkflows = (workflows: ReadonlyArray<Workflow>) => {\n      if (!Array.isArray(workflows) || workflows.length === 0) return next as any\n      const logic = WorkflowRuntime.mountAll({ moduleTag: next.tag as any, programs: workflows as any })\n      return withExtraLogics(\n        [...extraLogics, logic as any],\n        [...extraWorkflowDefs, ...workflows.map((w) => (w as any).def as WorkflowDef)],\n      )\n    }\n\n    next.implement = (config: any) => {\n      const mergedLogics = [...(config.logics ?? []), ...extraLogics]\n      return baseImplement({ ...config, logics: mergedLogics, __logix_workflowDefs: extraWorkflowDefs })\n    }\n\n    return next as any\n  }\n\n  base.withWorkflow = (workflow: Workflow) => withExtraLogics([], []).withWorkflow(workflow)\n\n  base.withWorkflows = (workflows: ReadonlyArray<Workflow>) => withExtraLogics([], []).withWorkflows(workflows)\n\n  return base\n}\n\nexport const Manage = {\n  make: <D extends (...args: any[]) => AnyModule>(config: {\n    readonly kind?: string\n    readonly define: D\n  }): { readonly kind?: string; readonly make: D } => ({\n    kind: config.kind,\n    make: config.define,\n  }),\n} as const\n"],
  "mappings": "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",
  "names": ["attachLogicUnitMeta", "internal", "Reducer", "make"]
}


package/public/sandbox/logix-core/ModuleTag.js

@@ -3,37 +3,40 @@
 import {
   Reducer,
   make
-} from "../chunks/chunk-SUXDGXVE.js";
-import "../chunks/chunk-CDLXJHXY.js";
-import "../chunks/chunk-YF6IO732.js";
-import "../chunks/chunk-PQ652ULI.js";
-import "../chunks/chunk-MPUSOFJ3.js";
-import "../chunks/chunk-HFV5GJPK.js";
-import "../chunks/chunk-CEGSWZ5S.js";
-import "../chunks/chunk-ZUBABAAO.js";
-import "../chunks/chunk-4LRLOTMA.js";
-import "../chunks/chunk-HNEDTEGQ.js";
+} from "../chunks/chunk-WNOBN3DX.js";
+import "../chunks/chunk-NE447XAF.js";
+import "../chunks/chunk-5GEYCJW2.js";
+import "../chunks/chunk-KTFZSXOW.js";
+import "../chunks/chunk-FQRUTYAD.js";
+import "../chunks/chunk-C2MYMMO4.js";
+import "../chunks/chunk-BJOWSSEL.js";
+import "../chunks/chunk-KDJR27JV.js";
+import "../chunks/chunk-EZTMVCJF.js";
+import "../chunks/chunk-6TUOP63Q.js";
+import "../chunks/chunk-L4PNO2H6.js";
 import "../chunks/chunk-NTN6T6I6.js";
-import "../chunks/chunk-JIXTOQXJ.js";
+import "../chunks/chunk-RIWOEI3T.js";
 import "../chunks/chunk-KE2H62D6.js";
-import "../chunks/chunk-WFV5PPWJ.js";
 import "../chunks/chunk-CTSYKMM6.js";
-import "../chunks/chunk-RJQ4PG2F.js";
+import "../chunks/chunk-NWCJJZNQ.js";
+import "../chunks/chunk-UBMUY7WO.js";
 import "../chunks/chunk-GFOF7NCX.js";
 import "../chunks/chunk-DOBF6YTQ.js";
-import "../chunks/chunk-A6JFUNQQ.js";
-import "../chunks/chunk-ON2LY6HJ.js";
+import "../chunks/chunk-74C5VW7Z.js";
+import "../chunks/chunk-4MY35XR3.js";
 import "../chunks/chunk-2LZ43SWS.js";
-import "../chunks/chunk-IP63FME6.js";
-import "../chunks/chunk-UCFEP3BH.js";
-import "../chunks/chunk-CZRI7MHA.js";
-import "../chunks/chunk-VLYP4WUS.js";
-import "../chunks/chunk-UMVN3AWO.js";
-import "../chunks/chunk-UKYAF3NL.js";
-import "../chunks/chunk-S46P7MC6.js";
-import "../chunks/chunk-3LX3KIQQ.js";
-import "../chunks/chunk-BWSNPKO5.js";
-import "../chunks/chunk-TOQ6SJ6O.js";
+import "../chunks/chunk-X2Z5VYG3.js";
+import "../chunks/chunk-ASVMK364.js";
+import "../chunks/chunk-7GPAF2UK.js";
+import "../chunks/chunk-YMVMZA3U.js";
+import "../chunks/chunk-NMGFJZ4I.js";
+import "../chunks/chunk-UJGVDFZN.js";
+import "../chunks/chunk-2XVE7F26.js";
+import "../chunks/chunk-W365QUZ5.js";
+import "../chunks/chunk-SH7TP5CJ.js";
+import "../chunks/chunk-SI5OKFFY.js";
+import "../chunks/chunk-LWI7BXFN.js";
+import "../chunks/chunk-DT7YIIWE.js";
 export {
   Reducer,
   make

package/public/sandbox/logix-core/Observability.js

@@ -4,33 +4,35 @@ import {
   registerTrialRunArtifactExporter,
   trialRun,
   trialRunModule
-} from "../chunks/chunk-POIBXAH5.js";
-import "../chunks/chunk-EJDFUZ4B.js";
-import "../chunks/chunk-4LRLOTMA.js";
-import "../chunks/chunk-HNEDTEGQ.js";
-import "../chunks/chunk-JIXTOQXJ.js";
+} from "../chunks/chunk-CWOXD5NG.js";
+import "../chunks/chunk-BUVHG3NJ.js";
+import "../chunks/chunk-KDJR27JV.js";
+import "../chunks/chunk-L4PNO2H6.js";
+import "../chunks/chunk-RIWOEI3T.js";
 import "../chunks/chunk-KE2H62D6.js";
-import "../chunks/chunk-WFV5PPWJ.js";
 import "../chunks/chunk-CTSYKMM6.js";
-import "../chunks/chunk-RJQ4PG2F.js";
+import "../chunks/chunk-NWCJJZNQ.js";
+import "../chunks/chunk-UBMUY7WO.js";
 import "../chunks/chunk-GFOF7NCX.js";
 import "../chunks/chunk-DOBF6YTQ.js";
-import "../chunks/chunk-ON2LY6HJ.js";
+import "../chunks/chunk-4MY35XR3.js";
 import "../chunks/chunk-2LZ43SWS.js";
-import "../chunks/chunk-IP63FME6.js";
-import "../chunks/chunk-UCFEP3BH.js";
-import "../chunks/chunk-CZRI7MHA.js";
-import "../chunks/chunk-VLYP4WUS.js";
-import "../chunks/chunk-UMVN3AWO.js";
-import "../chunks/chunk-UKYAF3NL.js";
-import "../chunks/chunk-S46P7MC6.js";
-import "../chunks/chunk-3LX3KIQQ.js";
+import "../chunks/chunk-X2Z5VYG3.js";
+import "../chunks/chunk-ASVMK364.js";
+import "../chunks/chunk-7GPAF2UK.js";
+import "../chunks/chunk-YMVMZA3U.js";
+import "../chunks/chunk-NMGFJZ4I.js";
+import "../chunks/chunk-UJGVDFZN.js";
+import "../chunks/chunk-2XVE7F26.js";
+import "../chunks/chunk-W365QUZ5.js";
+import "../chunks/chunk-SH7TP5CJ.js";
 import {
   OBSERVABILITY_PROTOCOL_VERSION,
   exportEvidencePackage,
   importEvidencePackage
-} from "../chunks/chunk-BWSNPKO5.js";
-import "../chunks/chunk-TOQ6SJ6O.js";
+} from "../chunks/chunk-SI5OKFFY.js";
+import "../chunks/chunk-LWI7BXFN.js";
+import "../chunks/chunk-DT7YIIWE.js";
 
 // ../logix-core/src/Observability.ts
 var protocolVersion = OBSERVABILITY_PROTOCOL_VERSION;
@@ -44,4 +46,4 @@ export {
   trialRun,
   trialRunModule
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vbG9naXgtY29yZS9zcmMvT2JzZXJ2YWJpbGl0eS50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLy8gT2JzZXJ2YWJpbGl0eSBQcm90b2NvbCAoQGxvZ2l4anMvY29yZS9PYnNlcnZhYmlsaXR5KS5cblxuaW1wb3J0ICogYXMgRXZpZGVuY2UgZnJvbSAnLi9pbnRlcm5hbC9vYnNlcnZhYmlsaXR5L2V2aWRlbmNlLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlcm5hbC9vYnNlcnZhYmlsaXR5L3RyaWFsUnVuLmpzJ1xuXG5leHBvcnQgdHlwZSB7IEpzb25WYWx1ZSB9IGZyb20gJy4vaW50ZXJuYWwvb2JzZXJ2YWJpbGl0eS9qc29uVmFsdWUuanMnXG5leHBvcnQgdHlwZSB7IEFydGlmYWN0RW52ZWxvcGUsIEFydGlmYWN0S2V5LCBUcmlhbFJ1bkFydGlmYWN0cyB9IGZyb20gJy4vaW50ZXJuYWwvb2JzZXJ2YWJpbGl0eS9hcnRpZmFjdHMvbW9kZWwuanMnXG5leHBvcnQgdHlwZSB7XG4gIFRyaWFsUnVuQXJ0aWZhY3RFeHBvcnRlcixcbiAgVHJpYWxSdW5BcnRpZmFjdEluc3BlY3Rpb25Db250ZXh0LFxufSBmcm9tICcuL2ludGVybmFsL29ic2VydmFiaWxpdHkvYXJ0aWZhY3RzL2V4cG9ydGVyLmpzJ1xuZXhwb3J0IHsgcmVnaXN0ZXJUcmlhbFJ1bkFydGlmYWN0RXhwb3J0ZXIgfSBmcm9tICcuL2ludGVybmFsL29ic2VydmFiaWxpdHkvYXJ0aWZhY3RzL3JlZ2lzdHJ5LmpzJ1xuXG5leHBvcnQgY29uc3QgcHJvdG9jb2xWZXJzaW9uID0gRXZpZGVuY2UuT0JTRVJWQUJJTElUWV9QUk9UT0NPTF9WRVJTSU9OXG5cbmV4cG9ydCBpbnRlcmZhY2UgT2JzZXJ2YXRpb25FbnZlbG9wZSBleHRlbmRzIEV2aWRlbmNlLk9ic2VydmF0aW9uRW52ZWxvcGUge31cbmV4cG9ydCBpbnRlcmZhY2UgRXZpZGVuY2VQYWNrYWdlU291cmNlIGV4dGVuZHMgRXZpZGVuY2UuRXZpZGVuY2VQYWNrYWdlU291cmNlIHt9XG5leHBvcnQgaW50ZXJmYWNlIEV2aWRlbmNlUGFja2FnZSBleHRlbmRzIEV2aWRlbmNlLkV2aWRlbmNlUGFja2FnZSB7fVxuXG5leHBvcnQgY29uc3QgZXhwb3J0RXZpZGVuY2VQYWNrYWdlID0gRXZpZGVuY2UuZXhwb3J0RXZpZGVuY2VQYWNrYWdlXG5leHBvcnQgY29uc3QgaW1wb3J0RXZpZGVuY2VQYWNrYWdlID0gRXZpZGVuY2UuaW1wb3J0RXZpZGVuY2VQYWNrYWdlXG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQWFPLElBQU0sa0JBQTJCO0FBTWpDLElBQU1BLHlCQUFpQztBQUN2QyxJQUFNQyx5QkFBaUM7IiwKICAibmFtZXMiOiBbImV4cG9ydEV2aWRlbmNlUGFja2FnZSIsICJpbXBvcnRFdmlkZW5jZVBhY2thZ2UiXQp9Cg==
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vbG9naXgtY29yZS9zcmMvT2JzZXJ2YWJpbGl0eS50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLy8gT2JzZXJ2YWJpbGl0eSBQcm90b2NvbCAoQGxvZ2l4anMvY29yZS9PYnNlcnZhYmlsaXR5KS5cblxuaW1wb3J0ICogYXMgRXZpZGVuY2UgZnJvbSAnLi9pbnRlcm5hbC9vYnNlcnZhYmlsaXR5L2V2aWRlbmNlLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlcm5hbC9vYnNlcnZhYmlsaXR5L3RyaWFsUnVuLmpzJ1xuXG5leHBvcnQgdHlwZSB7IEpzb25WYWx1ZSB9IGZyb20gJy4vaW50ZXJuYWwvb2JzZXJ2YWJpbGl0eS9qc29uVmFsdWUuanMnXG5leHBvcnQgdHlwZSB7IEFydGlmYWN0RW52ZWxvcGUsIEFydGlmYWN0S2V5LCBUcmlhbFJ1bkFydGlmYWN0cyB9IGZyb20gJy4vaW50ZXJuYWwvb2JzZXJ2YWJpbGl0eS9hcnRpZmFjdHMvbW9kZWwuanMnXG5leHBvcnQgdHlwZSB7XG4gIFRyaWFsUnVuQXJ0aWZhY3RFeHBvcnRlcixcbiAgVHJpYWxSdW5BcnRpZmFjdEluc3BlY3Rpb25Db250ZXh0LFxufSBmcm9tICcuL2ludGVybmFsL29ic2VydmFiaWxpdHkvYXJ0aWZhY3RzL2V4cG9ydGVyLmpzJ1xuZXhwb3J0IHsgcmVnaXN0ZXJUcmlhbFJ1bkFydGlmYWN0RXhwb3J0ZXIgfSBmcm9tICcuL2ludGVybmFsL29ic2VydmFiaWxpdHkvYXJ0aWZhY3RzL3JlZ2lzdHJ5LmpzJ1xuXG5leHBvcnQgY29uc3QgcHJvdG9jb2xWZXJzaW9uID0gRXZpZGVuY2UuT0JTRVJWQUJJTElUWV9QUk9UT0NPTF9WRVJTSU9OXG5cbmV4cG9ydCBpbnRlcmZhY2UgT2JzZXJ2YXRpb25FbnZlbG9wZSBleHRlbmRzIEV2aWRlbmNlLk9ic2VydmF0aW9uRW52ZWxvcGUge31cbmV4cG9ydCBpbnRlcmZhY2UgRXZpZGVuY2VQYWNrYWdlU291cmNlIGV4dGVuZHMgRXZpZGVuY2UuRXZpZGVuY2VQYWNrYWdlU291cmNlIHt9XG5leHBvcnQgaW50ZXJmYWNlIEV2aWRlbmNlUGFja2FnZSBleHRlbmRzIEV2aWRlbmNlLkV2aWRlbmNlUGFja2FnZSB7fVxuXG5leHBvcnQgY29uc3QgZXhwb3J0RXZpZGVuY2VQYWNrYWdlID0gRXZpZGVuY2UuZXhwb3J0RXZpZGVuY2VQYWNrYWdlXG5leHBvcnQgY29uc3QgaW1wb3J0RXZpZGVuY2VQYWNrYWdlID0gRXZpZGVuY2UuaW1wb3J0RXZpZGVuY2VQYWNrYWdlXG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBYU8sSUFBTSxrQkFBMkI7QUFNakMsSUFBTUEseUJBQWlDO0FBQ3ZDLElBQU1DLHlCQUFpQzsiLAogICJuYW1lcyI6IFsiZXhwb3J0RXZpZGVuY2VQYWNrYWdlIiwgImltcG9ydEV2aWRlbmNlUGFja2FnZSJdCn0K