@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/chunk-4MY35XR3.js

@@ -0,0 +1,175 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+import {
+  sanitize
+} from "./chunk-X2Z5VYG3.js";
+import {
+  normalizeFieldPath
+} from "./chunk-ASVMK364.js";
+import {
+  getExternalStoreDescriptor
+} from "./chunk-NMGFJZ4I.js";
+import {
+  fnv1a32,
+  stableStringify
+} from "./chunk-DT7YIIWE.js";
+
+// ../logix-core/src/internal/state-trait/ir.ts
+var normalizeFieldPaths = (paths) => {
+  if (!paths || paths.length === 0) return [];
+  const out = [];
+  for (const path of paths) {
+    const normalized = normalizeFieldPath(path);
+    if (normalized) out.push(normalized);
+  }
+  return out;
+};
+var normalizeFieldPath2 = (path) => path ? normalizeFieldPath(path) : void 0;
+var toNodeKind = (step) => {
+  switch (step.kind) {
+    case "computed-update":
+      return "computed";
+    case "link-propagate":
+      return "link";
+    case "source-refresh":
+      return "source";
+    case "external-store-sync":
+      return "externalStore";
+    case "check-validate":
+      return "check";
+  }
+};
+var findEntryForStep = (program, step) => {
+  const fieldPath = step.targetFieldPath;
+  if (!fieldPath) return void 0;
+  const kind = toNodeKind(step);
+  return program.entries.find(
+    (e) => e.fieldPath === fieldPath && (e.kind === kind || kind === "check" && e.kind === "check" || kind === "source" && e.kind === "source" || kind === "link" && e.kind === "link" || kind === "computed" && e.kind === "computed")
+  );
+};
+var getReadsForEntry = (entry) => {
+  if (!entry) return void 0;
+  if (entry.kind === "computed") {
+    return entry.meta.deps;
+  }
+  if (entry.kind === "source") {
+    return entry.meta.deps;
+  }
+  if (entry.kind === "link") {
+    const from = entry.meta.from;
+    return from ? [from] : [];
+  }
+  if (entry.kind === "externalStore") {
+    return [];
+  }
+  if (entry.kind === "check") {
+    const rules = entry.meta?.rules ?? {};
+    const out = [];
+    for (const name of Object.keys(rules)) {
+      const rule = rules[name];
+      const deps = rule?.deps;
+      if (deps) out.push(...deps);
+    }
+    return out;
+  }
+  return void 0;
+};
+var exportStaticIr = (params) => {
+  const moduleId = params.moduleId;
+  const version = params.version ?? "009";
+  const metaByField = /* @__PURE__ */ new Map();
+  for (const node of params.program.graph.nodes) {
+    const meta = node.meta;
+    if (!meta || typeof meta !== "object") continue;
+    const label = typeof meta.label === "string" ? meta.label : void 0;
+    const description = typeof meta.description === "string" ? meta.description : void 0;
+    const tags = Array.isArray(meta.tags) && meta.tags.every((t) => typeof t === "string") ? meta.tags : void 0;
+    const group = typeof meta.group === "string" ? meta.group : void 0;
+    const docsUrl = typeof meta.docsUrl === "string" ? meta.docsUrl : void 0;
+    const cacheGroup = typeof meta.cacheGroup === "string" ? meta.cacheGroup : void 0;
+    const annotationsRaw = meta.annotations;
+    const annotations = annotationsRaw && typeof annotationsRaw === "object" && !Array.isArray(annotationsRaw) ? annotationsRaw : void 0;
+    if (label || description || tags || group || docsUrl || cacheGroup || annotations) {
+      metaByField.set(node.id, {
+        label,
+        description,
+        tags,
+        group,
+        docsUrl,
+        cacheGroup,
+        annotations
+      });
+    }
+  }
+  const nodes = params.program.plan.steps.map((step) => {
+    const kind = toNodeKind(step);
+    const entry = findEntryForStep(params.program, step);
+    const reads = normalizeFieldPaths(getReadsForEntry(entry));
+    const target = step.targetFieldPath;
+    const write = normalizeFieldPath2(target);
+    const writes = write ? [write] : [];
+    const meta = target ? metaByField.get(target) : void 0;
+    const externalStorePolicy = () => {
+      if (kind !== "externalStore") return void 0;
+      if (!entry || entry.kind !== "externalStore") return void 0;
+      const descriptor = getExternalStoreDescriptor(entry.meta.store);
+      const storeId = descriptor?.storeId;
+      const priorityRaw = entry.meta?.priority;
+      const lane = priorityRaw === "nonUrgent" ? "nonUrgent" : "urgent";
+      const meta2 = sanitize(entry.meta.meta);
+      const source = descriptor?.kind === "module" ? {
+        kind: "module",
+        storeId,
+        moduleId: descriptor.moduleId,
+        ...descriptor.instanceId ? { instanceKey: descriptor.instanceId } : {},
+        selectorId: descriptor.readQuery.staticIr.selectorId,
+        readsDigest: descriptor.readQuery.staticIr.readsDigest,
+        fallbackReason: descriptor.readQuery.staticIr.fallbackReason
+      } : descriptor ? { kind: "external", storeId } : { kind: "external", storeId: "unknown" };
+      const coalesceWindowMs = entry.meta?.coalesceWindowMs;
+      return {
+        traitId: step.id,
+        storeId: storeId ?? "unknown",
+        source,
+        ownership: "external-owned",
+        lane,
+        ...typeof coalesceWindowMs === "number" && Number.isFinite(coalesceWindowMs) && coalesceWindowMs > 0 ? { coalesceWindowMs } : {},
+        ...meta2 ? { meta: meta2 } : {}
+      };
+    };
+    const base2 = {
+      nodeId: step.id,
+      kind,
+      reads,
+      writes: kind === "check" ? [] : writes,
+      ...kind === "externalStore" ? { policy: externalStorePolicy() } : {},
+      meta
+    };
+    if (kind !== "check" && target && !write) {
+      return { ...base2, writesUnknown: true };
+    }
+    return base2;
+  });
+  const edges = params.program.graph.edges.map((edge) => ({
+    edgeId: edge.id,
+    from: edge.from,
+    to: edge.to,
+    kind: edge.kind
+  }));
+  const base = {
+    version,
+    moduleId,
+    nodes,
+    edges
+  };
+  const digest = `stir:${version}:${fnv1a32(stableStringify(base))}`;
+  return {
+    ...base,
+    digest
+  };
+};
+
+export {
+  exportStaticIr
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/state-trait/ir.ts"],
  "sourcesContent": ["import type { StateTraitEntry, StateTraitPlanStep, StateTraitProgram } from './model.js'\nimport * as CanonicalFieldPath from '../field-path.js'\nimport { fnv1a32, stableStringify } from '../digest.js'\nimport { getExternalStoreDescriptor } from '../external-store-descriptor.js'\nimport * as Meta from './meta.js'\n\nexport type FieldPath = CanonicalFieldPath.FieldPath\n\nexport interface StaticIrNode {\n  readonly nodeId: string\n  readonly kind: string\n  readonly reads: ReadonlyArray<FieldPath>\n  readonly writes: ReadonlyArray<FieldPath>\n  readonly writesUnknown?: boolean\n  readonly policy?: Record<string, unknown>\n  readonly meta?: {\n    readonly label?: string\n    readonly description?: string\n    readonly tags?: ReadonlyArray<string>\n    readonly group?: string\n    readonly docsUrl?: string\n    readonly cacheGroup?: string\n    readonly annotations?: Record<string, unknown>\n  }\n}\n\nexport interface StaticIrEdge {\n  readonly edgeId: string\n  readonly from: string\n  readonly to: string\n  readonly kind: string\n}\n\nexport interface StaticIr {\n  readonly version: string\n  readonly moduleId: string\n  /**\n   * Stable digest (for drift detection / diffing): determined solely by the current export structure.\n   */\n  readonly digest: string\n  readonly nodes: ReadonlyArray<StaticIrNode>\n  readonly edges: ReadonlyArray<StaticIrEdge>\n  readonly conflicts?: ReadonlyArray<unknown>\n}\n\nconst normalizeFieldPaths = (paths: ReadonlyArray<string> | undefined): ReadonlyArray<FieldPath> => {\n  if (!paths || paths.length === 0) return []\n  const out: Array<FieldPath> = []\n  for (const path of paths) {\n    const normalized = CanonicalFieldPath.normalizeFieldPath(path)\n    if (normalized) out.push(normalized)\n  }\n  return out\n}\n\nconst normalizeFieldPath = (path: string | undefined): FieldPath | undefined =>\n  path ? CanonicalFieldPath.normalizeFieldPath(path) : undefined\n\nconst toNodeKind = (step: StateTraitPlanStep): string => {\n  switch (step.kind) {\n    case 'computed-update':\n      return 'computed'\n    case 'link-propagate':\n      return 'link'\n    case 'source-refresh':\n      return 'source'\n    case 'external-store-sync':\n      return 'externalStore'\n    case 'check-validate':\n      return 'check'\n  }\n}\n\nconst findEntryForStep = (\n  program: StateTraitProgram<any>,\n  step: StateTraitPlanStep,\n): StateTraitEntry<any, string> | undefined => {\n  const fieldPath = step.targetFieldPath\n  if (!fieldPath) return undefined\n  const kind = toNodeKind(step)\n  return program.entries.find(\n    (e) =>\n      e.fieldPath === fieldPath &&\n      (e.kind === kind ||\n        (kind === 'check' && e.kind === 'check') ||\n        (kind === 'source' && e.kind === 'source') ||\n        (kind === 'link' && e.kind === 'link') ||\n        (kind === 'computed' && e.kind === 'computed')),\n  )\n}\n\nconst getReadsForEntry = (entry: StateTraitEntry<any, string> | undefined): ReadonlyArray<string> | undefined => {\n  if (!entry) return undefined\n  if (entry.kind === 'computed') {\n    return (entry.meta as any).deps as ReadonlyArray<string> | undefined\n  }\n  if (entry.kind === 'source') {\n    return (entry.meta as any).deps as ReadonlyArray<string> | undefined\n  }\n  if (entry.kind === 'link') {\n    const from = (entry.meta as any).from as string | undefined\n    return from ? [from] : []\n  }\n  if (entry.kind === 'externalStore') {\n    return []\n  }\n  if (entry.kind === 'check') {\n    const rules = ((entry.meta as any)?.rules ?? {}) as Record<string, any>\n    const out: Array<string> = []\n    for (const name of Object.keys(rules)) {\n      const rule = rules[name]\n      const deps = rule?.deps as ReadonlyArray<string> | undefined\n      if (deps) out.push(...deps)\n    }\n    return out\n  }\n  return undefined\n}\n\nexport const exportStaticIr = (params: {\n  readonly program: StateTraitProgram<any>\n  readonly moduleId: string\n  readonly version?: string\n}): StaticIr => {\n  const moduleId = params.moduleId\n  const version = params.version ?? '009'\n\n  const metaByField = new Map<\n    string,\n    {\n      readonly label?: string\n      readonly description?: string\n      readonly tags?: ReadonlyArray<string>\n      readonly group?: string\n      readonly docsUrl?: string\n      readonly cacheGroup?: string\n      readonly annotations?: Record<string, unknown>\n    }\n  >()\n  for (const node of params.program.graph.nodes) {\n    const meta = node.meta as any\n    if (!meta || typeof meta !== 'object') continue\n    const label = typeof meta.label === 'string' ? meta.label : undefined\n    const description = typeof meta.description === 'string' ? meta.description : undefined\n    const tags =\n      Array.isArray(meta.tags) && meta.tags.every((t: unknown) => typeof t === 'string')\n        ? (meta.tags as ReadonlyArray<string>)\n        : undefined\n    const group = typeof meta.group === 'string' ? meta.group : undefined\n    const docsUrl = typeof meta.docsUrl === 'string' ? meta.docsUrl : undefined\n    const cacheGroup = typeof meta.cacheGroup === 'string' ? meta.cacheGroup : undefined\n\n    const annotationsRaw = meta.annotations\n    const annotations =\n      annotationsRaw && typeof annotationsRaw === 'object' && !Array.isArray(annotationsRaw)\n        ? (annotationsRaw as Record<string, unknown>)\n        : undefined\n\n    if (label || description || tags || group || docsUrl || cacheGroup || annotations) {\n      metaByField.set(node.id, {\n        label,\n        description,\n        tags,\n        group,\n        docsUrl,\n        cacheGroup,\n        annotations,\n      })\n    }\n  }\n\n  const nodes: Array<StaticIrNode> = params.program.plan.steps.map((step) => {\n    const kind = toNodeKind(step)\n    const entry = findEntryForStep(params.program, step)\n    const reads = normalizeFieldPaths(getReadsForEntry(entry))\n\n    const target = step.targetFieldPath\n    const write = normalizeFieldPath(target)\n    const writes = write ? [write] : []\n\n    const meta = target ? metaByField.get(target) : undefined\n\n    const externalStorePolicy = (): Record<string, unknown> | undefined => {\n      if (kind !== 'externalStore') return undefined\n      if (!entry || entry.kind !== 'externalStore') return undefined\n\n      const descriptor = getExternalStoreDescriptor((entry.meta as any).store)\n      const storeId = descriptor?.storeId\n\n      const priorityRaw = (entry.meta as any)?.priority\n      const lane = priorityRaw === 'nonUrgent' ? 'nonUrgent' : 'urgent'\n\n      const meta = Meta.sanitize((entry.meta as any).meta)\n\n      const source =\n        descriptor?.kind === 'module'\n          ? {\n              kind: 'module',\n              storeId,\n              moduleId: descriptor.moduleId,\n              ...(descriptor.instanceId ? { instanceKey: descriptor.instanceId } : {}),\n              selectorId: descriptor.readQuery.staticIr.selectorId,\n              readsDigest: descriptor.readQuery.staticIr.readsDigest,\n              fallbackReason: descriptor.readQuery.staticIr.fallbackReason,\n            }\n          : descriptor\n            ? { kind: 'external', storeId }\n            : { kind: 'external', storeId: 'unknown' }\n\n      const coalesceWindowMs = (entry.meta as any)?.coalesceWindowMs\n\n      return {\n        traitId: step.id,\n        storeId: storeId ?? 'unknown',\n        source,\n        ownership: 'external-owned',\n        lane,\n        ...(typeof coalesceWindowMs === 'number' && Number.isFinite(coalesceWindowMs) && coalesceWindowMs > 0\n          ? { coalesceWindowMs }\n          : {}),\n        ...(meta ? { meta } : {}),\n      }\n    }\n\n    const base: StaticIrNode = {\n      nodeId: step.id,\n      kind,\n      reads,\n      writes: kind === 'check' ? [] : writes,\n      ...(kind === 'externalStore' ? { policy: externalStorePolicy() } : {}),\n      meta,\n    }\n\n    if (kind !== 'check' && target && !write) {\n      return { ...base, writesUnknown: true }\n    }\n    return base\n  })\n\n  const edges: Array<StaticIrEdge> = params.program.graph.edges.map((edge) => ({\n    edgeId: edge.id,\n    from: edge.from,\n    to: edge.to,\n    kind: edge.kind,\n  }))\n\n  const base = {\n    version,\n    moduleId,\n    nodes,\n    edges,\n  } as const\n\n  const digest = `stir:${version}:${fnv1a32(stableStringify(base))}`\n\n  return {\n    ...base,\n    digest,\n  }\n}\n"],
  "mappings": "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",
  "names": ["normalizeFieldPath", "meta", "base"]
}


package/public/sandbox/chunks/chunk-5DNHJMHA.js

@@ -0,0 +1,69 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  record
+} from "./chunk-KLDSYWT5.js";
+
+// ../logix-core/src/Middleware.ts
+import { Effect } from "../effect.js";
+var makeDebugLogger = (config) => (op) => Effect.gen(function* () {
+  if (op.meta?.policy?.disableObservers) {
+    return yield* op.effect;
+  }
+  if (config?.logger) {
+    config.logger(op);
+  } else {
+    yield* Effect.logDebug(
+      `[EffectOp] kind=${op.kind} name=${op.name}`
+    );
+  }
+  return yield* op.effect;
+});
+var applyDebug = (stack, config) => [...stack, makeDebugLogger(config)];
+var makeDebugObserver = (config) => (op) => Effect.gen(function* () {
+  if (op.meta?.policy?.disableObservers) {
+    return yield* op.effect;
+  }
+  if (!config?.filter || config.filter(op)) {
+    const meta = op.meta ?? {};
+    const slimOp = {
+      id: op.id,
+      kind: op.kind,
+      name: op.name,
+      payload: op.payload,
+      meta: op.meta
+    };
+    yield* record({
+      type: "trace:effectop",
+      moduleId: typeof meta.moduleId === "string" ? meta.moduleId : void 0,
+      instanceId: typeof meta.instanceId === "string" ? meta.instanceId : void 0,
+      runtimeLabel: typeof meta.runtimeLabel === "string" ? meta.runtimeLabel : void 0,
+      txnSeq: typeof meta.txnSeq === "number" && Number.isFinite(meta.txnSeq) ? Math.floor(meta.txnSeq) : void 0,
+      data: slimOp
+    });
+  }
+  return yield* op.effect;
+});
+var applyDebugObserver = (stack, config) => [...stack, makeDebugObserver(config)];
+var withDebug = (stack, options) => {
+  let next = stack;
+  if (options?.logger !== false) {
+    const loggerConfig = typeof options?.logger === "function" ? { logger: options.logger } : void 0;
+    next = applyDebug(next, loggerConfig);
+  }
+  if (options?.observer !== false) {
+    const observerOption = options?.observer;
+    const observerConfig = observerOption === void 0 ? void 0 : observerOption;
+    next = applyDebugObserver(next, observerConfig);
+  }
+  return next;
+};
+
+export {
+  makeDebugLogger,
+  applyDebug,
+  makeDebugObserver,
+  applyDebugObserver,
+  withDebug
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/Middleware.ts"],
  "sourcesContent": ["// Middleware \u547D\u540D\u7A7A\u95F4\u5165\u53E3\uFF08@logix/core/Middleware\uFF09\u3002\n// - \u63D0\u4F9B\u57FA\u4E8E EffectOp \u7684\u8C03\u8BD5/\u89C2\u6D4B\u4E2D\u95F4\u4EF6\u7B49\u8F85\u52A9\u5DE5\u5177\uFF1B\n// - Query / DebugObserver \u7B49\u80FD\u529B\u5728\u672C\u547D\u540D\u7A7A\u95F4\u4E0B\u6269\u5C55\u3002\n\nimport { Effect } from \"effect\"\nimport * as EffectOp from \"./EffectOp.js\"\nimport * as Debug from \"./Debug.js\"\n\nexport type Middleware = EffectOp.Middleware\nexport type MiddlewareStack = EffectOp.MiddlewareStack\n\nexport interface DebugLoggerConfig {\n  /**\n   * \u53EF\u9009\uFF1A\u81EA\u5B9A\u4E49\u65E5\u5FD7\u51FD\u6570\uFF0C\u65B9\u4FBF\u5728\u6D4B\u8BD5\u4E2D\u6355\u83B7\u8C03\u7528\u3002\n   * - \u82E5\u672A\u63D0\u4F9B\uFF0C\u5219\u9ED8\u8BA4\u4F7F\u7528 Effect.logDebug \u8F93\u51FA\u3002\n   */\n  readonly logger?: (op: EffectOp.EffectOp<any, any, any>) => void\n}\n\n/**\n * \u521B\u5EFA\u4E00\u4E2A\u7B80\u5355\u7684 Debug \u65E5\u5FD7\u4E2D\u95F4\u4EF6\uFF1A\n * - \u5728\u6267\u884C Effect \u4E4B\u524D\u8BB0\u5F55\u4E00\u6761\u65E5\u5FD7\uFF1B\n * - \u4E0D\u6539\u53D8\u7ED3\u679C\u4E0E\u9519\u8BEF\u8BED\u4E49\u3002\n */\nexport const makeDebugLogger = (\n  config?: DebugLoggerConfig,\n): Middleware =>\n  <A, E, R>(op: EffectOp.EffectOp<A, E, R>): Effect.Effect<A, E, R> =>\n    Effect.gen(function* () {\n      // \u7EAF\u89C2\u6D4B\u7C7B\u80FD\u529B\uFF1A\u5141\u8BB8\u88AB\u5C40\u90E8\u7B56\u7565\u5173\u95ED\u3002\n      if (op.meta?.policy?.disableObservers) {\n        return yield* op.effect\n      }\n      if (config?.logger) {\n        config.logger(op)\n      } else {\n        yield* Effect.logDebug(\n          `[EffectOp] kind=${op.kind} name=${op.name}`,\n        )\n      }\n      return yield* op.effect\n    })\n\n/**\n * applyDebug\uFF1A\n * - \u5728\u73B0\u6709 MiddlewareStack \u672B\u5C3E\u8FFD\u52A0\u4E00\u4E2A DebugLogger \u4E2D\u95F4\u4EF6\uFF1B\n * - \u8FD4\u56DE\u65B0\u7684 stack\uFF0C\u4E0D\u4FEE\u6539\u539F\u6570\u7EC4\u3002\n */\nexport const applyDebug = (\n  stack: MiddlewareStack,\n  config?: DebugLoggerConfig,\n): MiddlewareStack => [...stack, makeDebugLogger(config)]\n\n/**\n * DebugObserverConfig\uFF1A\n * - \u9884\u7559\u8FC7\u6EE4\u5165\u53E3\uFF1A\u53EF\u6309\u6A21\u5757 / kind / name \u7B49\u7EF4\u5EA6\u7B5B\u9009\u9700\u8981\u89C2\u6D4B\u7684 EffectOp\u3002\n */\nexport interface DebugObserverConfig {\n  readonly filter?: (\n    op: EffectOp.EffectOp<any, any, any>,\n  ) => boolean\n}\n\n/**\n * makeDebugObserver\uFF1A\n * - \u5C06 EffectOp \u6D41\u7EDF\u4E00\u6536\u53E3\u5230 DebugSink\uFF08EffectOp \u2192 Debug.Event\uFF09\uFF1B\n * - \u5F53\u524D\u901A\u8FC7 trace:* \u4E8B\u4EF6\u5C06 EffectOp \u7684 Slim \u89C6\u56FE\u900F\u4F20\u5230 Debug \u6D41\uFF08\u7981\u6B62\u643A\u5E26 effect \u95ED\u5305\uFF09\uFF1A\n *   - type: \"trace:effectop\"\n *   - moduleId: \u6765\u81EA op.meta?.moduleId\uFF08\u82E5\u5B58\u5728\uFF09\n *   - data: { id, kind, name, payload, meta }\n *\n * \u8BF4\u660E\uFF1A\n * - \u4E0D\u6539\u53D8\u539F\u6709 Effect \u884C\u4E3A\uFF0C\u4EC5\u8FFD\u52A0 Debug \u4FA7\u89C2\u6D4B\uFF1B\n * - \u5177\u4F53\u7684 Devtools / Timeline \u89C6\u56FE\u53EF\u4EE5\u57FA\u4E8E trace:effectop \u4E8B\u4EF6\u91CD\u5EFA EffectOp \u65F6\u95F4\u7EBF\u3002\n */\nexport const makeDebugObserver = (\n  config?: DebugObserverConfig,\n): Middleware =>\n  <A, E, R>(op: EffectOp.EffectOp<A, E, R>): Effect.Effect<A, E, R> =>\n    Effect.gen(function* () {\n      // \u7EAF\u89C2\u6D4B\u7C7B\u80FD\u529B\uFF1A\u5141\u8BB8\u88AB\u5C40\u90E8\u7B56\u7565\u5173\u95ED\u3002\n      if (op.meta?.policy?.disableObservers) {\n        return yield* op.effect\n      }\n      if (!config?.filter || config.filter(op)) {\n        const meta: any = op.meta ?? {}\n        const slimOp = {\n          id: op.id,\n          kind: op.kind,\n          name: op.name,\n          payload: op.payload,\n          meta: op.meta,\n        }\n        yield* Debug.record({\n          type: \"trace:effectop\",\n          moduleId: typeof meta.moduleId === \"string\" ? meta.moduleId : undefined,\n          instanceId: typeof meta.instanceId === \"string\" ? meta.instanceId : undefined,\n          runtimeLabel: typeof meta.runtimeLabel === \"string\" ? meta.runtimeLabel : undefined,\n          txnSeq:\n            typeof meta.txnSeq === \"number\" && Number.isFinite(meta.txnSeq)\n              ? Math.floor(meta.txnSeq)\n              : undefined,\n          data: slimOp,\n        })\n      }\n      return yield* op.effect\n    })\n\n/**\n * applyDebugObserver\uFF1A\n * - \u5728\u73B0\u6709 MiddlewareStack \u672B\u5C3E\u8FFD\u52A0 DebugObserver \u4E2D\u95F4\u4EF6\uFF1B\n * - \u8FD4\u56DE\u65B0\u7684 stack\uFF0C\u4E0D\u4FEE\u6539\u539F\u6570\u7EC4\u3002\n */\nexport const applyDebugObserver = (\n  stack: MiddlewareStack,\n  config?: DebugObserverConfig,\n): MiddlewareStack => [...stack, makeDebugObserver(config)]\n\n/**\n * WithDebugOptions\uFF1A\n * - \u9AD8\u5C42\u7EC4\u5408\u5165\u53E3\u7684\u914D\u7F6E\u9879\uFF0C\u7528\u4E8E\u5728\u73B0\u6709 MiddlewareStack \u4E0A\u8FFD\u52A0 Debug \u80FD\u529B\u3002\n *\n * \u7EA6\u5B9A\uFF1A\n * - logger:\n *   - \u672A\u8BBE\u7F6E\uFF08undefined\uFF09\uFF1A\u542F\u7528\u9ED8\u8BA4 DebugLogger\uFF08Effect.logDebug\uFF09\uFF1B\n *   - \u63D0\u4F9B\u51FD\u6570\uFF1A\u4F7F\u7528\u81EA\u5B9A\u4E49 logger(op) \u66FF\u4EE3\u9ED8\u8BA4\u884C\u4E3A\uFF1B\n *   - \u663E\u5F0F false\uFF1A\u4E0D\u8FFD\u52A0 DebugLogger \u4E2D\u95F4\u4EF6\u3002\n * - observer:\n *   - \u672A\u8BBE\u7F6E\uFF08undefined\uFF09\uFF1A\u542F\u7528 DebugObserver\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u914D\u7F6E\uFF1B\n *   - \u63D0\u4F9B DebugObserverConfig\uFF1A\u6309\u914D\u7F6E\u542F\u7528 DebugObserver\uFF1B\n *   - \u663E\u5F0F false\uFF1A\u4E0D\u8FFD\u52A0 DebugObserver \u4E2D\u95F4\u4EF6\u3002\n */\nexport interface WithDebugOptions {\n  readonly logger?: DebugLoggerConfig[\"logger\"] | false\n  readonly observer?: DebugObserverConfig | false\n}\n\n/**\n * withDebug\uFF1A\n * - \u5728\u73B0\u6709 MiddlewareStack \u4E0A\u8FFD\u52A0 DebugLogger + DebugObserver \u9884\u8BBE\uFF1B\n * - \u652F\u6301\u901A\u8FC7 options \u63A7\u5236 logger / observer \u662F\u5426\u542F\u7528\u53CA\u5176\u914D\u7F6E\uFF1B\n * - \u8FD4\u56DE\u65B0\u7684 stack\uFF0C\u4E0D\u4FEE\u6539\u539F\u6570\u7EC4\u3002\n *\n * \u5178\u578B\u7528\u6CD5\uFF1A\n *\n *   let stack: MiddlewareStack = [metrics, timing]\n *   stack = Middleware.withDebug(stack, {\n *     logger: (op) => console.log(op.kind, op.name),\n *     observer: { filter: (op) => op.kind !== \"service\" },\n *   })\n */\nexport const withDebug = (\n  stack: MiddlewareStack,\n  options?: WithDebugOptions,\n): MiddlewareStack => {\n  let next = stack\n\n  // DebugLogger\uFF1A\u9ED8\u8BA4\u5F00\u542F\uFF0C\u9664\u975E\u663E\u5F0F logger === false\u3002\n  if (options?.logger !== false) {\n    const loggerConfig: DebugLoggerConfig | undefined =\n      typeof options?.logger === \"function\"\n        ? { logger: options.logger }\n        : undefined\n    next = applyDebug(next, loggerConfig)\n  }\n\n  // DebugObserver\uFF1A\u9ED8\u8BA4\u5F00\u542F\uFF0C\u9664\u975E\u663E\u5F0F observer === false\u3002\n  if (options?.observer !== false) {\n    // \u8FD9\u91CC\u5DF2\u7ECF\u901A\u8FC7\u6761\u4EF6\u6392\u9664\u4E86 observer === false\uFF0C\u53EA\u9700\u8981\u5728\u6709\u914D\u7F6E\u5BF9\u8C61\u65F6\u900F\u4F20\uFF1B\n    // undefined \u8868\u793A\u4F7F\u7528 DebugObserver \u9ED8\u8BA4\u884C\u4E3A\u3002\n    const observerOption = options?.observer\n    const observerConfig: DebugObserverConfig | undefined =\n      observerOption === undefined ? undefined : observerOption\n    next = applyDebugObserver(next, observerConfig)\n  }\n\n  return next\n}\n"],
  "mappings": ";;;;;;;AAIA,SAAS,cAAc;AAoBhB,IAAM,kBAAkB,CAC7B,WAEA,CAAU,OACR,OAAO,IAAI,aAAa;AAEtB,MAAI,GAAG,MAAM,QAAQ,kBAAkB;AACrC,WAAO,OAAO,GAAG;AAAA,EACnB;AACA,MAAI,QAAQ,QAAQ;AAClB,WAAO,OAAO,EAAE;AAAA,EAClB,OAAO;AACL,WAAO,OAAO;AAAA,MACZ,mBAAmB,GAAG,IAAI,SAAS,GAAG,IAAI;AAAA,IAC5C;AAAA,EACF;AACA,SAAO,OAAO,GAAG;AACnB,CAAC;AAOE,IAAM,aAAa,CACxB,OACA,WACoB,CAAC,GAAG,OAAO,gBAAgB,MAAM,CAAC;AAwBjD,IAAM,oBAAoB,CAC/B,WAEA,CAAU,OACR,OAAO,IAAI,aAAa;AAEtB,MAAI,GAAG,MAAM,QAAQ,kBAAkB;AACrC,WAAO,OAAO,GAAG;AAAA,EACnB;AACA,MAAI,CAAC,QAAQ,UAAU,OAAO,OAAO,EAAE,GAAG;AACxC,UAAM,OAAY,GAAG,QAAQ,CAAC;AAC9B,UAAM,SAAS;AAAA,MACb,IAAI,GAAG;AAAA,MACP,MAAM,GAAG;AAAA,MACT,MAAM,GAAG;AAAA,MACT,SAAS,GAAG;AAAA,MACZ,MAAM,GAAG;AAAA,IACX;AACA,WAAa,OAAO;AAAA,MAClB,MAAM;AAAA,MACN,UAAU,OAAO,KAAK,aAAa,WAAW,KAAK,WAAW;AAAA,MAC9D,YAAY,OAAO,KAAK,eAAe,WAAW,KAAK,aAAa;AAAA,MACpE,cAAc,OAAO,KAAK,iBAAiB,WAAW,KAAK,eAAe;AAAA,MAC1E,QACE,OAAO,KAAK,WAAW,YAAY,OAAO,SAAS,KAAK,MAAM,IAC1D,KAAK,MAAM,KAAK,MAAM,IACtB;AAAA,MACN,MAAM;AAAA,IACR,CAAC;AAAA,EACH;AACA,SAAO,OAAO,GAAG;AACnB,CAAC;AAOE,IAAM,qBAAqB,CAChC,OACA,WACoB,CAAC,GAAG,OAAO,kBAAkB,MAAM,CAAC;AAmCnD,IAAM,YAAY,CACvB,OACA,YACoB;AACpB,MAAI,OAAO;AAGX,MAAI,SAAS,WAAW,OAAO;AAC7B,UAAM,eACJ,OAAO,SAAS,WAAW,aACvB,EAAE,QAAQ,QAAQ,OAAO,IACzB;AACN,WAAO,WAAW,MAAM,YAAY;AAAA,EACtC;AAGA,MAAI,SAAS,aAAa,OAAO;AAG/B,UAAM,iBAAiB,SAAS;AAChC,UAAM,iBACJ,mBAAmB,SAAY,SAAY;AAC7C,WAAO,mBAAmB,MAAM,cAAc;AAAA,EAChD;AAEA,SAAO;AACT;",
  "names": []
}


package/public/sandbox/chunks/chunk-5EC4S7X6.js

@@ -0,0 +1,42 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  exportStaticIr
+} from "./chunk-7KQFTS2Y.js";
+import {
+  isDevEnv
+} from "./chunk-LTFCYZQ6.js";
+
+// ../logix-core/src/internal/debug/ModuleTraitsRegistry.ts
+var programsByIdAndDigest = /* @__PURE__ */ new Map();
+var latestDigestById = /* @__PURE__ */ new Map();
+var MAX_VERSIONS_PER_MODULE = 8;
+var registerModuleProgram = (moduleId, program) => {
+  if (!isDevEnv()) {
+    return;
+  }
+  const ir = exportStaticIr({ program, moduleId, version: "009" });
+  const digest = ir.digest;
+  let versions = programsByIdAndDigest.get(moduleId);
+  if (!versions) {
+    versions = /* @__PURE__ */ new Map();
+    programsByIdAndDigest.set(moduleId, versions);
+  }
+  versions.set(digest, program);
+  latestDigestById.set(moduleId, digest);
+  if (versions.size > MAX_VERSIONS_PER_MODULE) {
+    const oldest = versions.keys().next().value;
+    if (oldest) versions.delete(oldest);
+  }
+};
+var getModuleProgramById = (moduleId) => {
+  const latestDigest = latestDigestById.get(moduleId);
+  if (!latestDigest) return void 0;
+  return programsByIdAndDigest.get(moduleId)?.get(latestDigest);
+};
+
+export {
+  registerModuleProgram,
+  getModuleProgramById
+};
+//# sourceMappingURL=data:application/json;base64,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

package/public/sandbox/chunks/chunk-5FB7QFSH.js

@@ -0,0 +1,227 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+
+// ../logix-core/src/internal/field-path.ts
+var isFieldPathSegment = (seg) => {
+  if (!seg) return false;
+  if (seg === "*") return false;
+  if (/^\d+$/.test(seg)) return false;
+  if (seg.includes("[") || seg.includes("]")) return false;
+  return true;
+};
+var normalizeFieldPath = (input) => {
+  if (typeof input === "string") {
+    const segs = splitSegments(input);
+    if (!segs || segs.length === 0) return void 0;
+    const normalized2 = segs.filter(isFieldPathSegment);
+    return normalized2.length > 0 ? normalized2 : void 0;
+  }
+  if (input.length === 0) return void 0;
+  let needsFilter = false;
+  for (const seg of input) {
+    if (!isFieldPathSegment(seg)) {
+      needsFilter = true;
+      break;
+    }
+  }
+  if (!needsFilter) return input;
+  const normalized = input.filter(isFieldPathSegment);
+  return normalized.length > 0 ? normalized : void 0;
+};
+var compareFieldPath = (a, b) => {
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const as = a[i];
+    const bs = b[i];
+    if (as === bs) continue;
+    return as < bs ? -1 : 1;
+  }
+  return a.length - b.length;
+};
+var isPrefixOf = (prefix, full) => {
+  if (prefix.length > full.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (prefix[i] !== full[i]) return false;
+  }
+  return true;
+};
+var toPathString = (path) => path.join(".");
+var canonicalizeRootsFast = (roots) => {
+  const sorted = Array.from(roots).sort(compareFieldPath);
+  const out = [];
+  for (const next of sorted) {
+    const prev = out[out.length - 1];
+    if (prev && isPrefixOf(prev, next)) continue;
+    out.push(next);
+  }
+  return out;
+};
+var makeFieldPathIdRegistry = (fieldPaths) => {
+  const root = { children: /* @__PURE__ */ new Map() };
+  for (let id = 0; id < fieldPaths.length; id++) {
+    const path = fieldPaths[id];
+    let node = root;
+    for (const seg of path) {
+      const children = node.children;
+      let next = children.get(seg);
+      if (!next) {
+        next = { children: /* @__PURE__ */ new Map() };
+        children.set(seg, next);
+      }
+      node = next;
+    }
+    node.id = id;
+  }
+  return { fieldPaths, root };
+};
+var getFieldPathId = (registry, path) => {
+  let node = registry.root;
+  for (const seg of path) {
+    const next = node.children.get(seg);
+    if (!next) return void 0;
+    node = next;
+  }
+  return node.id;
+};
+var hashFieldPathIds = (ids) => {
+  let hash = 2166136261 >>> 0;
+  for (const id of ids) {
+    hash ^= id >>> 0;
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+};
+var dirtyPathsToDirtySet = (dirtyPaths) => {
+  let sawStar = false;
+  let hasInvalid = false;
+  const roots = [];
+  for (const raw of dirtyPaths ?? []) {
+    if (raw === "*") {
+      sawStar = true;
+      continue;
+    }
+    const normalized = normalizeFieldPath(raw);
+    if (!normalized) {
+      hasInvalid = true;
+      continue;
+    }
+    roots.push(normalized);
+  }
+  if (hasInvalid) {
+    return { dirtyAll: true, reason: "nonTrackablePatch" };
+  }
+  const canonical = canonicalizeRootsFast(roots).map(toPathString);
+  if (canonical.length === 0) {
+    return { dirtyAll: true, reason: sawStar ? "unknownWrite" : "unknownWrite" };
+  }
+  return { dirtyAll: false, paths: canonical };
+};
+var dirtyPathsToRootIds = (options) => {
+  let sawStar = false;
+  let hasInvalid = false;
+  const roots = [];
+  for (const raw of options.dirtyPaths ?? []) {
+    if (raw === "*") {
+      sawStar = true;
+      continue;
+    }
+    const normalized = normalizeFieldPath(raw);
+    if (!normalized) {
+      hasInvalid = true;
+      continue;
+    }
+    roots.push(normalized);
+  }
+  const canonical = canonicalizeRootsFast(roots);
+  const rootIds = [];
+  let missing = false;
+  for (const root of canonical) {
+    const id = getFieldPathId(options.registry, root);
+    if (id == null) {
+      missing = true;
+      continue;
+    }
+    rootIds.push(id);
+  }
+  const hasSpecific = rootIds.length > 0;
+  if (hasInvalid) {
+    return {
+      dirtyAll: true,
+      reason: "nonTrackablePatch",
+      rootIds: [],
+      rootCount: 0,
+      keySize: 0,
+      keyHash: 0
+    };
+  }
+  rootIds.sort((a, b) => a - b);
+  if (missing) {
+    return {
+      dirtyAll: true,
+      reason: "fallbackPolicy",
+      rootIds: [],
+      rootCount: 0,
+      keySize: 0,
+      keyHash: 0
+    };
+  }
+  if (!hasSpecific && sawStar) {
+    return {
+      dirtyAll: true,
+      reason: "unknownWrite",
+      rootIds: [],
+      rootCount: 0,
+      keySize: 0,
+      keyHash: 0
+    };
+  }
+  const keyHash = hashFieldPathIds(rootIds);
+  return {
+    dirtyAll: false,
+    rootIds,
+    rootCount: rootIds.length,
+    keySize: rootIds.length,
+    keyHash
+  };
+};
+var splitSegments = (path) => {
+  if (!path) return void 0;
+  if (path === "*") return void 0;
+  const parts = path.split(".").filter((p) => p.length > 0);
+  const segs = [];
+  for (const part of parts) {
+    if (!part) continue;
+    if (part === "*") {
+      return void 0;
+    }
+    if (part.endsWith("[]")) {
+      const base = part.slice(0, -2);
+      if (base) segs.push(base);
+      continue;
+    }
+    const bracket = /^(.+)\[(\d+)\]$/.exec(part);
+    if (bracket) {
+      segs.push(bracket[1]);
+      continue;
+    }
+    if (/^\d+$/.test(part)) {
+      continue;
+    }
+    if (part.includes("[") || part.includes("]")) {
+      return void 0;
+    }
+    segs.push(part);
+  }
+  return segs;
+};
+
+export {
+  isFieldPathSegment,
+  normalizeFieldPath,
+  compareFieldPath,
+  makeFieldPathIdRegistry,
+  getFieldPathId,
+  dirtyPathsToDirtySet,
+  dirtyPathsToRootIds
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/field-path.ts"],
  "sourcesContent": ["export type FieldPath = ReadonlyArray<string>\nexport type FieldPathId = number\n\nexport type DirtyAllReason = 'unknownWrite' | 'customMutation' | 'nonTrackablePatch' | 'fallbackPolicy'\n\nexport type DirtySet =\n  | {\n      readonly dirtyAll: true\n      readonly reason: DirtyAllReason\n    }\n  | {\n      readonly dirtyAll: false\n      readonly paths: ReadonlyArray<string>\n    }\n\ninterface FieldPathTrieNode {\n  id?: FieldPathId\n  children: Map<string, FieldPathTrieNode>\n}\n\nexport interface FieldPathIdRegistry {\n  readonly fieldPaths: ReadonlyArray<FieldPath>\n  readonly root: FieldPathTrieNode\n}\n\nexport const isFieldPathSegment = (seg: string): boolean => {\n  if (!seg) return false\n  if (seg === '*') return false\n  if (/^\\d+$/.test(seg)) return false\n  if (seg.includes('[') || seg.includes(']')) return false\n  return true\n}\n\nexport const normalizeFieldPath = (input: string | FieldPath): FieldPath | undefined => {\n  if (typeof input === 'string') {\n    const segs = splitSegments(input)\n    if (!segs || segs.length === 0) return undefined\n    const normalized = segs.filter(isFieldPathSegment)\n    return normalized.length > 0 ? normalized : undefined\n  }\n\n  if (input.length === 0) return undefined\n\n  let needsFilter = false\n  for (const seg of input) {\n    if (!isFieldPathSegment(seg)) {\n      needsFilter = true\n      break\n    }\n  }\n\n  if (!needsFilter) return input\n\n  const normalized = input.filter(isFieldPathSegment)\n  return normalized.length > 0 ? normalized : undefined\n}\n\nexport const compareFieldPath = (a: FieldPath, b: FieldPath): number => {\n  const len = Math.min(a.length, b.length)\n  for (let i = 0; i < len; i++) {\n    const as = a[i]!\n    const bs = b[i]!\n    if (as === bs) continue\n    return as < bs ? -1 : 1\n  }\n  return a.length - b.length\n}\n\nexport const isPrefixOf = (prefix: FieldPath, full: FieldPath): boolean => {\n  if (prefix.length > full.length) return false\n  for (let i = 0; i < prefix.length; i++) {\n    if (prefix[i] !== full[i]) return false\n  }\n  return true\n}\n\nexport const toKey = (path: FieldPath): string => JSON.stringify(path)\n\nexport const toPathString = (path: FieldPath): string => path.join('.')\n\nexport const canonicalizeRoots = (roots: Iterable<FieldPath>): ReadonlyArray<FieldPath> => {\n  const byKey = new Map<string, FieldPath>()\n  for (const root of roots) {\n    const key = toKey(root)\n    if (!byKey.has(key)) byKey.set(key, root)\n  }\n\n  const sorted = Array.from(byKey.values()).sort(compareFieldPath)\n  const out: Array<FieldPath> = []\n  for (const next of sorted) {\n    const prev = out[out.length - 1]\n    if (prev && isPrefixOf(prev, next)) {\n      continue\n    }\n    out.push(next)\n  }\n  return out\n}\n\nexport const canonicalizeRootsFast = (roots: Iterable<FieldPath>): ReadonlyArray<FieldPath> => {\n  const sorted = Array.from(roots).sort(compareFieldPath)\n  const out: Array<FieldPath> = []\n  for (const next of sorted) {\n    const prev = out[out.length - 1]\n    if (prev && isPrefixOf(prev, next)) continue\n    out.push(next)\n  }\n  return out\n}\n\nexport const makeFieldPathIdRegistry = (fieldPaths: ReadonlyArray<FieldPath>): FieldPathIdRegistry => {\n  const root: FieldPathTrieNode = { children: new Map() }\n\n  for (let id = 0; id < fieldPaths.length; id++) {\n    const path = fieldPaths[id]!\n    let node = root\n    for (const seg of path) {\n      const children = node.children\n      let next = children.get(seg)\n      if (!next) {\n        next = { children: new Map() }\n        children.set(seg, next)\n      }\n      node = next\n    }\n    node.id = id\n  }\n\n  return { fieldPaths, root }\n}\n\nexport const getFieldPathId = (registry: FieldPathIdRegistry, path: FieldPath): FieldPathId | undefined => {\n  let node = registry.root\n  for (const seg of path) {\n    const next = node.children.get(seg)\n    if (!next) return undefined\n    node = next\n  }\n  return node.id\n}\n\nexport const getFieldPathIdFromString = (registry: FieldPathIdRegistry, path: string): FieldPathId | undefined => {\n  if (!path || path === '*') return undefined\n  const normalized = normalizeFieldPath(path)\n  if (!normalized) return undefined\n  return getFieldPathId(registry, normalized)\n}\n\nexport const hashFieldPathIds = (ids: ReadonlyArray<number>): number => {\n  // FNV-1a (32-bit)\n  let hash = 2166136261 >>> 0\n  for (const id of ids) {\n    hash ^= id >>> 0\n    hash = Math.imul(hash, 16777619)\n  }\n  return hash >>> 0\n}\n\nexport interface DirtyRootIds {\n  readonly dirtyAll: boolean\n  readonly reason?: DirtyAllReason\n  readonly rootIds: ReadonlyArray<FieldPathId>\n  readonly rootCount: number\n  readonly keySize: number\n  readonly keyHash: number\n}\n\nexport const dirtyPathsToDirtySet = (dirtyPaths?: Iterable<string | FieldPath>): DirtySet => {\n  let sawStar = false\n  let hasInvalid = false\n\n  const roots: Array<FieldPath> = []\n  for (const raw of dirtyPaths ?? []) {\n    if (raw === '*') {\n      sawStar = true\n      continue\n    }\n    const normalized = normalizeFieldPath(raw)\n    if (!normalized) {\n      hasInvalid = true\n      continue\n    }\n    roots.push(normalized)\n  }\n\n  if (hasInvalid) {\n    return { dirtyAll: true, reason: 'nonTrackablePatch' }\n  }\n\n  const canonical = canonicalizeRootsFast(roots).map(toPathString)\n\n  if (canonical.length === 0) {\n    return { dirtyAll: true, reason: sawStar ? 'unknownWrite' : 'unknownWrite' }\n  }\n\n  return { dirtyAll: false, paths: canonical }\n}\n\nexport const dirtyPathsToRootIds = (options: {\n  readonly dirtyPaths?: Iterable<string | FieldPath>\n  readonly registry: FieldPathIdRegistry\n}): DirtyRootIds => {\n  let sawStar = false\n  let hasInvalid = false\n\n  const roots: Array<FieldPath> = []\n  for (const raw of options.dirtyPaths ?? []) {\n    if (raw === '*') {\n      sawStar = true\n      continue\n    }\n    const normalized = normalizeFieldPath(raw)\n    if (!normalized) {\n      hasInvalid = true\n      continue\n    }\n    roots.push(normalized)\n  }\n\n  const canonical = canonicalizeRootsFast(roots)\n  const rootIds: Array<number> = []\n  let missing = false\n  for (const root of canonical) {\n    const id = getFieldPathId(options.registry, root)\n    if (id == null) {\n      missing = true\n      continue\n    }\n    rootIds.push(id)\n  }\n\n  const hasSpecific = rootIds.length > 0\n  if (hasInvalid) {\n    return {\n      dirtyAll: true,\n      reason: 'nonTrackablePatch',\n      rootIds: [],\n      rootCount: 0,\n      keySize: 0,\n      keyHash: 0,\n    }\n  }\n\n  rootIds.sort((a, b) => a - b)\n\n  if (missing) {\n    return {\n      dirtyAll: true,\n      reason: 'fallbackPolicy',\n      rootIds: [],\n      rootCount: 0,\n      keySize: 0,\n      keyHash: 0,\n    }\n  }\n\n  if (!hasSpecific && sawStar) {\n    return {\n      dirtyAll: true,\n      reason: 'unknownWrite',\n      rootIds: [],\n      rootCount: 0,\n      keySize: 0,\n      keyHash: 0,\n    }\n  }\n\n  const keyHash = hashFieldPathIds(rootIds)\n  return {\n    dirtyAll: false,\n    rootIds,\n    rootCount: rootIds.length,\n    keySize: rootIds.length,\n    keyHash,\n  }\n}\n\nconst splitSegments = (path: string): Array<string> | undefined => {\n  if (!path) return undefined\n  if (path === '*') return undefined\n\n  const parts = path.split('.').filter((p) => p.length > 0)\n  const segs: Array<string> = []\n\n  for (const part of parts) {\n    if (!part) continue\n    if (part === '*') {\n      return undefined\n    }\n    if (part.endsWith('[]')) {\n      const base = part.slice(0, -2)\n      if (base) segs.push(base)\n      continue\n    }\n    const bracket = /^(.+)\\[(\\d+)\\]$/.exec(part)\n    if (bracket) {\n      segs.push(bracket[1]!)\n      continue\n    }\n    if (/^\\d+$/.test(part)) {\n      continue\n    }\n    if (part.includes('[') || part.includes(']')) {\n      return undefined\n    }\n    segs.push(part)\n  }\n\n  return segs\n}\n"],
  "mappings": "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",
  "names": ["normalized"]
}
