@logixjs/devtools-react 0.0.1 → 1.0.0

package/dist/LogixDevtools.cjs

@@ -64,15 +64,19 @@ var Logix8 = __toESM(require("@logixjs/core"), 1);
 
 // src/internal/ui/hooks/DevtoolsHooks.tsx
 var import_react = __toESM(require("react"), 1);
-var import_effect5 = require("effect");
+var import_effect6 = require("effect");
 
 // src/internal/state/runtime.ts
 var Logix5 = __toESM(require("@logixjs/core"), 1);
+var import_effect5 = require("effect");
 
 // src/internal/snapshot/index.ts
 var Logix = __toESM(require("@logixjs/core"), 1);
 var import_effect = require("effect");
-var clearDevtoolsEvents = Logix.Debug.clearDevtoolsEvents;
+var clearDevtoolsEvents = () => {
+  Logix.Debug.clearDevtoolsEvents();
+  notify();
+};
 var setInstanceLabel = Logix.Debug.setInstanceLabel;
 var getInstanceLabel = Logix.Debug.getInstanceLabel;
 var snapshotOverride;
@@ -116,19 +120,13 @@ var normalizeDevtoolsSnapshot = (snapshot) => {
   return { ...snapshot, events };
 };
 var listeners = /* @__PURE__ */ new Set();
-var unsubscribeCore;
+var snapshotPubSub = import_effect.Effect.runSync(import_effect.PubSub.unbounded());
 var notify = () => {
+  import_effect.PubSub.publishUnsafe(snapshotPubSub, getDevtoolsSnapshot());
   for (const listener of listeners) {
     listener();
   }
 };
-var ensureCoreSubscribed = () => {
-  if (unsubscribeCore) return;
-  unsubscribeCore = Logix.Debug.subscribeDevtoolsSnapshot(() => {
-    if (snapshotOverride) return;
-    notify();
-  });
-};
 var hasDevtoolsSnapshotOverride = () => snapshotOverride != null;
 var getDevtoolsSnapshotOverrideInfo = () => snapshotOverrideInfo;
 var setDevtoolsSnapshotOverride = (snapshot, info) => {
@@ -145,29 +143,14 @@ var clearDevtoolsSnapshotOverride = () => {
   notify();
 };
 var getDevtoolsSnapshot = () => snapshotOverride ?? Logix.Debug.getDevtoolsSnapshot();
-var subscribeDevtoolsSnapshot = (listener) => {
-  listeners.add(listener);
-  ensureCoreSubscribed();
-  return () => {
-    listeners.delete(listener);
-    if (listeners.size === 0 && unsubscribeCore) {
-      unsubscribeCore();
-      unsubscribeCore = void 0;
-    }
-  };
-};
 var devtoolsLayer = Logix.Debug.devtoolsHubLayer();
-var DevtoolsSnapshotStore = class extends import_effect.Context.Tag("Logix/DevtoolsSnapshotStore")() {
+var DevtoolsSnapshotStore = class extends import_effect.ServiceMap.Service()(
+  "Logix/DevtoolsSnapshotStore"
+) {
 };
 var devtoolsSnapshotService = {
   get: import_effect.Effect.sync(() => getDevtoolsSnapshot()),
-  changes: import_effect.Stream.async((emit) => {
-    const listener = () => {
-      emit.single(getDevtoolsSnapshot());
-    };
-    const unsubscribe = subscribeDevtoolsSnapshot(listener);
-    return import_effect.Effect.sync(unsubscribe);
-  })
+  changes: import_effect.Stream.fromPubSub(snapshotPubSub)
 };
 var devtoolsSnapshotLayer = import_effect.Layer.succeed(
   DevtoolsSnapshotStore,
@@ -213,7 +196,7 @@ var OperationSummarySchema = import_effect2.Schema.Struct({
       top3: import_effect2.Schema.Array(
         import_effect2.Schema.Struct({
           stepId: import_effect2.Schema.String,
-          kind: import_effect2.Schema.Literal("computed", "link"),
+          kind: import_effect2.Schema.Literals(["computed", "link"]),
           fieldPath: import_effect2.Schema.String,
           durationMs: import_effect2.Schema.Number,
           changed: import_effect2.Schema.Boolean,
@@ -229,7 +212,7 @@ var TriggerLayoutSchema = import_effect2.Schema.Struct({
   isDragging: import_effect2.Schema.Boolean
 });
 var DevtoolsSettingsSchema = import_effect2.Schema.Struct({
-  mode: import_effect2.Schema.Literal("basic", "deep"),
+  mode: import_effect2.Schema.Literals(["basic", "deep"]),
   showTraitEvents: import_effect2.Schema.Boolean,
   showReactRenderEvents: import_effect2.Schema.Boolean,
   enableTimeTravelUI: import_effect2.Schema.Boolean,
@@ -270,7 +253,7 @@ var DevtoolsStateSchema = import_effect2.Schema.Struct({
       moduleId: import_effect2.Schema.String,
       instanceId: import_effect2.Schema.String,
       txnId: import_effect2.Schema.String,
-      mode: import_effect2.Schema.Literal("before", "after")
+      mode: import_effect2.Schema.Literals(["before", "after"])
     })
   ),
   runtimes: import_effect2.Schema.Array(
@@ -299,7 +282,7 @@ var DevtoolsStateSchema = import_effect2.Schema.Struct({
     isDragging: import_effect2.Schema.Boolean,
     trigger: import_effect2.Schema.optional(TriggerLayoutSchema)
   }),
-  theme: import_effect2.Schema.Literal("system", "light", "dark"),
+  theme: import_effect2.Schema.Literals(["system", "light", "dark"]),
   settings: DevtoolsSettingsSchema
 });
 var defaultSettings = {
@@ -369,13 +352,11 @@ var gateDirtyRootPathsByDigest = (meta) => {
   }
   const dirtySet = meta.dirtySet;
   if (!isRecord2(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;
@@ -906,23 +887,21 @@ var persistSettingsToStorage = (settings) => {
 var Logix3 = __toESM(require("@logixjs/core"), 1);
 var import_effect3 = require("effect");
 var ResizePayload = import_effect3.Schema.Struct({
-  edge: import_effect3.Schema.Literal("top", "left", "right")
+  edge: import_effect3.Schema.Literals(["top", "left", "right"])
+});
+var UpdateLayoutPayload = import_effect3.Schema.Struct({
+  height: import_effect3.Schema.optional(import_effect3.Schema.Number),
+  marginLeft: import_effect3.Schema.optional(import_effect3.Schema.Number),
+  marginRight: import_effect3.Schema.optional(import_effect3.Schema.Number),
+  isDragging: import_effect3.Schema.optional(import_effect3.Schema.Boolean),
+  trigger: import_effect3.Schema.optional(
+    import_effect3.Schema.Struct({
+      x: import_effect3.Schema.Number,
+      y: import_effect3.Schema.Number,
+      isDragging: import_effect3.Schema.Boolean
+    })
+  )
 });
-var UpdateLayoutPayload = import_effect3.Schema.partial(
-  import_effect3.Schema.Struct({
-    height: import_effect3.Schema.Number,
-    marginLeft: import_effect3.Schema.Number,
-    marginRight: import_effect3.Schema.Number,
-    isDragging: import_effect3.Schema.Boolean,
-    trigger: import_effect3.Schema.optional(
-      import_effect3.Schema.Struct({
-        x: import_effect3.Schema.Number,
-        y: import_effect3.Schema.Number,
-        isDragging: import_effect3.Schema.Boolean
-      })
-    )
-  })
-);
 var DevtoolsModule = Logix3.Module.make("LogixDevtoolsModule", {
   state: DevtoolsStateSchema,
   actions: {
@@ -956,8 +935,8 @@ var DevtoolsModule = Logix3.Module.make("LogixDevtoolsModule", {
     clearImportedEvidence: import_effect3.Schema.Void,
     resizeStart: ResizePayload,
     updateLayout: UpdateLayoutPayload,
-    setTheme: import_effect3.Schema.Literal("system", "light", "dark"),
-    setMode: import_effect3.Schema.Literal("basic", "deep"),
+    setTheme: import_effect3.Schema.Literals(["system", "light", "dark"]),
+    setMode: import_effect3.Schema.Literals(["basic", "deep"]),
     updateSettings: import_effect3.Schema.Any
   },
   reducers: {
@@ -1192,15 +1171,165 @@ var normalizeRuntimeDebugEventRef = (value) => {
   }
   return { ...value, instanceId };
 };
-var fromDomEvent = (event) => import_effect4.Stream.async((emit) => {
-  const handler = (e) => emit.single(e);
-  window.addEventListener(event, handler);
-  return import_effect4.Effect.sync(() => window.removeEventListener(event, handler));
-});
+var readConvergeFieldPathsByDigest = (summary) => {
+  if (!isRecord3(summary)) return /* @__PURE__ */ new Map();
+  const converge = isRecord3(summary.converge) ? summary.converge : void 0;
+  const byDigest = converge && isRecord3(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 (!isRecord3(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 = isRecord3(event.meta) ? event.meta : void 0;
+  if (!meta) return event;
+  if (event.kind === "state" && event.label === "state:update") {
+    const dirtySet = isRecord3(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 = isRecord3(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 = isRecord3(args.event.meta) ? args.event.meta : void 0;
+  if (!meta) return args.event;
+  const staticIrDigest = asNonEmptyString2(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 = isRecord3(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 = isRecord3(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) => import_effect4.Stream.callback(
+  (queue) => import_effect4.Effect.gen(function* () {
+    const handler = (e) => {
+      import_effect4.Queue.offerUnsafe(queue, e);
+    };
+    window.addEventListener(event, handler);
+    yield* import_effect4.Effect.addFinalizer(() => import_effect4.Effect.sync(() => window.removeEventListener(event, handler)));
+  })
+);
 var DevtoolsLogic = DevtoolsModule.logic(($) => ({
   setup: $.lifecycle.onStart(
     import_effect4.Effect.gen(function* () {
-      const snapshotStore = yield* DevtoolsSnapshotStore;
+      const snapshotStore = yield* $.use(DevtoolsSnapshotStore);
       const initialSnapshot = yield* snapshotStore.get;
       yield* $.state.update(
         (prev) => computeDevtoolsState(prev, initialSnapshot, {
@@ -1211,7 +1340,7 @@ var DevtoolsLogic = DevtoolsModule.logic(($) => ({
   ),
   // run section: initialize snapshot subscription + register all onAction watchers and dragging logic.
   run: import_effect4.Effect.gen(function* () {
-    const snapshotStore = yield* DevtoolsSnapshotStore;
+    const snapshotStore = yield* $.use(DevtoolsSnapshotStore);
     yield* $.on(snapshotStore.changes).runFork(
       (snapshot) => $.state.update(
         (prev) => computeDevtoolsState(prev, snapshot, {
@@ -1310,13 +1439,15 @@ var DevtoolsLogic = DevtoolsModule.logic(($) => ({
           return;
         }
         const evidence = Logix4.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,
@@ -1408,18 +1539,18 @@ var devtoolsRuntime = Logix5.Runtime.make(DevtoolsImpl, {
   // so Logic can subscribe to Snapshot changes via Tag.
   layer: devtoolsSnapshotLayer
 });
-var devtoolsModuleRuntime = devtoolsRuntime.runSync(DevtoolsModule.tag);
+var devtoolsModuleRuntime = devtoolsRuntime.runSync(import_effect5.Effect.service(DevtoolsModule.tag).pipe(import_effect5.Effect.orDie));
 
 // src/internal/ui/hooks/DevtoolsHooks.tsx
 var subscribe = (onStoreChange) => {
   const fiber = devtoolsRuntime.runFork(
-    import_effect5.Stream.runForEach(
+    import_effect6.Stream.runForEach(
       devtoolsModuleRuntime.changes((state) => state),
-      () => import_effect5.Effect.sync(onStoreChange)
+      () => import_effect6.Effect.sync(onStoreChange)
     )
   );
   return () => {
-    devtoolsRuntime.runFork(import_effect5.Fiber.interrupt(fiber));
+    devtoolsRuntime.runFork(import_effect6.Fiber.interrupt(fiber));
   };
 };
 var getSnapshot = () => devtoolsRuntime.runSync(devtoolsModuleRuntime.getState);
@@ -1747,9 +1878,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/LogixDevtools.js

@@ -1,7 +1,7 @@
 import {
   LogixDevtools
-} from "./chunk-WTZBDE4J.js";
-import "./chunk-FNWHBEXD.js";
+} from "./chunk-H5JD2DNC.js";
+import "./chunk-NH3EYAZ6.js";
 import "./chunk-CZWYV2AZ.js";
 export {
   LogixDevtools