@logixjs/devtools-react 0.0.1 → 1.0.0

package/dist/{chunk-WTZBDE4J.js → chunk-H5JD2DNC.js}

@@ -8,7 +8,7 @@ import {
   getInstanceLabel,
   hasDevtoolsSnapshotOverride,
   setDevtoolsSnapshotOverride
-} from "./chunk-FNWHBEXD.js";
+} from "./chunk-NH3EYAZ6.js";
 import {
   StateTraitGraphView,
   ensureDevtoolsStyles
@@ -24,14 +24,15 @@ import * as Logix7 from "@logixjs/core";
 
 // src/internal/ui/hooks/DevtoolsHooks.tsx
 import React, { useSyncExternalStore } from "react";
-import { Effect as Effect2, Fiber, Stream as Stream2 } from "effect";
+import { Effect as Effect3, Fiber, Stream as Stream2 } from "effect";
 
 // src/internal/state/runtime.ts
 import * as Logix4 from "@logixjs/core";
+import { Effect as Effect2 } from "effect";
 
 // src/internal/state/logic.ts
 import * as Logix3 from "@logixjs/core";
-import { Effect, Stream } from "effect";
+import { Effect, Queue, Stream } from "effect";
 
 // src/internal/state/compute.ts
 import * as Logix from "@logixjs/core";
@@ -68,7 +69,7 @@ var OperationSummarySchema = Schema.Struct({
       top3: Schema.Array(
         Schema.Struct({
           stepId: Schema.String,
-          kind: Schema.Literal("computed", "link"),
+          kind: Schema.Literals(["computed", "link"]),
           fieldPath: Schema.String,
           durationMs: Schema.Number,
           changed: Schema.Boolean,
@@ -84,7 +85,7 @@ var TriggerLayoutSchema = Schema.Struct({
   isDragging: Schema.Boolean
 });
 var DevtoolsSettingsSchema = Schema.Struct({
-  mode: Schema.Literal("basic", "deep"),
+  mode: Schema.Literals(["basic", "deep"]),
   showTraitEvents: Schema.Boolean,
   showReactRenderEvents: Schema.Boolean,
   enableTimeTravelUI: Schema.Boolean,
@@ -125,7 +126,7 @@ var DevtoolsStateSchema = Schema.Struct({
       moduleId: Schema.String,
       instanceId: Schema.String,
       txnId: Schema.String,
-      mode: Schema.Literal("before", "after")
+      mode: Schema.Literals(["before", "after"])
     })
   ),
   runtimes: Schema.Array(
@@ -154,7 +155,7 @@ var DevtoolsStateSchema = Schema.Struct({
     isDragging: Schema.Boolean,
     trigger: Schema.optional(TriggerLayoutSchema)
   }),
-  theme: Schema.Literal("system", "light", "dark"),
+  theme: Schema.Literals(["system", "light", "dark"]),
   settings: DevtoolsSettingsSchema
 });
 var defaultSettings = {
@@ -224,13 +225,11 @@ var gateDirtyRootPathsByDigest = (meta) => {
   }
   const dirtySet = meta.dirtySet;
   if (!isRecord(dirtySet)) return meta;
-  if (!Array.isArray(dirtySet.rootPaths)) return meta;
+  if (!Object.prototype.hasOwnProperty.call(dirtySet, "rootPaths")) return meta;
+  const { rootPaths: _rootPaths, ...dirtySetWithoutRootPaths } = dirtySet;
   return {
     ...meta,
-    dirtySet: {
-      ...dirtySet,
-      rootPaths: void 0
-    }
+    dirtySet: dirtySetWithoutRootPaths
   };
 };
 var getEventTimestamp = (event) => event.timestamp;
@@ -761,23 +760,21 @@ var persistSettingsToStorage = (settings) => {
 import * as Logix2 from "@logixjs/core";
 import { Schema as Schema2 } from "effect";
 var ResizePayload = Schema2.Struct({
-  edge: Schema2.Literal("top", "left", "right")
+  edge: Schema2.Literals(["top", "left", "right"])
+});
+var UpdateLayoutPayload = Schema2.Struct({
+  height: Schema2.optional(Schema2.Number),
+  marginLeft: Schema2.optional(Schema2.Number),
+  marginRight: Schema2.optional(Schema2.Number),
+  isDragging: Schema2.optional(Schema2.Boolean),
+  trigger: Schema2.optional(
+    Schema2.Struct({
+      x: Schema2.Number,
+      y: Schema2.Number,
+      isDragging: Schema2.Boolean
+    })
+  )
 });
-var UpdateLayoutPayload = Schema2.partial(
-  Schema2.Struct({
-    height: Schema2.Number,
-    marginLeft: Schema2.Number,
-    marginRight: Schema2.Number,
-    isDragging: Schema2.Boolean,
-    trigger: Schema2.optional(
-      Schema2.Struct({
-        x: Schema2.Number,
-        y: Schema2.Number,
-        isDragging: Schema2.Boolean
-      })
-    )
-  })
-);
 var DevtoolsModule = Logix2.Module.make("LogixDevtoolsModule", {
   state: DevtoolsStateSchema,
   actions: {
@@ -811,8 +808,8 @@ var DevtoolsModule = Logix2.Module.make("LogixDevtoolsModule", {
     clearImportedEvidence: Schema2.Void,
     resizeStart: ResizePayload,
     updateLayout: UpdateLayoutPayload,
-    setTheme: Schema2.Literal("system", "light", "dark"),
-    setMode: Schema2.Literal("basic", "deep"),
+    setTheme: Schema2.Literals(["system", "light", "dark"]),
+    setMode: Schema2.Literals(["basic", "deep"]),
     updateSettings: Schema2.Any
   },
   reducers: {
@@ -1047,15 +1044,165 @@ var normalizeRuntimeDebugEventRef = (value) => {
   }
   return { ...value, instanceId };
 };
-var fromDomEvent = (event) => Stream.async((emit) => {
-  const handler = (e) => emit.single(e);
-  window.addEventListener(event, handler);
-  return Effect.sync(() => window.removeEventListener(event, handler));
-});
+var readConvergeFieldPathsByDigest = (summary) => {
+  if (!isRecord2(summary)) return /* @__PURE__ */ new Map();
+  const converge = isRecord2(summary.converge) ? summary.converge : void 0;
+  const byDigest = converge && isRecord2(converge.staticIrByDigest) ? converge.staticIrByDigest : void 0;
+  if (!byDigest) return /* @__PURE__ */ new Map();
+  const out = /* @__PURE__ */ new Map();
+  for (const [digest, ir] of Object.entries(byDigest)) {
+    if (!isRecord2(ir)) continue;
+    const fieldPathsRaw = ir.fieldPaths;
+    if (!Array.isArray(fieldPathsRaw)) continue;
+    const fieldPaths = [];
+    for (const pathRaw of fieldPathsRaw) {
+      if (!Array.isArray(pathRaw) || pathRaw.length === 0) {
+        fieldPaths.length = 0;
+        break;
+      }
+      if (!pathRaw.every((seg) => typeof seg === "string" && seg.length > 0)) {
+        fieldPaths.length = 0;
+        break;
+      }
+      fieldPaths.push(pathRaw);
+    }
+    if (fieldPaths.length > 0) {
+      out.set(digest, fieldPaths);
+    }
+  }
+  return out;
+};
+var isPrefixPath = (prefix, path) => {
+  if (prefix.length > path.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (prefix[i] !== path[i]) return false;
+  }
+  return true;
+};
+var minimizeRootPaths = (paths) => {
+  const roots = [];
+  for (const path of paths) {
+    let redundant = false;
+    for (const existing of roots) {
+      if (isPrefixPath(existing, path)) {
+        redundant = true;
+        break;
+      }
+    }
+    if (redundant) continue;
+    let nextLen = 0;
+    for (let i = 0; i < roots.length; i++) {
+      const existing = roots[i];
+      if (isPrefixPath(path, existing)) continue;
+      roots[nextLen] = existing;
+      nextLen += 1;
+    }
+    roots.length = nextLen;
+    roots.push(path);
+  }
+  return roots;
+};
+var resolveRootPaths = (args) => {
+  const ids = args.ids;
+  if (!Array.isArray(ids) || ids.length === 0) return void 0;
+  const candidates = [];
+  for (const rawId of ids) {
+    if (!Number.isInteger(rawId)) continue;
+    const id = rawId;
+    if (id < 0 || id >= args.fieldPaths.length) continue;
+    candidates.push(args.fieldPaths[id]);
+  }
+  if (candidates.length === 0) return void 0;
+  const minimized = minimizeRootPaths(candidates);
+  return minimized.length > 0 ? minimized : void 0;
+};
+var stripRootPathsField = (value) => {
+  const { rootPaths: _rootPaths, ...rest } = value;
+  return rest;
+};
+var stripLegacyDirtyRootPathsFromEvent = (event) => {
+  const meta = isRecord2(event.meta) ? event.meta : void 0;
+  if (!meta) return event;
+  if (event.kind === "state" && event.label === "state:update") {
+    const dirtySet = isRecord2(meta.dirtySet) ? meta.dirtySet : void 0;
+    if (!dirtySet || !Object.prototype.hasOwnProperty.call(dirtySet, "rootPaths")) return event;
+    return {
+      ...event,
+      meta: {
+        ...meta,
+        dirtySet: stripRootPathsField(dirtySet)
+      }
+    };
+  }
+  if (event.kind === "trait:converge") {
+    const dirty = isRecord2(meta.dirty) ? meta.dirty : void 0;
+    if (!dirty || !Object.prototype.hasOwnProperty.call(dirty, "rootPaths")) return event;
+    return {
+      ...event,
+      meta: {
+        ...meta,
+        dirty: stripRootPathsField(dirty)
+      }
+    };
+  }
+  return event;
+};
+var materializeDirtyRootPathsFromCanonical = (args) => {
+  if (args.fieldPathsByDigest.size === 0) return args.event;
+  const meta = isRecord2(args.event.meta) ? args.event.meta : void 0;
+  if (!meta) return args.event;
+  const staticIrDigest = asNonEmptyString(meta.staticIrDigest);
+  if (!staticIrDigest) return args.event;
+  const fieldPaths = args.fieldPathsByDigest.get(staticIrDigest);
+  if (!fieldPaths) return args.event;
+  if (args.event.kind === "state" && args.event.label === "state:update") {
+    const dirtySet = isRecord2(meta.dirtySet) ? meta.dirtySet : void 0;
+    if (!dirtySet) return args.event;
+    const ids = Object.prototype.hasOwnProperty.call(dirtySet, "pathIds") ? dirtySet.pathIds : dirtySet.rootIds;
+    const rootPaths = resolveRootPaths({ ids, fieldPaths });
+    if (!rootPaths) return args.event;
+    return {
+      ...args.event,
+      meta: {
+        ...meta,
+        dirtySet: {
+          ...dirtySet,
+          rootPaths
+        }
+      }
+    };
+  }
+  if (args.event.kind === "trait:converge") {
+    const dirty = isRecord2(meta.dirty) ? meta.dirty : void 0;
+    if (!dirty) return args.event;
+    const rootPaths = resolveRootPaths({ ids: dirty.rootIds, fieldPaths });
+    if (!rootPaths) return args.event;
+    return {
+      ...args.event,
+      meta: {
+        ...meta,
+        dirty: {
+          ...dirty,
+          rootPaths
+        }
+      }
+    };
+  }
+  return args.event;
+};
+var fromDomEvent = (event) => Stream.callback(
+  (queue) => Effect.gen(function* () {
+    const handler = (e) => {
+      Queue.offerUnsafe(queue, e);
+    };
+    window.addEventListener(event, handler);
+    yield* Effect.addFinalizer(() => Effect.sync(() => window.removeEventListener(event, handler)));
+  })
+);
 var DevtoolsLogic = DevtoolsModule.logic(($) => ({
   setup: $.lifecycle.onStart(
     Effect.gen(function* () {
-      const snapshotStore = yield* DevtoolsSnapshotStore;
+      const snapshotStore = yield* $.use(DevtoolsSnapshotStore);
       const initialSnapshot = yield* snapshotStore.get;
       yield* $.state.update(
         (prev) => computeDevtoolsState(prev, initialSnapshot, {
@@ -1066,7 +1213,7 @@ var DevtoolsLogic = DevtoolsModule.logic(($) => ({
   ),
   // run section: initialize snapshot subscription + register all onAction watchers and dragging logic.
   run: Effect.gen(function* () {
-    const snapshotStore = yield* DevtoolsSnapshotStore;
+    const snapshotStore = yield* $.use(DevtoolsSnapshotStore);
     yield* $.on(snapshotStore.changes).runFork(
       (snapshot) => $.state.update(
         (prev) => computeDevtoolsState(prev, snapshot, {
@@ -1165,13 +1312,15 @@ var DevtoolsLogic = DevtoolsModule.logic(($) => ({
           return;
         }
         const evidence = Logix3.Observability.importEvidencePackage(parsed);
+        const fieldPathsByDigest = readConvergeFieldPathsByDigest(evidence.summary);
         const events = [];
         for (const envelope of evidence.events) {
           if (envelope.type !== "debug:event") continue;
           const payload = envelope.payload;
           const normalized = normalizeRuntimeDebugEventRef(payload);
           if (!normalized) continue;
-          events.push(normalized);
+          const canonicalEvent = stripLegacyDirtyRootPathsFromEvent(normalized);
+          events.push(materializeDirtyRootPathsFromCanonical({ event: canonicalEvent, fieldPathsByDigest }));
         }
         const snapshot = {
           snapshotToken: 0,
@@ -1263,14 +1412,14 @@ var devtoolsRuntime = Logix4.Runtime.make(DevtoolsImpl, {
   // so Logic can subscribe to Snapshot changes via Tag.
   layer: devtoolsSnapshotLayer
 });
-var devtoolsModuleRuntime = devtoolsRuntime.runSync(DevtoolsModule.tag);
+var devtoolsModuleRuntime = devtoolsRuntime.runSync(Effect2.service(DevtoolsModule.tag).pipe(Effect2.orDie));
 
 // src/internal/ui/hooks/DevtoolsHooks.tsx
 var subscribe = (onStoreChange) => {
   const fiber = devtoolsRuntime.runFork(
     Stream2.runForEach(
       devtoolsModuleRuntime.changes((state) => state),
-      () => Effect2.sync(onStoreChange)
+      () => Effect3.sync(onStoreChange)
     )
   );
   return () => {
@@ -1602,9 +1751,9 @@ var makeTraitConvergeOverrideSnippets = (params) => {
       [moduleId]: patch
     }
   })})`;
-  const moduleOverride = `Logix.Runtime.setTraitConvergeOverride(runtime, ${stableStringify(moduleId)}, ${stableStringify(
+  const moduleOverride = `await Effect.runPromise(Logix.Runtime.setTraitConvergeOverride(runtime, ${stableStringify(moduleId)}, ${stableStringify(
     patch
-  )})`;
+  )}))`;
   return [
     {
       kind: "provider_override",

package/dist/{chunk-FNWHBEXD.js → chunk-NH3EYAZ6.js}

@@ -1,7 +1,10 @@
 // src/internal/snapshot/index.ts
 import * as Logix from "@logixjs/core";
-import { Context, Effect, Layer, Stream } from "effect";
-var clearDevtoolsEvents = Logix.Debug.clearDevtoolsEvents;
+import { Effect, Layer, PubSub, ServiceMap, Stream } from "effect";
+var clearDevtoolsEvents = () => {
+  Logix.Debug.clearDevtoolsEvents();
+  notify();
+};
 var setInstanceLabel = Logix.Debug.setInstanceLabel;
 var getInstanceLabel = Logix.Debug.getInstanceLabel;
 var snapshotOverride;
@@ -46,7 +49,9 @@ var normalizeDevtoolsSnapshot = (snapshot) => {
 };
 var listeners = /* @__PURE__ */ new Set();
 var unsubscribeCore;
+var snapshotPubSub = Effect.runSync(PubSub.unbounded());
 var notify = () => {
+  PubSub.publishUnsafe(snapshotPubSub, getDevtoolsSnapshot());
   for (const listener of listeners) {
     listener();
   }
@@ -88,17 +93,13 @@ var subscribeDevtoolsSnapshot = (listener) => {
 };
 var subscribeDevtoolsSnapshotToken = subscribeDevtoolsSnapshot;
 var devtoolsLayer = Logix.Debug.devtoolsHubLayer();
-var DevtoolsSnapshotStore = class extends Context.Tag("Logix/DevtoolsSnapshotStore")() {
+var DevtoolsSnapshotStore = class extends ServiceMap.Service()(
+  "Logix/DevtoolsSnapshotStore"
+) {
 };
 var devtoolsSnapshotService = {
   get: Effect.sync(() => getDevtoolsSnapshot()),
-  changes: Stream.async((emit) => {
-    const listener = () => {
-      emit.single(getDevtoolsSnapshot());
-    };
-    const unsubscribe = subscribeDevtoolsSnapshot(listener);
-    return Effect.sync(unsubscribe);
-  })
+  changes: Stream.fromPubSub(snapshotPubSub)
 };
 var devtoolsSnapshotLayer = Layer.succeed(
   DevtoolsSnapshotStore,