solid-deps 0.0.3 → 0.0.4

package/README.md

@@ -16,7 +16,7 @@ Or with Bun:
 bun add solid-deps solid-js@2.0.0-rc.17 @solidjs/signals@2.0.0-rc.17
 ```
 
-**Compatibility:** Tested with Solid 2.0.0-rc.17 production, development and observe builds. `solid-deps` now discovers observer graph fields at runtime, rather than using fixed field-name mappings. Other Solid 2 versions may work if they retain compatible internal graph semantics, but are not yet verified. Your app and `solid-deps` must share one `@solidjs/signals` runtime instance. SSR is not supported.
+**Compatibility:** Tested with Solid 2.0.0-rc.17 production, development and observe builds. `solid-deps` recognizes validated descriptive development fields directly and discovers unknown or minified graph fields at runtime. Other Solid 2 versions may work if they retain compatible internal graph semantics, but are not yet verified. Your app and `solid-deps` must share one `@solidjs/signals` runtime instance. SSR is not supported.
 
 ## Quick start: `createScope()`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solid-deps",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Experimental direct dependency attachment for Solid 2 reactive observers after async boundaries",
   "type": "module",
   "license": "MIT",
@@ -37,9 +37,9 @@
   ],
   "scripts": {
     "setup": "node scripts/setup.mjs",
-    "test": "node --conditions=browser --test test/test.mjs test/test-async.mjs test/test-return.mjs test/test-scope.mjs test/test-manifest.mjs test/test-graph-hardening.mjs test/test-async-transitions.mjs test/test-transaction-integrity.mjs test/test-scheduler-lifecycle.mjs test/test-release-hardening.mjs test/test-discovery.mjs",
-    "test:dev": "node --conditions=browser --conditions=development --test test/test.mjs test/test-async.mjs test/test-return.mjs test/test-scope.mjs test/test-manifest.mjs test/test-graph-hardening.mjs test/test-async-transitions.mjs test/test-transaction-integrity.mjs test/test-scheduler-lifecycle.mjs test/test-release-hardening.mjs test/test-discovery.mjs",
-    "test:observe": "node --conditions=browser --conditions=observe --test test/test.mjs test/test-async.mjs test/test-return.mjs test/test-scope.mjs test/test-manifest.mjs test/test-graph-hardening.mjs test/test-async-transitions.mjs test/test-transaction-integrity.mjs test/test-scheduler-lifecycle.mjs test/test-release-hardening.mjs test/test-discovery.mjs",
+    "test": "node --conditions=browser --test test/test.mjs test/test-async.mjs test/test-return.mjs test/test-scope.mjs test/test-manifest.mjs test/test-graph-hardening.mjs test/test-async-transitions.mjs test/test-transaction-integrity.mjs test/test-scheduler-lifecycle.mjs test/test-release-hardening.mjs test/test-discovery.mjs test/test-fastpath.mjs test/test-owner-bound-research.mjs",
+    "test:dev": "node --conditions=browser --conditions=development --test test/test.mjs test/test-async.mjs test/test-return.mjs test/test-scope.mjs test/test-manifest.mjs test/test-graph-hardening.mjs test/test-async-transitions.mjs test/test-transaction-integrity.mjs test/test-scheduler-lifecycle.mjs test/test-release-hardening.mjs test/test-discovery.mjs test/test-fastpath.mjs test/test-owner-bound-research.mjs",
+    "test:observe": "node --conditions=browser --conditions=observe --test test/test.mjs test/test-async.mjs test/test-return.mjs test/test-scope.mjs test/test-manifest.mjs test/test-graph-hardening.mjs test/test-async-transitions.mjs test/test-transaction-integrity.mjs test/test-scheduler-lifecycle.mjs test/test-release-hardening.mjs test/test-discovery.mjs test/test-fastpath.mjs test/test-owner-bound-research.mjs",
     "test:all": "node scripts/run-tests.mjs",
     "test:package": "node scripts/smoke-package.mjs",
     "test:browser": "node --test test/browser/playwright.test.mjs",

package/src/discover.mjs

@@ -1,6 +1,7 @@
 /**
  * Discover the private linked dependency graph from controlled, disposable
- * Solid computations. No minified or development property names are encoded.
+ * Solid computations. Only recognizable descriptive development property names
+ * are encoded; all unknown layouts use the name-independent inference.
  *
  * This is topology inference, not a guarantee of compatibility with a new
  * algorithm or a property-mangling transform that changes graph semantics.
@@ -11,6 +12,111 @@ import {
 } from '@solidjs/signals';
 
 let inferred;
+const diagnostics = { knownDev: 0, inferred: 0 };
+
+/** Internal test-only counters. Not exported from the package entry point. */
+export function _discoveryDiagnostics() {
+  return { ...diagnostics, origin: inferred?.origin ?? null };
+}
+
+// Development field names are a candidate, never evidence of graph compatibility.
+// Minified field names are deliberately not recorded here.
+const knownDev = Object.freeze({
+  deps: '_deps', tail: '_depsTail', gen: '_depGen', flags: '_flags',
+  dep: '_dep', sub: '_sub', next: '_nextDep', linkGen: '_gen',
+  parent: '_parent', child: '_firstChild', disposal: '_disposal',
+  recomputingBit: 4
+});
+const devFields = ['deps', 'tail', 'gen', 'flags', 'parent', 'child', 'disposal'];
+
+// Only inspect own *data* properties to avoid executing an arbitrary getter
+// during compatibility detection. A missing data field is not silently read.
+function data(node, key) {
+  if (!obj(node)) return { exists: false };
+  const descriptor = Object.getOwnPropertyDescriptor(node, key);
+  return descriptor && 'value' in descriptor
+    ? { exists: true, value: descriptor.value }
+    : { exists: false };
+}
+
+/**
+ * Pure, non-mutating candidate check; the initial observer may have zero deps,
+ * or a validated prefix followed by an older-generation stale suffix.
+ * `null` means unknown or partially renamed; corrupted complete layouts throw.
+ * Kept as an internal module export for the source-tree regression suite.
+ */
+export function tryKnownDevLayout(node) {
+  if (!obj(node)) return null;
+  const present = devFields.filter(role => Object.hasOwn(node, knownDev[role]));
+  if (present.length !== devFields.length) return null;
+
+  const read = (object, key, role) => {
+    const slot = data(object, key);
+    if (!slot.exists) throw new Error(`solid-deps: invalid known development ${role}; refusing graph mutation`);
+    return slot.value;
+  };
+  const fail = why => { throw new Error(`solid-deps: invalid known development graph (${why}); refusing graph mutation`); };
+  const gen = read(node, knownDev.gen, 'generation');
+  const flags = read(node, knownDev.flags, 'flags');
+  const head = read(node, knownDev.deps, 'head');
+  const tail = read(node, knownDev.tail, 'tail');
+  const parent = read(node, knownDev.parent, 'parent');
+  const child = read(node, knownDev.child, 'child');
+  const disposal = read(node, knownDev.disposal, 'disposal');
+
+  if (!Number.isSafeInteger(gen) || gen < 0 || !Number.isSafeInteger(flags) || flags < 0)
+    fail('generation or flags is not a nonnegative integer');
+  // Multiple onCleanup() calls create an array of disposal callbacks.
+  // Check their data slots without invoking a potentially shadowed .every().
+  let validDisposal = disposal == null || typeof disposal === 'function';
+  if (Array.isArray(disposal)) {
+    validDisposal = disposal.length > 0;
+    for (let i = 0; i < disposal.length; i++) {
+      const callback = data(disposal, String(i));
+      if (!callback.exists || typeof callback.value !== 'function') validDisposal = false;
+    }
+  }
+  if (head != null && !obj(head) || tail != null && !obj(tail) ||
+      parent != null && !obj(parent) || child != null && !obj(child) ||
+      !validDisposal)
+    fail('invalid dependency or lifecycle value');
+  if (head == null && tail != null) fail('tail exists without a head');
+
+  let edge = head;
+  let tailReached = tail == null;
+  const visited = new Set();
+  while (edge != null) {
+    if (!obj(edge) || visited.has(edge)) fail('non-link or cyclic dependency chain');
+    visited.add(edge);
+    const source = read(edge, knownDev.dep, 'link source');
+    const subscriber = read(edge, knownDev.sub, 'link subscriber');
+    const linkGen = read(edge, knownDev.linkGen, 'link generation');
+    const next = read(edge, knownDev.next, 'next link');
+    if (!obj(source) || subscriber !== node || !Number.isSafeInteger(linkGen) ||
+        linkGen < 0 || linkGen > gen || next != null && !obj(next))
+      fail('inconsistent dependency link');
+
+    // Check both sides of the source subscription list. In rc.17 dev builds,
+    // source._subs and edge._nextSub connect each signal back to its readers.
+    // This is a read-only check, never an attempt to repair graph structure.
+    let sub = read(source, '_subs', 'source subscriber head');
+    const subscribers = new Set();
+    let found = false;
+    while (sub != null) {
+      if (!obj(sub) || subscribers.has(sub)) fail('invalid source subscriber list');
+      subscribers.add(sub);
+      if (sub === edge) found = true;
+      sub = read(sub, '_nextSub', 'subscriber next');
+    }
+    if (!found) fail('source is not subscribed back to dependency link');
+
+    if (edge === tail) tailReached = true;
+    edge = next;
+  }
+  if (!tailReached) fail('tail not reachable from dependency head');
+  return knownDev;
+}
+
 const own = (obj) => obj && typeof obj === 'object'
   ? Reflect.ownKeys(obj).filter(key => Object.prototype.propertyIsEnumerable.call(obj, key)) : [];
 const entries = obj => own(obj).map(key => [key, obj[key]]);
@@ -157,12 +263,24 @@ function discover() {
   }
 }
 
-export function internalLayout() {
-  return inferred ??= discover();
+export function internalLayout(node) {
+  if (inferred) return inferred.layout;
+  // Called with the real target by layoutOf; keep the optional no-argument
+  // form for internal source-tree tests and unknown-layout calibration.
+  const dev = node == null ? null : tryKnownDevLayout(node);
+  if (dev) {
+    diagnostics.knownDev++;
+    inferred = { layout: dev, origin: 'known-dev' };
+  } else {
+    const layout = discover();
+    diagnostics.inferred++;
+    inferred = { layout, origin: 'inferred' };
+  }
+  return inferred.layout;
 }
 
 export function layoutOf(node) {
-  const shape = internalLayout();
+  const shape = internalLayout(node);
   if (!obj(node) || typeof node[shape.gen] !== 'number' ||
       !(shape.deps in node) || !(shape.tail in node) ||
       typeof node[shape.flags] !== 'number' || !(shape.child in node) ||