@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,372 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  build,
+  install
+} from "./chunk-R75Q2CTT.js";
+import {
+  registerModuleProgram
+} from "./chunk-5EC4S7X6.js";
+import {
+  Module
+} from "./chunk-UQKQ6V3V.js";
+import {
+  attachLogicUnitMeta
+} from "./chunk-MYBDYNK4.js";
+import {
+  mutateWithPatchPaths,
+  mutateWithoutPatches
+} from "./chunk-OWTMSCF7.js";
+import {
+  getBoundInternals,
+  setModuleTraitsProgram
+} from "./chunk-F743SKYD.js";
+import {
+  currentDiagnosticsLevel,
+  record
+} from "./chunk-X74KU74D.js";
+import {
+  fnv1a32,
+  stableStringify
+} from "./chunk-6JRP52YT.js";
+
+// ../logix-core/src/ModuleTag.ts
+import { Effect, FiberRef } from "../effect.js";
+
+// ../logix-core/src/internal/runtime/core/ModuleTraits.ts
+var ModuleTraitsConflictError = class extends Error {
+  constructor(moduleId, conflicts) {
+    super(
+      [
+        `[ModuleTraitsConflictError] Conflicting traitIds found (moduleId=${moduleId}).`,
+        ...conflicts.map(
+          (c) => c.kind === "duplicate_traitId" ? `- duplicate ${c.traitId}: ${c.sources.map((s) => `${s.originType}:${s.originId}`).join(", ")}` : c.kind === "missing_requires" ? `- missing requires for ${c.traitId}: ${(c.missing ?? []).join(", ")}; sources=${c.sources.map((s) => `${s.originType}:${s.originId}`).join(", ")}` : `- excludes violation for ${c.traitId}: present=${(c.present ?? []).join(", ")}; sources=${c.sources.map((s) => `${s.originType}:${s.originId}`).join(", ")}`
+        )
+      ].join("\n")
+    );
+    this.moduleId = moduleId;
+    this.conflicts = conflicts;
+    this._tag = "ModuleTraitsConflictError";
+  }
+};
+var toProvenanceKey = (p) => `${p.originType}:${p.originId}:${p.originIdKind}:${p.originLabel}:${p.path ?? ""}`;
+var compareProvenance = (a, b) => {
+  const type = a.originType.localeCompare(b.originType);
+  if (type !== 0) return type;
+  const id = a.originId.localeCompare(b.originId);
+  if (id !== 0) return id;
+  const kind = a.originIdKind.localeCompare(b.originIdKind);
+  if (kind !== 0) return kind;
+  const label = a.originLabel.localeCompare(b.originLabel);
+  if (label !== 0) return label;
+  return String(a.path ?? "").localeCompare(String(b.path ?? ""));
+};
+var originTypeOrder = (t) => t === "module" ? 0 : 1;
+var compareTraitIdByProvenance = (a, b) => {
+  const ta = originTypeOrder(a.provenance.originType) - originTypeOrder(b.provenance.originType);
+  if (ta !== 0) return ta;
+  const oa = a.provenance.originId.localeCompare(b.provenance.originId);
+  if (oa !== 0) return oa;
+  return a.traitId.localeCompare(b.traitId);
+};
+var extractStringArray = (value) => {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const v of value) {
+    if (typeof v !== "string") continue;
+    const s = v.trim();
+    if (!s) continue;
+    out.push(s);
+  }
+  return out;
+};
+var getTraitRequires = (value) => {
+  if (!value || typeof value !== "object") return [];
+  const direct = extractStringArray(value.requires);
+  return direct;
+};
+var getTraitExcludes = (value) => {
+  if (!value || typeof value !== "object") return [];
+  const direct = extractStringArray(value.excludes);
+  return direct;
+};
+var getTraitName = (traitId, value) => {
+  if (value && typeof value === "object") {
+    const n = value.name;
+    if (typeof n === "string" && n.trim().length > 0) return n.trim();
+  }
+  return traitId;
+};
+var getTraitDescription = (value) => {
+  if (value && typeof value === "object") {
+    const d = value.description;
+    if (typeof d === "string" && d.trim().length > 0) return d.trim();
+  }
+  return void 0;
+};
+var finalizeTraitContributions = (args) => {
+  const traitById = /* @__PURE__ */ new Map();
+  const duplicateSources = /* @__PURE__ */ new Map();
+  const contributions = [...args.contributions].sort((a, b) => compareProvenance(a.provenance, b.provenance));
+  for (const c of contributions) {
+    const traits2 = c.traits;
+    if (!traits2 || typeof traits2 !== "object") continue;
+    for (const traitId of Object.keys(traits2).sort((a, b) => a.localeCompare(b))) {
+      const value = traits2[traitId];
+      if (value === void 0) continue;
+      const prev = traitById.get(traitId);
+      if (!prev) {
+        traitById.set(traitId, { value, provenance: c.provenance });
+        continue;
+      }
+      const sources = duplicateSources.get(traitId) ?? [prev.provenance];
+      sources.push(c.provenance);
+      duplicateSources.set(traitId, sources);
+    }
+  }
+  const conflicts = [];
+  const registerConflict = (conflict) => {
+    const unique = /* @__PURE__ */ new Map();
+    for (const s of conflict.sources) {
+      unique.set(toProvenanceKey(s), s);
+    }
+    conflicts.push({
+      ...conflict,
+      sources: Array.from(unique.values()).sort(compareProvenance)
+    });
+  };
+  for (const traitId of Array.from(duplicateSources.keys()).sort((a, b) => a.localeCompare(b))) {
+    registerConflict({
+      kind: "duplicate_traitId",
+      traitId,
+      sources: duplicateSources.get(traitId) ?? []
+    });
+  }
+  const merged = {};
+  const provenanceIndex = {};
+  const traits = [];
+  const entries = [];
+  for (const traitId of traitById.keys()) {
+    const entry = traitById.get(traitId);
+    if (!entry) continue;
+    entries.push({ traitId, value: entry.value, provenance: entry.provenance });
+  }
+  const ids = entries.slice().sort(compareTraitIdByProvenance).map((e) => e.traitId);
+  for (const traitId of ids) {
+    const entry = traitById.get(traitId);
+    if (!entry) continue;
+    merged[traitId] = entry.value;
+    provenanceIndex[traitId] = entry.provenance;
+    traits.push({
+      traitId,
+      name: getTraitName(traitId, entry.value),
+      description: getTraitDescription(entry.value)
+    });
+  }
+  const present = new Set(ids);
+  for (const traitId of ids) {
+    const entry = traitById.get(traitId);
+    if (!entry) continue;
+    const requires = getTraitRequires(entry.value);
+    if (requires.length > 0) {
+      const missing = requires.filter((r) => !present.has(r));
+      if (missing.length > 0) {
+        registerConflict({
+          kind: "missing_requires",
+          traitId,
+          missing: Array.from(new Set(missing)).sort((a, b) => a.localeCompare(b)),
+          sources: [entry.provenance]
+        });
+      }
+    }
+    const excludes = getTraitExcludes(entry.value);
+    if (excludes.length > 0) {
+      const presentExcluded = excludes.filter((e) => present.has(e));
+      if (presentExcluded.length > 0) {
+        const otherSources = [];
+        for (const otherId of presentExcluded) {
+          const other = traitById.get(otherId);
+          if (other) otherSources.push(other.provenance);
+        }
+        registerConflict({
+          kind: "excludes_violation",
+          traitId,
+          present: Array.from(new Set(presentExcluded)).sort((a, b) => a.localeCompare(b)),
+          sources: [entry.provenance, ...otherSources]
+        });
+      }
+    }
+  }
+  if (conflicts.length > 0) {
+    const kindOrder = {
+      duplicate_traitId: 0,
+      missing_requires: 1,
+      excludes_violation: 2
+    };
+    conflicts.sort((a, b) => {
+      const k = kindOrder[a.kind] - kindOrder[b.kind];
+      if (k !== 0) return k;
+      return a.traitId.localeCompare(b.traitId);
+    });
+    throw new ModuleTraitsConflictError(args.moduleId, conflicts);
+  }
+  const digestBase = {
+    moduleId: args.moduleId,
+    traits,
+    provenanceIndex
+  };
+  const digest = `mtraits:023:${fnv1a32(stableStringify(digestBase))}`;
+  return {
+    merged,
+    snapshot: {
+      moduleId: args.moduleId,
+      digest,
+      traits,
+      provenanceIndex
+    }
+  };
+};
+
+// ../logix-core/src/ModuleTag.ts
+var Reducer = {
+  mutate: (mutator) => (state, action, sink) => {
+    if (!sink) {
+      return mutateWithoutPatches(state, (draft) => {
+        mutator(draft, action);
+      });
+    }
+    const { nextState, patchPaths } = mutateWithPatchPaths(state, (draft) => {
+      mutator(draft, action);
+    });
+    for (const path of patchPaths) {
+      sink(path);
+    }
+    return nextState;
+  }
+};
+var makeImpl = (id, def) => Module(id, def);
+var make = (id, def) => {
+  const moduleTag = makeImpl(id, def);
+  const stateSchema = def.state;
+  const moduleTraitsSpec = def.traits;
+  const baseProgram = moduleTraitsSpec ? build(stateSchema, moduleTraitsSpec) : void 0;
+  if (baseProgram) {
+    setModuleTraitsProgram(moduleTag, baseProgram);
+    registerModuleProgram(id, baseProgram);
+  }
+  const makeModuleTraitsContributionLogic = (traits) => {
+    const logic = moduleTag.logic(($) => ({
+      setup: Effect.sync(() => {
+        if (!traits || typeof traits !== "object") return;
+        const internals = getBoundInternals($);
+        internals.traits.registerModuleTraitsContribution({
+          traits,
+          provenance: {
+            originType: "module",
+            originId: id,
+            originIdKind: "explicit",
+            originLabel: `module:${id}`
+          }
+        });
+      }),
+      run: Effect.void
+    }));
+    attachLogicUnitMeta(logic, {
+      id: "__logix_internal:traits:module_contrib",
+      kind: "internal",
+      name: "traits:module_contrib",
+      moduleId: id
+    });
+    return logic;
+  };
+  const makeFinalizeTraitsLogic = () => {
+    const logic = moduleTag.logic(($) => ({
+      setup: Effect.gen(function* () {
+        const internals = getBoundInternals($);
+        const diagnosticsLevel = yield* FiberRef.get(currentDiagnosticsLevel);
+        const contributions = internals.traits.getModuleTraitsContributions();
+        let merged;
+        let snapshot;
+        try {
+          ;
+          ({ merged, snapshot } = finalizeTraitContributions({
+            moduleId: id,
+            contributions
+          }));
+        } catch (cause) {
+          if (diagnosticsLevel !== "off" && cause && typeof cause === "object" && cause._tag === "ModuleTraitsConflictError") {
+            const conflicts = Array.isArray(cause.conflicts) ? cause.conflicts : [];
+            const traitIds = conflicts.map((c) => c && typeof c === "object" ? c.traitId : void 0).filter((t) => typeof t === "string" && t.length > 0).slice(0, 20);
+            const data = diagnosticsLevel === "full" ? {
+              conflictCount: conflicts.length,
+              conflicts
+            } : {
+              conflictCount: conflicts.length,
+              traitIds
+            };
+            yield* record({
+              type: "trace:module:traits:conflict",
+              moduleId: id,
+              instanceId: internals.instanceId,
+              data
+            });
+          }
+          throw cause;
+        }
+        internals.traits.setModuleTraitsSnapshot(snapshot);
+        internals.traits.freezeModuleTraits();
+        if (diagnosticsLevel !== "off") {
+          const data = diagnosticsLevel === "full" ? {
+            digest: snapshot.digest,
+            count: snapshot.traits.length,
+            traits: snapshot.traits,
+            provenanceIndex: snapshot.provenanceIndex
+          } : {
+            digest: snapshot.digest,
+            count: snapshot.traits.length
+          };
+          yield* record({
+            type: "trace:module:traits",
+            moduleId: id,
+            instanceId: internals.instanceId,
+            data
+          });
+        }
+        if (Object.keys(merged).length === 0) {
+          return;
+        }
+        const onlyModuleLevel = contributions.length === 1 && contributions[0]?.provenance?.originType === "module";
+        const program = onlyModuleLevel && baseProgram ? baseProgram : build(stateSchema, merged);
+        setModuleTraitsProgram(moduleTag, program);
+        registerModuleProgram(id, program);
+        yield* install($, program);
+      }),
+      run: Effect.void
+    }));
+    attachLogicUnitMeta(logic, {
+      id: "__logix_internal:traits:finalize",
+      kind: "internal",
+      name: "traits:finalize",
+      moduleId: id
+    });
+    return logic;
+  };
+  const originalImplement = moduleTag.implement;
+  moduleTag.implement = ((config) => {
+    const userLogics = config.logics ?? [];
+    const moduleLevel = def.traits ? [makeModuleTraitsContributionLogic(def.traits)] : [];
+    const finalize = makeFinalizeTraitsLogic();
+    const mergedLogics = [...moduleLevel, ...userLogics, finalize];
+    return originalImplement({
+      ...config,
+      logics: mergedLogics
+    });
+  });
+  return moduleTag;
+};
+
+export {
+  Reducer,
+  make
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/ModuleTag.ts", "../../../../logix-core/src/internal/runtime/core/ModuleTraits.ts"],
  "sourcesContent": ["import { Effect, FiberRef, Layer, Schema } from 'effect'\nimport * as Logic from './Logic.js'\nimport * as ModuleFactory from './internal/runtime/ModuleFactory.js'\nimport type { FieldPath } from './internal/field-path.js'\nimport { mutateWithoutPatches, mutateWithPatchPaths } from './internal/runtime/core/mutativePatches.js'\nimport { getBoundInternals, setModuleTraitsProgram } from './internal/runtime/core/runtimeInternalsAccessor.js'\nimport * as Debug from './internal/runtime/core/DebugSink.js'\nimport * as LogicUnitMeta from './internal/runtime/core/LogicUnitMeta.js'\nimport type {\n  ActionsFromMap,\n  AnyModuleShape,\n  AnySchema,\n  BoundApi,\n  ActionOf,\n  ModuleImpl,\n  ModuleLogic,\n  ModuleShape,\n  ModuleRuntime,\n  ModuleTag,\n  ModuleHandle,\n  ModuleHandleUnion,\n  StateChangeWithMeta,\n  StateCommitMeta,\n  StateCommitMode,\n  StateCommitPriority,\n  ReducersFromMap,\n  StateOf,\n} from './internal/module.js'\nimport * as StateTrait from './StateTrait.js'\nimport type { StateTraitProgram } from './StateTrait.js'\nimport * as ModuleTraitsRegistry from './internal/debug/ModuleTraitsRegistry.js'\nimport * as ModuleTraits from './internal/runtime/core/ModuleTraits.js'\n\n/**\n * ModuleTag / ModuleRuntime / ModuleImpl \u7B49\u6838\u5FC3\u7C7B\u578B\u5B9A\u4E49\u7684\u516C\u5F00\u51FA\u53E3\u3002\n *\n * \u4E0E .codex/skills/project-guide/references/runtime-logix/logix-core/api/02-module-and-logic-api.md \u4FDD\u6301\u5BF9\u9F50\u3002\n * \u5177\u4F53\u7C7B\u578B\u5B9A\u4E49\u96C6\u4E2D\u5728 internal/module.ts \u4E2D\uFF0C\u672C\u6A21\u5757\u8D1F\u8D23\u7EC4\u5408\u5DE5\u5382\u5B9E\u73B0\u3002\n */\nexport type {\n  AnySchema,\n  AnyModuleShape,\n  ModuleShape,\n  ModuleLogic,\n  ModuleImpl,\n  ModuleRuntime,\n  ModuleTag,\n  ModuleHandle,\n  ModuleHandleUnion,\n  StateOf,\n  ActionsFromMap,\n  ReducersFromMap,\n  BoundApi,\n  ActionOf,\n  StateCommitMode,\n  StateCommitPriority,\n  StateCommitMeta,\n  StateChangeWithMeta,\n} from './internal/module.js'\n\n/**\n * Reducer \u5E2E\u52A9\u5DE5\u5177\uFF1A\n * - `Reducer.mutate` \u63D0\u4F9B\u4E0E `$.state.mutate` \u4E00\u81F4\u7684 mutative \u98CE\u683C\u5199\u6CD5\uFF1B\n * - \u901A\u8FC7\u5185\u90E8\u57FA\u4E8E mutative \u7684\u4E0D\u53EF\u53D8\u66F4\u65B0\uFF0C\u5C06\u300C\u5C31\u5730\u4FEE\u6539 draft\u300D\u6620\u5C04\u4E3A\u7EAF `(state, action) => state` \u51FD\u6570\u3002\n *\n * \u7528\u6CD5\u793A\u4F8B\uFF1A\n *\n *   const Counter = Logix.ModuleTag.make(\"Counter\", {\n *     state: CounterState,\n *     actions: CounterActions,\n *     reducers: {\n *       inc: Logix.ModuleTag.Reducer.mutate((draft, _action) => {\n *         draft.count += 1\n *       }),\n *     },\n *   })\n *\n *   yield* $.reducer(\n *     \"setValue\",\n *     Logix.ModuleTag.Reducer.mutate((draft, action) => {\n *       draft.value = action.payload\n *     }),\n *   )\n */\nexport const Reducer = {\n  mutate:\n    <S, A>(\n      mutator: (draft: Logic.Draft<S>, action: A) => void,\n    ): ((state: S, action: A, sink?: (path: string | FieldPath) => void) => S) =>\n    (state, action, sink) => {\n      if (!sink) {\n        return mutateWithoutPatches(state as S, (draft) => {\n          mutator(draft as Logic.Draft<S>, action)\n        })\n      }\n\n      const { nextState, patchPaths } = mutateWithPatchPaths(state as S, (draft) => {\n        mutator(draft as Logic.Draft<S>, action)\n      })\n\n      for (const path of patchPaths) {\n        sink(path)\n      }\n\n      return nextState\n    },\n}\n\n/**\n * \u7B80\u5316\u7684 Shape \u5B9A\u4E49\u52A9\u624B\uFF0C\u4E13\u4E3A Action Map \u8BBE\u8BA1\u3002\n * @example type MyShape = Shape<typeof MyState, typeof MyActionMap>\n */\nexport type Shape<S extends AnySchema, M extends Record<string, AnySchema>> = ModuleShape<\n  S,\n  Schema.Schema<ActionsFromMap<M>>,\n  M\n>\n\nconst makeImpl = <Id extends string, SSchema extends AnySchema, AMap extends Record<string, AnySchema>>(\n  id: Id,\n  def: {\n    readonly state: SSchema\n    readonly actions: AMap\n    readonly reducers?: ReducersFromMap<SSchema, AMap>\n  },\n): ModuleTag<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>> =>\n  ModuleFactory.Module(id, def) as ModuleTag<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>>\n\n/**\n * ModuleTag.make\uFF1A\n * - \u4EE5\u7ED9\u5B9A id \u4E0E state/actions/reducers \u5B9A\u4E49\u4E00\u4E2A\u9886\u57DF\u6A21\u5757 Tag\uFF1B\n * - \u8FD4\u56DE\u7684 ModuleTag \u65E2\u662F Context.Tag\uFF0C\u53C8\u643A\u5E26 Shape \u4E0E\u5DE5\u5382\u80FD\u529B\u3002\n *\n * \u8BF4\u660E\uFF1A022 \u8D77\u65E7 `Module`\uFF08Tag identity\uFF09\u66F4\u540D\u4E3A `ModuleTag`\uFF1B\u9886\u57DF\u5B9A\u4E49\u5BF9\u8C61\u8BF7\u4F7F\u7528 `Logix.Module`\u3002\n */\nexport const make = <Id extends string, SSchema extends AnySchema, AMap extends Record<string, AnySchema>>(\n  id: Id,\n  def: {\n    readonly state: SSchema\n    readonly actions: AMap\n    readonly reducers?: ReducersFromMap<SSchema, AMap>\n    /**\n     * traits\uFF1A\n     * - \u7528\u4E8E\u6302\u8F7D StateTraitSpec\uFF08\u8BE6\u89C1 specs/000-module-traits-runtime\uFF09\u3002\n     * - \u5F53\u524D\u5B9E\u73B0\u4F1A\u5728 ModuleTag.make \u9636\u6BB5 build Program\uFF0C\u5E76\u5728 `ModuleTag.implement` \u6CE8\u5165\u4E00\u6BB5 setup-only Logic \u6765\u8C03\u7528 `StateTrait.install`\u3002\n     *   \uFF08\u6CE8\uFF1A\u82E5\u4F7F\u7528 `ModuleTag.live` \u76F4\u51FA Layer \u4E14\u5E0C\u671B\u542F\u7528 traits \u884C\u4E3A\uFF0C\u8BF7\u663E\u5F0F\u5728 logics \u4E2D\u8C03\u7528 `StateTrait.install`\uFF0C\u6216\u6539\u7528 `ModuleTag.implement`\u3002\uFF09\n     */\n    readonly traits?: unknown\n  },\n): ModuleTag<Id, ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>> => {\n  const moduleTag = makeImpl(id, def)\n\n  type Sh = ModuleShape<SSchema, Schema.Schema<ActionsFromMap<AMap>>, AMap>\n\n  const stateSchema = def.state as Schema.Schema<any, any>\n  const moduleTraitsSpec = def.traits as StateTrait.StateTraitSpec<any> | undefined\n  const baseProgram: StateTraitProgram<any> | undefined = moduleTraitsSpec\n    ? StateTrait.build(stateSchema as any, moduleTraitsSpec as any)\n    : undefined\n\n  if (baseProgram) {\n    // \u4F9B TraitLifecycle/Debug/Devtools \u8BFB\u53D6\uFF08\u5B9A\u4E49\u4FA7\u9690\u85CF\u69FD\u4F4D\uFF09\u3002\n    setModuleTraitsProgram(moduleTag as any, baseProgram)\n    ModuleTraitsRegistry.registerModuleProgram(id, baseProgram as StateTraitProgram<any>)\n  }\n\n  // 023\uFF1Atraits \u7684\u201C\u58F0\u660E\u5165\u53E3/\u5408\u5E76\u5165\u53E3\u201D\u7EDF\u4E00\u6536\u655B\u5230 setup \u9636\u6BB5\uFF1A\n  // - module-level traits \u5148\u4F5C\u4E3A contribution \u6CE8\u518C\uFF1B\n  // - logic-level \u901A\u8FC7 $.traits.declare \u6CE8\u518C\uFF1B\n  // - \u6700\u540E\u4E00\u6B21\u6027 finalize \u2192 freeze \u2192 build/install\u3002\n\n  const makeModuleTraitsContributionLogic = (traits: unknown): ModuleLogic<Sh, never, never> => {\n    const logic = moduleTag.logic(($) => ({\n      setup: Effect.sync(() => {\n        if (!traits || typeof traits !== 'object') return\n        // module-level provenance\uFF1A\u4EE5 moduleId \u4F5C\u4E3A\u7A33\u5B9A\u951A\u70B9\n        //\uFF08\u5BF9\u9F50 023 data-model\uFF1AoriginType=module, originId=moduleId\uFF09\u3002\n        // \u6CE8\u610F\uFF1AtraitsSpec \u4ECD\u590D\u7528 StateTraitSpec \u7ED3\u6784\uFF0C\u4E0D\u5F15\u5165\u7B2C\u4E8C\u5957 IR\u3002\n        const internals = getBoundInternals($ as any)\n        internals.traits.registerModuleTraitsContribution({\n          traits,\n          provenance: {\n            originType: 'module',\n            originId: id,\n            originIdKind: 'explicit',\n            originLabel: `module:${id}`,\n          },\n        })\n      }),\n      run: Effect.void,\n    })) as ModuleLogic<Sh, never, never>\n\n    LogicUnitMeta.attachLogicUnitMeta(logic as any, {\n      id: '__logix_internal:traits:module_contrib',\n      kind: 'internal',\n      name: 'traits:module_contrib',\n      moduleId: id,\n    })\n    return logic\n  }\n\n  const makeFinalizeTraitsLogic = (): ModuleLogic<Sh, never, never> => {\n    const logic = moduleTag.logic(($) => ({\n      setup: Effect.gen(function* () {\n        const internals = getBoundInternals($ as any)\n        const diagnosticsLevel = yield* FiberRef.get(Debug.currentDiagnosticsLevel)\n\n        const contributions = internals.traits.getModuleTraitsContributions()\n        let merged: ModuleTraits.TraitSpec\n        let snapshot: ModuleTraits.ModuleTraitsSnapshot\n\n        try {\n          ;({ merged, snapshot } = ModuleTraits.finalizeTraitContributions({\n            moduleId: id,\n            contributions,\n          }))\n        } catch (cause) {\n          if (\n            diagnosticsLevel !== 'off' &&\n            cause &&\n            typeof cause === 'object' &&\n            (cause as any)._tag === 'ModuleTraitsConflictError'\n          ) {\n            const conflicts = Array.isArray((cause as any).conflicts)\n              ? ((cause as any).conflicts as ReadonlyArray<unknown>)\n              : []\n            const traitIds = conflicts\n              .map((c: any) => (c && typeof c === 'object' ? (c as any).traitId : undefined))\n              .filter((t): t is string => typeof t === 'string' && t.length > 0)\n              .slice(0, 20)\n\n            const data =\n              diagnosticsLevel === 'full'\n                ? {\n                    conflictCount: conflicts.length,\n                    conflicts,\n                  }\n                : {\n                    conflictCount: conflicts.length,\n                    traitIds,\n                  }\n\n            yield* Debug.record({\n              type: 'trace:module:traits:conflict',\n              moduleId: id,\n              instanceId: internals.instanceId,\n              data,\n            } as any)\n          }\n\n          throw cause\n        }\n\n        internals.traits.setModuleTraitsSnapshot(snapshot)\n        internals.traits.freezeModuleTraits()\n\n        if (diagnosticsLevel !== 'off') {\n          const data =\n            diagnosticsLevel === 'full'\n              ? {\n                  digest: snapshot.digest,\n                  count: snapshot.traits.length,\n                  traits: snapshot.traits,\n                  provenanceIndex: snapshot.provenanceIndex,\n                }\n              : {\n                  digest: snapshot.digest,\n                  count: snapshot.traits.length,\n                }\n\n          yield* Debug.record({\n            type: 'trace:module:traits',\n            moduleId: id,\n            instanceId: internals.instanceId,\n            data,\n          } as any)\n        }\n\n        if (Object.keys(merged).length === 0) {\n          return\n        }\n\n        const onlyModuleLevel = contributions.length === 1 && contributions[0]?.provenance?.originType === 'module'\n\n        // \u57FA\u4E8E\u6700\u7EC8\u5408\u5E76\u540E\u7684 Spec \u6784\u9020\u4E00\u6B21\u6027 Program\uFF0C\u5E76\u5728\u521D\u59CB\u5316\u9636\u6BB5\u5B89\u88C5\u3002\n        // - \u82E5\u53EA\u6709 module-level contribution\uFF0C\u5219\u590D\u7528 ModuleTag.make \u9636\u6BB5\u9884\u6784\u5EFA\u7684 program\uFF08\u4FBF\u4E8E Debug/TraitLifecycle\uFF09\u3002\n        const program =\n          onlyModuleLevel && baseProgram ? baseProgram : StateTrait.build(stateSchema as any, merged as any)\n\n        // \u4F9B TraitLifecycle/Debug/Devtools \u8BFB\u53D6\uFF08\u5B9A\u4E49\u4FA7\u9690\u85CF\u69FD\u4F4D\uFF09\u3002\n        setModuleTraitsProgram(moduleTag as any, program)\n        ModuleTraitsRegistry.registerModuleProgram(id, program as StateTraitProgram<any>)\n\n        yield* StateTrait.install($ as unknown as BoundApi<any, any>, program)\n      }),\n      run: Effect.void,\n    })) as ModuleLogic<Sh, never, never>\n\n    LogicUnitMeta.attachLogicUnitMeta(logic as any, {\n      id: '__logix_internal:traits:finalize',\n      kind: 'internal',\n      name: 'traits:finalize',\n      moduleId: id,\n    })\n\n    return logic\n  }\n\n  // \u5305\u88C5 implement\uFF1A\u5728\u5B9E\u73B0\u5C42\u6CE8\u5165\uFF081\uFF09module-level contribution logic\uFF08\u53EF\u9009\uFF09\uFF082\uFF09finalize+install logic\uFF08\u5FC5\u9009\uFF09\u3002\n  const originalImplement = moduleTag.implement\n  ;(moduleTag as any).implement = (<R = never>(config: {\n    initial: StateOf<typeof moduleTag.shape>\n    logics?: Array<ModuleLogic<typeof moduleTag.shape, R, any>>\n    imports?: ReadonlyArray<Layer.Layer<any, any, any> | ModuleImpl<any, AnyModuleShape, any>>\n    processes?: ReadonlyArray<Effect.Effect<void, any, any>>\n  }) => {\n    const userLogics = (config.logics ?? []) as Array<ModuleLogic<typeof moduleTag.shape, R, any>>\n\n    const moduleLevel = def.traits ? [makeModuleTraitsContributionLogic(def.traits) as any] : []\n\n    const finalize = makeFinalizeTraitsLogic() as ModuleLogic<typeof moduleTag.shape, R, any>\n\n    const mergedLogics = [...moduleLevel, ...userLogics, finalize]\n\n    return originalImplement<R>({\n      ...config,\n      logics: mergedLogics,\n    })\n  }) as typeof moduleTag.implement\n\n  return moduleTag\n}\n", "import { fnv1a32, stableStringify } from '../../digest.js'\n\nexport type TraitId = string\n\nexport type TraitOriginType = 'module' | 'logicUnit'\nexport type TraitOriginIdKind = 'explicit' | 'derived'\n\nexport interface TraitProvenance {\n  readonly originType: TraitOriginType\n  readonly originId: string\n  readonly originIdKind: TraitOriginIdKind\n  /**\n   * \u7ED9 Devtools/\u9519\u8BEF\u4FE1\u606F\u5C55\u793A\u7684\u53EF\u8BFB\u6807\u7B7E\uFF08\u4F8B\u5982 \"logicUnit:Profile#1\"\uFF09\u3002\n   */\n  readonly originLabel: string\n  /**\n   * \u53EF\u9009\uFF1A\u58F0\u660E\u4F4D\u7F6E\u6458\u8981\uFF08\u4F8B\u5982\u6587\u4EF6\u8DEF\u5F84/\u8C03\u7528\u70B9\uFF09\uFF0C\u4EC5\u7528\u4E8E\u5B9A\u4F4D\uFF0C\u4E0D\u53C2\u4E0E\u8BED\u4E49\u88C1\u51B3\u3002\n   */\n  readonly path?: string\n}\n\n/**\n * TraitSpec\uFF1A\n * - \u4F5C\u4E3A\u201Ctraits \u58F0\u660E\u201D\u7684\u6700\u5C0F\u5F62\u6001\uFF1A\u4E00\u7EC4\u4EE5 traitId \u4E3A key \u7684\u58F0\u660E\u5BF9\u8C61\uFF1B\n * - \u5177\u4F53 value \u5F62\u6001\u7531\u5177\u4F53 trait \u7CFB\u7EDF\uFF08\u5982 StateTraitSpec\uFF09\u51B3\u5B9A\uFF1B\n * - \u8FD9\u91CC\u4E0D\u7EA6\u675F value \u7684\u53EF\u5E8F\u5217\u5316\u6027\uFF08\u8FD0\u884C\u671F install \u53EF\u80FD\u4F9D\u8D56\u51FD\u6570\uFF09\uFF0C\u4F46 Snapshot/\u8BC1\u636E\u5BFC\u51FA\u5FC5\u987B\u53EA\u53D6\u53EF\u5E8F\u5217\u5316\u5B50\u96C6\u3002\n */\nexport type TraitSpec = object\n\nexport interface TraitContribution {\n  readonly traits: TraitSpec\n  readonly provenance: TraitProvenance\n}\n\nexport interface ModuleTraitItem {\n  readonly traitId: TraitId\n  readonly name: string\n  readonly description?: string\n}\n\nexport type TraitConflictKind = 'duplicate_traitId' | 'missing_requires' | 'excludes_violation'\n\nexport interface TraitConflict {\n  readonly kind: TraitConflictKind\n  readonly traitId: TraitId\n  readonly sources: ReadonlyArray<TraitProvenance>\n  readonly missing?: ReadonlyArray<TraitId>\n  readonly present?: ReadonlyArray<TraitId>\n}\n\nexport class ModuleTraitsConflictError extends Error {\n  readonly _tag = 'ModuleTraitsConflictError'\n\n  constructor(\n    readonly moduleId: string,\n    readonly conflicts: ReadonlyArray<TraitConflict>,\n  ) {\n    super(\n      [\n        `[ModuleTraitsConflictError] Conflicting traitIds found (moduleId=${moduleId}).`,\n        ...conflicts.map((c) =>\n          c.kind === 'duplicate_traitId'\n            ? `- duplicate ${c.traitId}: ${c.sources.map((s) => `${s.originType}:${s.originId}`).join(', ')}`\n            : c.kind === 'missing_requires'\n              ? `- missing requires for ${c.traitId}: ${(c.missing ?? []).join(', ')}; sources=${c.sources\n                  .map((s) => `${s.originType}:${s.originId}`)\n                  .join(', ')}`\n              : `- excludes violation for ${c.traitId}: present=${(c.present ?? []).join(', ')}; sources=${c.sources\n                  .map((s) => `${s.originType}:${s.originId}`)\n                  .join(', ')}`,\n        ),\n      ].join('\\n'),\n    )\n  }\n}\n\nexport interface ModuleTraitsSnapshot {\n  readonly moduleId: string\n  readonly digest: string\n  readonly traits: ReadonlyArray<ModuleTraitItem>\n  readonly provenanceIndex: Record<TraitId, TraitProvenance>\n}\n\nconst toProvenanceKey = (p: TraitProvenance): string =>\n  `${p.originType}:${p.originId}:${p.originIdKind}:${p.originLabel}:${p.path ?? ''}`\n\nconst compareProvenance = (a: TraitProvenance, b: TraitProvenance): number => {\n  const type = a.originType.localeCompare(b.originType)\n  if (type !== 0) return type\n  const id = a.originId.localeCompare(b.originId)\n  if (id !== 0) return id\n  const kind = a.originIdKind.localeCompare(b.originIdKind)\n  if (kind !== 0) return kind\n  const label = a.originLabel.localeCompare(b.originLabel)\n  if (label !== 0) return label\n  return String(a.path ?? '').localeCompare(String(b.path ?? ''))\n}\n\nconst originTypeOrder = (t: TraitOriginType): number => (t === 'module' ? 0 : 1)\n\nconst compareTraitIdByProvenance = (\n  a: { readonly traitId: TraitId; readonly provenance: TraitProvenance },\n  b: { readonly traitId: TraitId; readonly provenance: TraitProvenance },\n): number => {\n  const ta = originTypeOrder(a.provenance.originType) - originTypeOrder(b.provenance.originType)\n  if (ta !== 0) return ta\n  const oa = a.provenance.originId.localeCompare(b.provenance.originId)\n  if (oa !== 0) return oa\n  return a.traitId.localeCompare(b.traitId)\n}\n\nconst extractStringArray = (value: unknown): ReadonlyArray<string> => {\n  if (!Array.isArray(value)) return []\n  const out: Array<string> = []\n  for (const v of value) {\n    if (typeof v !== 'string') continue\n    const s = v.trim()\n    if (!s) continue\n    out.push(s)\n  }\n  return out\n}\n\nconst getTraitRequires = (value: unknown): ReadonlyArray<TraitId> => {\n  if (!value || typeof value !== 'object') return []\n  const direct = extractStringArray((value as any).requires)\n  return direct\n}\n\nconst getTraitExcludes = (value: unknown): ReadonlyArray<TraitId> => {\n  if (!value || typeof value !== 'object') return []\n  const direct = extractStringArray((value as any).excludes)\n  return direct\n}\n\nconst getTraitName = (traitId: TraitId, value: unknown): string => {\n  if (value && typeof value === 'object') {\n    const n = (value as any).name\n    if (typeof n === 'string' && n.trim().length > 0) return n.trim()\n  }\n  return traitId\n}\n\nconst getTraitDescription = (value: unknown): string | undefined => {\n  if (value && typeof value === 'object') {\n    const d = (value as any).description\n    if (typeof d === 'string' && d.trim().length > 0) return d.trim()\n  }\n  return undefined\n}\n\nexport const finalizeTraitContributions = (args: {\n  readonly moduleId: string\n  readonly contributions: ReadonlyArray<TraitContribution>\n}): { readonly merged: TraitSpec; readonly snapshot: ModuleTraitsSnapshot } => {\n  const traitById = new Map<TraitId, { readonly value: unknown; readonly provenance: TraitProvenance }>()\n\n  const duplicateSources = new Map<TraitId, Array<TraitProvenance>>()\n\n  const contributions = [...args.contributions].sort((a, b) => compareProvenance(a.provenance, b.provenance))\n\n  for (const c of contributions) {\n    const traits = c.traits\n    if (!traits || typeof traits !== 'object') continue\n    for (const traitId of Object.keys(traits).sort((a, b) => a.localeCompare(b))) {\n      const value = (traits as Record<string, unknown>)[traitId]\n      if (value === undefined) continue\n\n      const prev = traitById.get(traitId)\n      if (!prev) {\n        traitById.set(traitId, { value, provenance: c.provenance })\n        continue\n      }\n\n      const sources = duplicateSources.get(traitId) ?? [prev.provenance]\n      sources.push(c.provenance)\n      duplicateSources.set(traitId, sources)\n    }\n  }\n\n  const conflicts: Array<TraitConflict> = []\n  const registerConflict = (conflict: TraitConflict) => {\n    const unique = new Map<string, TraitProvenance>()\n    for (const s of conflict.sources) {\n      unique.set(toProvenanceKey(s), s)\n    }\n    conflicts.push({\n      ...conflict,\n      sources: Array.from(unique.values()).sort(compareProvenance),\n    })\n  }\n\n  // 1) duplicate traitId conflicts\n  for (const traitId of Array.from(duplicateSources.keys()).sort((a, b) => a.localeCompare(b))) {\n    registerConflict({\n      kind: 'duplicate_traitId',\n      traitId,\n      sources: duplicateSources.get(traitId) ?? [],\n    })\n  }\n\n  const merged: Record<string, unknown> = {}\n  const provenanceIndex: Record<string, TraitProvenance> = {}\n  const traits: Array<ModuleTraitItem> = []\n\n  const entries: Array<{ readonly traitId: TraitId; readonly value: unknown; readonly provenance: TraitProvenance }> =\n    []\n  for (const traitId of traitById.keys()) {\n    const entry = traitById.get(traitId)\n    if (!entry) continue\n    entries.push({ traitId, value: entry.value, provenance: entry.provenance })\n  }\n\n  const ids = entries\n    .slice()\n    .sort(compareTraitIdByProvenance)\n    .map((e) => e.traitId)\n\n  for (const traitId of ids) {\n    const entry = traitById.get(traitId)\n    if (!entry) continue\n    merged[traitId] = entry.value\n    provenanceIndex[traitId] = entry.provenance\n    traits.push({\n      traitId,\n      name: getTraitName(traitId, entry.value),\n      description: getTraitDescription(entry.value),\n    })\n  }\n\n  // 2) consistency checks (FR-007): requires / excludes\n  const present = new Set(ids)\n\n  for (const traitId of ids) {\n    const entry = traitById.get(traitId)\n    if (!entry) continue\n\n    const requires = getTraitRequires(entry.value)\n    if (requires.length > 0) {\n      const missing = requires.filter((r) => !present.has(r))\n      if (missing.length > 0) {\n        registerConflict({\n          kind: 'missing_requires',\n          traitId,\n          missing: Array.from(new Set(missing)).sort((a, b) => a.localeCompare(b)),\n          sources: [entry.provenance],\n        })\n      }\n    }\n\n    const excludes = getTraitExcludes(entry.value)\n    if (excludes.length > 0) {\n      const presentExcluded = excludes.filter((e) => present.has(e))\n      if (presentExcluded.length > 0) {\n        const otherSources: Array<TraitProvenance> = []\n        for (const otherId of presentExcluded) {\n          const other = traitById.get(otherId)\n          if (other) otherSources.push(other.provenance)\n        }\n        registerConflict({\n          kind: 'excludes_violation',\n          traitId,\n          present: Array.from(new Set(presentExcluded)).sort((a, b) => a.localeCompare(b)),\n          sources: [entry.provenance, ...otherSources],\n        })\n      }\n    }\n  }\n\n  if (conflicts.length > 0) {\n    const kindOrder: Record<TraitConflictKind, number> = {\n      duplicate_traitId: 0,\n      missing_requires: 1,\n      excludes_violation: 2,\n    }\n    conflicts.sort((a, b) => {\n      const k = kindOrder[a.kind] - kindOrder[b.kind]\n      if (k !== 0) return k\n      return a.traitId.localeCompare(b.traitId)\n    })\n    throw new ModuleTraitsConflictError(args.moduleId, conflicts)\n  }\n\n  const digestBase = {\n    moduleId: args.moduleId,\n    traits,\n    provenanceIndex,\n  } as const\n\n  const digest = `mtraits:023:${fnv1a32(stableStringify(digestBase))}`\n\n  return {\n    merged,\n    snapshot: {\n      moduleId: args.moduleId,\n      digest,\n      traits,\n      provenanceIndex,\n    },\n  }\n}\n"],
  "mappings": "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",
  "names": ["traits"]
}


package/public/sandbox/chunks/{chunk-3LX3KIQQ.js → chunk-W365QUZ5.js}

@@ -2,13 +2,11 @@
 
 import {
   OBSERVABILITY_PROTOCOL_VERSION,
-  exportEvidencePackage
-} from "./chunk-BWSNPKO5.js";
-import {
   composeMiddleware,
+  exportEvidencePackage,
   makeOperationRejected,
   runWithMiddleware
-} from "./chunk-TOQ6SJ6O.js";
+} from "./chunk-SI5OKFFY.js";
 
 // ../logix-core/src/internal/observability/runSession.ts
 import { Context, Layer } from "../effect.js";
@@ -174,4 +172,4 @@ export {
   withMeta,
   run
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/observability/runSession.ts", "../../../../logix-core/src/internal/effect-op.ts"],
  "sourcesContent": ["import { Context, Layer } from 'effect'\nimport type { JsonValue } from './jsonValue.js'\nimport type { EvidencePackage, EvidencePackageSource, ObservationEnvelope } from './evidence.js'\nimport { exportEvidencePackage, OBSERVABILITY_PROTOCOL_VERSION } from './evidence.js'\n\nexport type RunId = string\n\nexport interface RunSessionLocalState {\n  /**\n   * once: a de-dup key set for \"emit only once\" behavior (must be isolated per session to avoid cross-session pollution).\n   * Returns true if it's the first occurrence, false if the key has been seen before.\n   */\n  readonly once: (key: string) => boolean\n\n  /**\n   * seq: allocate monotonic sequences by key (e.g. opSeq/eventSeq), must be isolated per session.\n   */\n  readonly nextSeq: (namespace: string, key: string) => number\n\n  /** Tests/reset only: clear this session's local state. */\n  readonly clear: () => void\n}\n\nexport interface RunSession {\n  readonly runId: RunId\n  readonly source: EvidencePackageSource\n  readonly startedAt: number\n  readonly local: RunSessionLocalState\n}\n\nclass RunSessionTagImpl extends Context.Tag('@logixjs/core/RunSession')<RunSessionTagImpl, RunSession>() {}\n\nexport const RunSessionTag = RunSessionTagImpl\n\nexport interface EvidenceSink {\n  readonly record: (type: string, payload: JsonValue, options?: { readonly timestamp?: number }) => void\n  readonly export: (options?: {\n    readonly protocolVersion?: string\n    readonly createdAt?: number\n    readonly summary?: JsonValue\n    readonly maxEvents?: number\n  }) => EvidencePackage\n  readonly clear: () => void\n}\n\nconst NEXT_RUN_SEQ_KEY = Symbol.for('@logixjs/core/runSession/nextRunSeq')\nlet fallbackNextRunSeq = 0\n\nconst nextRunSeq = (): number => {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const g: any = globalThis as any\n    const prev = typeof g[NEXT_RUN_SEQ_KEY] === 'number' ? (g[NEXT_RUN_SEQ_KEY] as number) : 0\n    const next = prev + 1\n    g[NEXT_RUN_SEQ_KEY] = next\n    return next\n  } catch {\n    fallbackNextRunSeq += 1\n    return fallbackNextRunSeq\n  }\n}\n\nconst makeRunId = (startedAt: number): RunId => `run-${startedAt}.${nextRunSeq()}`\n\nexport const makeRunSessionLocalState = (): RunSessionLocalState => {\n  const onceKeys = new Set<string>()\n  const seqByNamespace = new Map<string, Map<string, number>>()\n\n  return {\n    once: (key) => {\n      if (onceKeys.has(key)) return false\n      onceKeys.add(key)\n      return true\n    },\n    nextSeq: (namespace, key) => {\n      const byKey = seqByNamespace.get(namespace) ?? new Map<string, number>()\n      if (!seqByNamespace.has(namespace)) seqByNamespace.set(namespace, byKey)\n      const prev = byKey.get(key) ?? 0\n      const next = prev + 1\n      byKey.set(key, next)\n      return next\n    },\n    clear: () => {\n      onceKeys.clear()\n      seqByNamespace.clear()\n    },\n  }\n}\n\nexport const makeRunSession = (options?: {\n  readonly runId?: RunId\n  readonly source?: EvidencePackageSource\n  readonly startedAt?: number\n  readonly local?: RunSessionLocalState\n}): RunSession => {\n  const startedAt = options?.startedAt ?? Date.now()\n  return {\n    runId: options?.runId ?? makeRunId(startedAt),\n    source: options?.source ?? { host: 'unknown' },\n    startedAt,\n    local: options?.local ?? makeRunSessionLocalState(),\n  }\n}\n\nexport const makeEvidenceSink = (session: RunSession): EvidenceSink => {\n  const events: ObservationEnvelope[] = []\n  let nextSeq = 1\n\n  return {\n    record: (type, payload, options) => {\n      events.push({\n        protocolVersion: OBSERVABILITY_PROTOCOL_VERSION,\n        runId: session.runId,\n        seq: nextSeq++,\n        timestamp: options?.timestamp ?? Date.now(),\n        type,\n        payload,\n      })\n    },\n    export: (options) => {\n      const protocolVersion = options?.protocolVersion ?? OBSERVABILITY_PROTOCOL_VERSION\n      const maxEvents = options?.maxEvents\n\n      const selected =\n        typeof maxEvents === 'number' && Number.isFinite(maxEvents) && maxEvents > 0\n          ? events.slice(Math.max(0, events.length - Math.floor(maxEvents)))\n          : events.slice()\n\n      return exportEvidencePackage({\n        protocolVersion,\n        runId: session.runId,\n        source: session.source,\n        createdAt: options?.createdAt,\n        events: selected,\n        summary: options?.summary,\n      })\n    },\n    clear: () => {\n      events.length = 0\n      nextSeq = 1\n    },\n  }\n}\n\nexport const runSessionLayer = (session?: RunSession): Layer.Layer<RunSessionTagImpl, never, never> =>\n  Layer.succeed(RunSessionTag, session ?? makeRunSession()) as Layer.Layer<RunSessionTagImpl, never, never>\n", "// Internal EffectOp API (for internal implementation code).\n//\n// Goal:\n// - Internal modules must never import root public submodules (e.g. `../EffectOp`).\n// - This file hosts the shared implementation; public `src/EffectOp.ts` delegates to it.\n\nimport { Effect, Option } from 'effect'\nimport * as Core from './runtime/core/EffectOpCore.js'\nimport { RunSessionTag } from './observability/runSession.js'\n\nexport type EffectOp<Out = unknown, Err = unknown, Env = unknown> = Core.EffectOp<Out, Err, Env>\n\nexport type OperationPolicy = Core.OperationPolicy\n\nexport type OperationRejected = Core.OperationRejected\n\nexport type OperationError<E> = Core.OperationError<E>\n\nexport type Middleware = Core.Middleware\n\nexport type MiddlewareStack = Core.MiddlewareStack\n\nexport const composeMiddleware = Core.composeMiddleware\n\nexport const makeOperationRejected = Core.makeOperationRejected\n\n/**\n * Generate a stable id for identifying an EffectOp.\n * - Uses a monotonic sequence by default to avoid non-replayability from randomness/time.\n * - If meta.instanceId is available, prefer deriving `${instanceId}::o${opSeq}`.\n */\nlet nextGlobalOpSeq = 0\n\nconst nextOpSeq = (): number => {\n  nextGlobalOpSeq += 1\n  return nextGlobalOpSeq\n}\n\nconst makeId = (instanceId: string | undefined, opSeq: number): string =>\n  instanceId ? `${instanceId}::o${opSeq}` : `o${opSeq}`\n\n/**\n * EffectOp.make\uFF1A\n * - Create an EffectOp with basic meta.\n * - Generates a stable id by default (based on `instanceId` + monotonic `opSeq`); callers may override externally.\n */\nexport const make = <A, E, R>(params: {\n  readonly kind: EffectOp['kind']\n  readonly name: string\n  readonly effect: Effect.Effect<A, E, R>\n  readonly payload?: unknown\n  readonly meta?: EffectOp['meta']\n  readonly id?: string\n}): EffectOp<A, E, R> => ({\n  ...(params.id\n    ? { id: params.id, meta: params.meta }\n    : (() => {\n        const meta: any = params.meta ?? {}\n        const instanceId: string | undefined = meta.instanceId\n        const opSeq: number =\n          typeof meta.opSeq === 'number' && Number.isFinite(meta.opSeq) ? Math.floor(meta.opSeq) : nextOpSeq()\n        return {\n          id: makeId(instanceId, opSeq),\n          meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq },\n        }\n      })()),\n  kind: params.kind,\n  name: params.name,\n  payload: params.payload,\n  effect: params.effect,\n})\n\n/**\n * EffectOp.makeInRunSession\uFF1A\n * - Allocate a stable `opSeq` within a RunSession scope (per-session + per-instance).\n * - If RunSession is missing from Env, fall back to a process-wide monotonic sequence (no process-wide Map).\n */\nexport const makeInRunSession = <A, E, R>(params: {\n  readonly kind: EffectOp['kind']\n  readonly name: string\n  readonly effect: Effect.Effect<A, E, R>\n  readonly payload?: unknown\n  readonly meta?: EffectOp['meta']\n  readonly id?: string\n}): Effect.Effect<EffectOp<A, E, R>, never, any> =>\n  Effect.gen(function* () {\n    if (params.id) {\n      return {\n        id: params.id,\n        kind: params.kind,\n        name: params.name,\n        payload: params.payload,\n        meta: params.meta,\n        effect: params.effect,\n      } satisfies EffectOp<A, E, R>\n    }\n\n    const meta: any = params.meta ?? {}\n    const instanceId: string | undefined = meta.instanceId\n\n    let opSeq: number\n    if (typeof meta.opSeq === 'number' && Number.isFinite(meta.opSeq)) {\n      opSeq = Math.floor(meta.opSeq)\n    } else {\n      const sessionOpt = yield* Effect.serviceOption(RunSessionTag)\n      if (Option.isSome(sessionOpt)) {\n        const key = instanceId ?? 'global'\n        opSeq = sessionOpt.value.local.nextSeq('opSeq', key)\n      } else {\n        opSeq = nextOpSeq()\n      }\n    }\n\n    return {\n      id: makeId(instanceId, opSeq),\n      kind: params.kind,\n      name: params.name,\n      payload: params.payload,\n      meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq },\n      effect: params.effect,\n    } satisfies EffectOp<A, E, R>\n  })\n\n/**\n * EffectOp.withMeta\uFF1A\n * - Append or override meta fields on an existing EffectOp.\n * - Does not change the effect itself.\n */\nexport const withMeta = <A, E, R>(\n  op: EffectOp<A, E, R>,\n  meta: Partial<NonNullable<EffectOp['meta']>>,\n): EffectOp<A, E, R> => ({\n  ...op,\n  meta: { ...(op.meta ?? {}), ...meta },\n})\n\n/**\n * EffectOp.run\uFF1A\n * - Execute an EffectOp using the given MiddlewareStack.\n * - If the stack is empty, return op.effect directly.\n */\nexport const run = <A, E, R>(op: EffectOp<A, E, R>, stack: MiddlewareStack): Effect.Effect<A, E, R> =>\n  Core.runWithMiddleware(op, stack)\n"],
  "mappings": "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",
  "names": ["composeMiddleware", "makeOperationRejected"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/observability/runSession.ts", "../../../../logix-core/src/internal/effect-op.ts"],
  "sourcesContent": ["import { Context, Layer } from 'effect'\nimport type { JsonValue } from './jsonValue.js'\nimport type { EvidencePackage, EvidencePackageSource, ObservationEnvelope } from './evidence.js'\nimport { exportEvidencePackage, OBSERVABILITY_PROTOCOL_VERSION } from './evidence.js'\n\nexport type RunId = string\n\nexport interface RunSessionLocalState {\n  /**\n   * once: a de-dup key set for \"emit only once\" behavior (must be isolated per session to avoid cross-session pollution).\n   * Returns true if it's the first occurrence, false if the key has been seen before.\n   */\n  readonly once: (key: string) => boolean\n\n  /**\n   * seq: allocate monotonic sequences by key (e.g. opSeq/eventSeq), must be isolated per session.\n   */\n  readonly nextSeq: (namespace: string, key: string) => number\n\n  /** Tests/reset only: clear this session's local state. */\n  readonly clear: () => void\n}\n\nexport interface RunSession {\n  readonly runId: RunId\n  readonly source: EvidencePackageSource\n  readonly startedAt: number\n  readonly local: RunSessionLocalState\n}\n\nclass RunSessionTagImpl extends Context.Tag('@logixjs/core/RunSession')<RunSessionTagImpl, RunSession>() {}\n\nexport const RunSessionTag = RunSessionTagImpl\n\nexport interface EvidenceSink {\n  readonly record: (type: string, payload: JsonValue, options?: { readonly timestamp?: number }) => void\n  readonly export: (options?: {\n    readonly protocolVersion?: string\n    readonly createdAt?: number\n    readonly summary?: JsonValue\n    readonly maxEvents?: number\n  }) => EvidencePackage\n  readonly clear: () => void\n}\n\nconst NEXT_RUN_SEQ_KEY = Symbol.for('@logixjs/core/runSession/nextRunSeq')\nlet fallbackNextRunSeq = 0\n\nconst nextRunSeq = (): number => {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const g: any = globalThis as any\n    const prev = typeof g[NEXT_RUN_SEQ_KEY] === 'number' ? (g[NEXT_RUN_SEQ_KEY] as number) : 0\n    const next = prev + 1\n    g[NEXT_RUN_SEQ_KEY] = next\n    return next\n  } catch {\n    fallbackNextRunSeq += 1\n    return fallbackNextRunSeq\n  }\n}\n\nconst makeRunId = (startedAt: number): RunId => `run-${startedAt}.${nextRunSeq()}`\n\nexport const makeRunSessionLocalState = (): RunSessionLocalState => {\n  const onceKeys = new Set<string>()\n  const seqByNamespace = new Map<string, Map<string, number>>()\n\n  return {\n    once: (key) => {\n      if (onceKeys.has(key)) return false\n      onceKeys.add(key)\n      return true\n    },\n    nextSeq: (namespace, key) => {\n      const byKey = seqByNamespace.get(namespace) ?? new Map<string, number>()\n      if (!seqByNamespace.has(namespace)) seqByNamespace.set(namespace, byKey)\n      const prev = byKey.get(key) ?? 0\n      const next = prev + 1\n      byKey.set(key, next)\n      return next\n    },\n    clear: () => {\n      onceKeys.clear()\n      seqByNamespace.clear()\n    },\n  }\n}\n\nexport const makeRunSession = (options?: {\n  readonly runId?: RunId\n  readonly source?: EvidencePackageSource\n  readonly startedAt?: number\n  readonly local?: RunSessionLocalState\n}): RunSession => {\n  const startedAt = options?.startedAt ?? Date.now()\n  return {\n    runId: options?.runId ?? makeRunId(startedAt),\n    source: options?.source ?? { host: 'unknown' },\n    startedAt,\n    local: options?.local ?? makeRunSessionLocalState(),\n  }\n}\n\nexport const makeEvidenceSink = (session: RunSession): EvidenceSink => {\n  const events: ObservationEnvelope[] = []\n  let nextSeq = 1\n\n  return {\n    record: (type, payload, options) => {\n      events.push({\n        protocolVersion: OBSERVABILITY_PROTOCOL_VERSION,\n        runId: session.runId,\n        seq: nextSeq++,\n        timestamp: options?.timestamp ?? Date.now(),\n        type,\n        payload,\n      })\n    },\n    export: (options) => {\n      const protocolVersion = options?.protocolVersion ?? OBSERVABILITY_PROTOCOL_VERSION\n      const maxEvents = options?.maxEvents\n\n      const selected =\n        typeof maxEvents === 'number' && Number.isFinite(maxEvents) && maxEvents > 0\n          ? events.slice(Math.max(0, events.length - Math.floor(maxEvents)))\n          : events.slice()\n\n      return exportEvidencePackage({\n        protocolVersion,\n        runId: session.runId,\n        source: session.source,\n        createdAt: options?.createdAt,\n        events: selected,\n        summary: options?.summary,\n      })\n    },\n    clear: () => {\n      events.length = 0\n      nextSeq = 1\n    },\n  }\n}\n\nexport const runSessionLayer = (session?: RunSession): Layer.Layer<RunSessionTagImpl, never, never> =>\n  Layer.succeed(RunSessionTag, session ?? makeRunSession()) as Layer.Layer<RunSessionTagImpl, never, never>\n", "// Internal EffectOp API (for internal implementation code).\n//\n// Goal:\n// - Internal modules must never import root public submodules (e.g. `../EffectOp`).\n// - This file hosts the shared implementation; public `src/EffectOp.ts` delegates to it.\n\nimport { Effect, Option } from 'effect'\nimport * as Core from './runtime/core/EffectOpCore.js'\nimport { RunSessionTag } from './observability/runSession.js'\n\nexport type EffectOp<Out = unknown, Err = unknown, Env = unknown> = Core.EffectOp<Out, Err, Env>\n\nexport type OperationPolicy = Core.OperationPolicy\n\nexport type OperationRejected = Core.OperationRejected\n\nexport type OperationError<E> = Core.OperationError<E>\n\nexport type Middleware = Core.Middleware\n\nexport type MiddlewareStack = Core.MiddlewareStack\n\nexport const composeMiddleware = Core.composeMiddleware\n\nexport const makeOperationRejected = Core.makeOperationRejected\n\n/**\n * Generate a stable id for identifying an EffectOp.\n * - Uses a monotonic sequence by default to avoid non-replayability from randomness/time.\n * - If meta.instanceId is available, prefer deriving `${instanceId}::o${opSeq}`.\n */\nlet nextGlobalOpSeq = 0\n\nconst nextOpSeq = (): number => {\n  nextGlobalOpSeq += 1\n  return nextGlobalOpSeq\n}\n\nconst makeId = (instanceId: string | undefined, opSeq: number): string =>\n  instanceId ? `${instanceId}::o${opSeq}` : `o${opSeq}`\n\n/**\n * EffectOp.make\uFF1A\n * - Create an EffectOp with basic meta.\n * - Generates a stable id by default (based on `instanceId` + monotonic `opSeq`); callers may override externally.\n */\nexport const make = <A, E, R>(params: {\n  readonly kind: EffectOp['kind']\n  readonly name: string\n  readonly effect: Effect.Effect<A, E, R>\n  readonly payload?: unknown\n  readonly meta?: EffectOp['meta']\n  readonly id?: string\n}): EffectOp<A, E, R> => ({\n  ...(params.id\n    ? { id: params.id, meta: params.meta }\n    : (() => {\n        const meta: any = params.meta ?? {}\n        const instanceId: string | undefined = meta.instanceId\n        const opSeq: number =\n          typeof meta.opSeq === 'number' && Number.isFinite(meta.opSeq) ? Math.floor(meta.opSeq) : nextOpSeq()\n        return {\n          id: makeId(instanceId, opSeq),\n          meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq },\n        }\n      })()),\n  kind: params.kind,\n  name: params.name,\n  payload: params.payload,\n  effect: params.effect,\n})\n\n/**\n * EffectOp.makeInRunSession\uFF1A\n * - Allocate a stable `opSeq` within a RunSession scope (per-session + per-instance).\n * - If RunSession is missing from Env, fall back to a process-wide monotonic sequence (no process-wide Map).\n */\nexport const makeInRunSession = <A, E, R>(params: {\n  readonly kind: EffectOp['kind']\n  readonly name: string\n  readonly effect: Effect.Effect<A, E, R>\n  readonly payload?: unknown\n  readonly meta?: EffectOp['meta']\n  readonly id?: string\n}): Effect.Effect<EffectOp<A, E, R>, never, any> =>\n  Effect.gen(function* () {\n    if (params.id) {\n      return {\n        id: params.id,\n        kind: params.kind,\n        name: params.name,\n        payload: params.payload,\n        meta: params.meta,\n        effect: params.effect,\n      } satisfies EffectOp<A, E, R>\n    }\n\n    const meta: any = params.meta ?? {}\n    const instanceId: string | undefined = meta.instanceId\n\n    let opSeq: number\n    if (typeof meta.opSeq === 'number' && Number.isFinite(meta.opSeq)) {\n      opSeq = Math.floor(meta.opSeq)\n    } else {\n      const sessionOpt = yield* Effect.serviceOption(RunSessionTag)\n      if (Option.isSome(sessionOpt)) {\n        const key = instanceId ?? 'global'\n        opSeq = sessionOpt.value.local.nextSeq('opSeq', key)\n      } else {\n        opSeq = nextOpSeq()\n      }\n    }\n\n    return {\n      id: makeId(instanceId, opSeq),\n      kind: params.kind,\n      name: params.name,\n      payload: params.payload,\n      meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq },\n      effect: params.effect,\n    } satisfies EffectOp<A, E, R>\n  })\n\n/**\n * EffectOp.withMeta\uFF1A\n * - Append or override meta fields on an existing EffectOp.\n * - Does not change the effect itself.\n */\nexport const withMeta = <A, E, R>(\n  op: EffectOp<A, E, R>,\n  meta: Partial<NonNullable<EffectOp['meta']>>,\n): EffectOp<A, E, R> => ({\n  ...op,\n  meta: { ...(op.meta ?? {}), ...meta },\n})\n\n/**\n * EffectOp.run\uFF1A\n * - Execute an EffectOp using the given MiddlewareStack.\n * - If the stack is empty, return op.effect directly.\n */\nexport const run = <A, E, R>(op: EffectOp<A, E, R>, stack: MiddlewareStack): Effect.Effect<A, E, R> =>\n  Core.runWithMiddleware(op, stack)\n"],
  "mappings": "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",
  "names": ["composeMiddleware", "makeOperationRejected"]
}
