@expressive/inspect 0.0.1

package/README.md

@@ -0,0 +1,64 @@
+<h1 align="center">@expressive/inspect</h1>
+
+<p align="center">
+  In-process inspector for Expressive MVC state.
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@expressive/inspect"><img alt="NPM" src="https://badge.fury.io/js/%40expressive%2Finspect.svg"></a>
+</p>
+
+---
+
+Query the live model graph of an [Expressive MVC](https://github.com/gabeklein/expressive-mvc) app from a test, a Playwright spec, or the browser console. No UI, no network - a base layer for agents, devtools, and test helpers.
+
+```bash
+npm install --save-dev @expressive/inspect
+```
+
+## Install into the app
+
+```ts
+// first import of the app entry, before any State is constructed
+import '@expressive/inspect/install';
+```
+
+Attaches to every `State` and publishes `globalThis.__EXPRESSIVE_INSPECT__`. For a shipped build, call `attach()` behind your own dev flag instead of the side-effect import.
+
+## In process
+
+```ts
+import { find, roots } from '@expressive/inspect';
+
+const composer = find('Composer');           // by label, or by id
+composer.state                               // the raw instance
+composer.parent / composer.children          // ownership
+composer.get('draft')                        // stored value, no getter fires
+const frames = await composer.act((s) => s.submit('hi'));   // run, settle, see what changed
+```
+
+## Across a boundary
+
+```ts
+import { inspect } from '@expressive/inspect/playwright';
+
+const api = inspect(page);                   // Page, Frame, or Locator
+await api.get('Composer.draft');
+const frames = await api.around(() => page.click('#submit'));
+```
+
+Console: `__EXPRESSIVE_INSPECT__.get('Composer.draft')`, `__EXPRESSIVE_INSPECT__.journal.record({ level: 'keys', paths: ['Composer.draft'] })`.
+
+## Journal
+
+Off by default. `journal.record({ level, types, paths, keys, calls })`, then `frames({ since })`. A frame is one batch of writes plus its flush; work an effect defers carries a `cause` back to the frame that scheduled it. `export()` emits NDJSON for a sidecar.
+
+## Orphans
+
+Instances a host never committed - a render thrown away, a StrictMode twin - stay out of `models()` and `tree()`. `orphans()` lists them, `warnings()` counts them.
+
+## Minified builds
+
+Property names survive minification; class names do not. Each class gets a stable `typeId` and a construction `site`. Name them with `label(Type, 'Composer')`, `static displayName`, or `resolve({ T3: 'Composer' })`, or keep names at build time (`keepNames`, `keep_classnames`).
+
+Full reference: [skills/inspect.md](https://github.com/gabeklein/expressive-mvc/blob/main/skills/inspect.md).

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import { C as Level, E as act, S as Frame, T as Query, _ as warnings, a as Node, b as resolve, c as detach, d as instances, f as models, g as tree, h as set, i as Model, l as find, m as roots, n as serialize, o as attach, p as orphans, r as Instance, s as call, t as parsePath, u as get, v as TypeInfo, w as Options, x as Event, y as label } from "./serialize-FF81tr-L.js";
+
+//#region src/index.d.ts
+declare const journal: {
+  record(options?: Options): Required<Options>;
+  frames(query?: Query): Frame[];
+  history(query: Query): Array<{
+    seq: number;
+    at: number;
+    event: Event;
+  }>;
+  downstream(from: number): Frame[];
+  seq(): number;
+  export(query?: Query): string;
+  clear(): void;
+  reset(): void;
+};
+declare const inspect: {
+  attach: typeof attach;
+  detach: typeof detach;
+  find: typeof find;
+  instances: typeof instances;
+  roots: typeof roots;
+  orphans: typeof orphans;
+  warnings: typeof warnings;
+  models: typeof models;
+  tree: typeof tree;
+  get: typeof get;
+  set: typeof set;
+  call: typeof call;
+  act: typeof act;
+  label: typeof label;
+  resolve: typeof resolve;
+  journal: {
+    record(options?: Options): Required<Options>;
+    frames(query?: Query): Frame[];
+    history(query: Query): Array<{
+      seq: number;
+      at: number;
+      event: Event;
+    }>;
+    downstream(from: number): Frame[];
+    seq(): number;
+    export(query?: Query): string;
+    clear(): void;
+    reset(): void;
+  };
+};
+declare global {
+  var __EXPRESSIVE_INSPECT__: typeof inspect | undefined;
+}
+//#endregion
+export { type Event, type Frame, Instance, type Level, type Model, type Node, type Options, type Query, type TypeInfo, act, attach, call, inspect as default, inspect, detach, find, get, instances, journal, label, models, orphans, parsePath, resolve, roots, serialize, set, tree, warnings };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,33 @@
+import { _ as label, a as find, b as serialize, c as models, d as set, f as tree, g as journal$1, h as act, i as detach, l as orphans, m as wrapAll, n as attach, o as get, p as warnings, r as call, s as instances, t as Instance, u as roots, v as resolve, y as parsePath } from "./inspect-D4NC5Mx5.js";
+
+//#region src/index.ts
+const journal = {
+	...journal$1,
+	record(options) {
+		const config = journal$1.record(options);
+		if (config.calls && config.level !== "off") wrapAll();
+		return config;
+	}
+};
+const inspect = {
+	attach,
+	detach,
+	find,
+	instances,
+	roots,
+	orphans,
+	warnings,
+	models,
+	tree,
+	get,
+	set,
+	call,
+	act,
+	label,
+	resolve,
+	journal
+};
+
+//#endregion
+export { Instance, act, attach, call, inspect as default, inspect, detach, find, get, instances, journal, label, models, orphans, parsePath, resolve, roots, serialize, set, tree, warnings };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["base"],"sources":["../src/index.ts"],"sourcesContent":["import { attach, call, detach, find, get, Instance, instances, models, orphans, roots, set, tree, warnings, wrapAll } from './inspect';\nimport { act, journal as base, type Options } from './journal';\nimport { label, resolve } from './types';\n\nexport type { Model, Node } from './inspect';\nexport type { Event, Frame, Level, Options, Query } from './journal';\nexport type { TypeInfo } from './types';\nexport { Instance, act, attach, call, detach, find, get, instances, label, models, orphans, resolve, roots, set, tree, warnings };\nexport { parsePath, serialize } from './serialize';\n\nexport const journal = {\n  ...base,\n  record(options?: Options) {\n    const config = base.record(options);\n    if (config.calls && config.level !== 'off') wrapAll();\n    return config;\n  }\n};\n\nexport const inspect = {\n  attach,\n  detach,\n  find,\n  instances,\n  roots,\n  orphans,\n  warnings,\n  models,\n  tree,\n  get,\n  set,\n  call,\n  act,\n  label,\n  resolve,\n  journal\n};\n\ndeclare global {\n  var __EXPRESSIVE_INSPECT__: typeof inspect | undefined;\n}\n\nexport default inspect;\n"],"mappings":";;;AAUA,MAAa,UAAU;CACrB,GAAGA;CACH,OAAO,SAAmB;EACxB,MAAM,SAASA,UAAK,OAAO,QAAQ;AACnC,MAAI,OAAO,SAAS,OAAO,UAAU,MAAO,UAAS;AACrD,SAAO;;CAEV;AAED,MAAa,UAAU;CACrB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD"}

package/dist/inspect-D4NC5Mx5.js

@@ -0,0 +1,641 @@
+import { Context, State } from "@expressive/mvc";
+import { isElement } from "@expressive/mvc/runtime";
+
+//#region src/serialize.ts
+const MAX_STRING = 240;
+const MAX_ARRAY = 24;
+const MAX_KEYS = 40;
+function parsePath(raw) {
+	const trimmed = raw.trim();
+	const dot = trimmed.indexOf(".");
+	if (dot <= 0) return { target: trimmed };
+	return {
+		target: trimmed.slice(0, dot),
+		path: trimmed.slice(dot + 1)
+	};
+}
+/** Raw stored entries of a State - never reads through accessors. */
+function entries(state) {
+	return new Map(state);
+}
+/** Walk `path` without triggering getters, factories, or suspense. */
+function walk(value, path) {
+	if (!path) return value;
+	let cur = value;
+	for (const part of path.split(".")) {
+		if (cur == null || typeof cur !== "object") return void 0;
+		if (cur instanceof State) cur = entries(cur).get(part);
+		else if (cur instanceof Map) cur = cur.get(part);
+		else cur = cur[part];
+	}
+	return cur;
+}
+function ref(state) {
+	return {
+		$ref: String(state),
+		$type: state.constructor.name
+	};
+}
+/** JSON-safe, size-capped view. Nested States collapse to `$ref`. */
+function serialize(value, depth = 2) {
+	if (value instanceof State) {
+		const out = ref(value);
+		for (const [key, child] of [...entries(value)].slice(0, MAX_KEYS)) out[key] = write(child, depth - 1);
+		return out;
+	}
+	return write(value, depth);
+}
+function write(value, depth) {
+	if (value == null || typeof value === "boolean") return value;
+	if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+	if (typeof value === "string") return value.length > MAX_STRING ? `${value.slice(0, MAX_STRING - 1)}…` : value;
+	if (typeof value === "bigint") return `${value}n`;
+	if (typeof value !== "object") return void 0;
+	if (value instanceof State) return ref(value);
+	if (value instanceof Date) return value.toISOString();
+	if (value instanceof Error) return {
+		name: value.name,
+		message: value.message
+	};
+	if (typeof value.then === "function") return "(pending)";
+	const items = list(value);
+	if (items) {
+		if (depth <= 0) return `[${items.length}]`;
+		const out = items.slice(0, MAX_ARRAY).map((row) => write(row, depth - 1));
+		if (items.length > MAX_ARRAY) out.push(`…+${items.length - MAX_ARRAY}`);
+		return out;
+	}
+	const pairs = value instanceof Map ? [...value].map(([k, v]) => [String(k), v]) : Object.entries(value);
+	if (depth <= 0) return `{${pairs.length}}`;
+	const out = {};
+	for (const [key, child] of pairs.slice(0, MAX_KEYS)) {
+		if (key === "is") continue;
+		const next = write(child, depth - 1);
+		if (next !== void 0) out[key] = next;
+	}
+	if (pairs.length > MAX_KEYS) out["…"] = pairs.length - MAX_KEYS;
+	return out;
+}
+function list(value) {
+	if (Array.isArray(value)) return value;
+	if (value instanceof Map) return void 0;
+	if (typeof value[Symbol.iterator] === "function") return [...value];
+}
+
+//#endregion
+//#region src/types.ts
+const info = /* @__PURE__ */ new Map();
+const labels = /* @__PURE__ */ new Map();
+const names = /* @__PURE__ */ new Map();
+let count = 0;
+function register(Type) {
+	let row = info.get(Type);
+	if (!row) {
+		const site = String((/* @__PURE__ */ new Error()).stack).split("\n").slice(1, 16).join("\n");
+		info.set(Type, row = {
+			typeId: `T${++count}`,
+			type: "",
+			site
+		});
+	}
+	return row;
+}
+function seen(Type) {
+	const row = register(Type);
+	row.type = labelOf(Type);
+	return { ...row };
+}
+function labelOf(Type) {
+	const row = register(Type);
+	const explicit = labels.get(Type) ?? Type.displayName;
+	if (explicit) return explicit;
+	const named = names.get(row.typeId) ?? names.get(row.site);
+	if (named) return named;
+	return Type.name.length > 2 ? Type.name : row.typeId;
+}
+function label(Type, name) {
+	labels.set(Type, name);
+}
+/** Supply resolved names keyed by `typeId` or `site`, e.g. from a source-map pass. */
+function resolve(table) {
+	for (const [key, name] of Object.entries(table)) names.set(key, name);
+}
+function forget() {
+	info.clear();
+	labels.clear();
+	names.clear();
+	count = 0;
+}
+
+//#endregion
+//#region src/journal.ts
+const FRAME_CAP = 500;
+const frames = [];
+const config = {
+	level: "off",
+	types: [],
+	paths: [],
+	keys: [],
+	calls: false
+};
+let seq = 0;
+let open;
+let cause;
+const journal = {
+	record(options = {}) {
+		Object.assign(config, options);
+		if (!options.level && options.calls && config.level === "off") config.level = "keys";
+		return {
+			...config,
+			types: [...config.types],
+			paths: [...config.paths],
+			keys: [...config.keys]
+		};
+	},
+	frames(query = {}) {
+		const out = [];
+		for (const frame of frames) {
+			if (query.since !== void 0 && frame.seq <= query.since) continue;
+			if (query.cause !== void 0 && frame.cause !== query.cause) continue;
+			const events = frame.events.filter((e) => matches(e, query));
+			if (events.length) out.push({
+				...frame,
+				events
+			});
+		}
+		return out;
+	},
+	history(query) {
+		const out = [];
+		for (const frame of journal.frames(query)) for (const event of frame.events) out.push({
+			seq: frame.seq,
+			at: frame.at,
+			event
+		});
+		return out;
+	},
+	downstream(from) {
+		const roots = new Set([from]);
+		return frames.filter((frame) => {
+			if (frame.cause === void 0 || !roots.has(frame.cause)) return false;
+			roots.add(frame.seq);
+			return true;
+		});
+	},
+	seq() {
+		return seq;
+	},
+	export(query = {}) {
+		return journal.frames(query).flatMap((frame) => frame.events.map((event) => JSON.stringify({
+			seq: frame.seq,
+			at: frame.at,
+			cause: frame.cause,
+			...event
+		}))).join("\n");
+	},
+	clear() {
+		frames.length = 0;
+		open = void 0;
+		cause = void 0;
+		seq = 0;
+	},
+	reset() {
+		journal.clear();
+		Object.assign(config, {
+			level: "off",
+			types: [],
+			paths: [],
+			keys: [],
+			calls: false
+		});
+	}
+};
+function matches(event, query) {
+	return (!query.type || event.type === query.type) && (!query.id || event.id === query.id) && (!query.key || event.key === query.key);
+}
+/** Filters OR together; none set records everything. Without a key only type-level filters apply. */
+function wants(state, key) {
+	if (config.level === "off") return false;
+	const { types, paths, keys } = config;
+	if (!types.length && !paths.length && !keys.length) return true;
+	const Type = state.constructor;
+	const label = labelOf(Type);
+	if (types.includes(label)) return true;
+	if (key !== void 0 && keys.includes(key)) return true;
+	const targets = [
+		label,
+		seen(Type).typeId,
+		String(state)
+	];
+	for (const address of paths) {
+		const { target, path } = parsePath(address);
+		if (targets.includes(target) && (key === void 0 || path === key)) return true;
+	}
+	return false;
+}
+function recordsCalls() {
+	return config.calls && config.level !== "off";
+}
+/** Run `work` with recording forced on; returns the frames it produced. */
+async function act(work) {
+	const level = config.level;
+	const start = seq;
+	if (level === "off") config.level = "values";
+	try {
+		await work();
+		await new Promise((resolve) => setTimeout(resolve, 0));
+	} finally {
+		config.level = level;
+	}
+	return journal.frames({ since: start });
+}
+function note(state, key, store) {
+	const name = String(key);
+	if (!wants(state, name)) return;
+	const event = {
+		id: String(state),
+		type: labelOf(state.constructor),
+		key: name,
+		kind: typeof key === "string" && store.has(key) ? "update" : "event"
+	};
+	if (config.level === "values" && event.kind === "update") event.value = serialize(store.get(name), 1);
+	push(event);
+}
+function noteCall(state, key, args) {
+	if (!recordsCalls() || !wants(state, key)) return;
+	const event = {
+		id: String(state),
+		type: labelOf(state.constructor),
+		key,
+		kind: "call"
+	};
+	if (config.level === "values") event.args = args.map((arg) => serialize(arg, 1));
+	push(event);
+}
+function noteDestroy(state) {
+	if (!wants(state)) return;
+	push({
+		id: String(state),
+		type: labelOf(state.constructor),
+		key: "",
+		kind: "destroy"
+	});
+}
+function push(event) {
+	if (!open) {
+		const frame = {
+			seq: ++seq,
+			at: Date.now(),
+			events: []
+		};
+		if (cause !== void 0) frame.cause = cause;
+		open = frame;
+		frames.push(frame);
+		if (frames.length > FRAME_CAP) frames.splice(0, frames.length - FRAME_CAP);
+		queueMicrotask(() => {
+			open = void 0;
+			cause = frame.seq;
+			queueMicrotask(() => {
+				if (seq === frame.seq) cause = void 0;
+			});
+		});
+	}
+	open.events.push(event);
+}
+
+//#endregion
+//#region src/inspect.ts
+const Reaper = typeof FinalizationRegistry === "function" ? FinalizationRegistry : class {
+	register() {}
+	unregister() {}
+};
+const weak = (state) => typeof WeakRef === "function" ? new WeakRef(state) : { deref: () => state };
+const live = /* @__PURE__ */ new Map();
+const hooks = /* @__PURE__ */ new Map();
+const wrapped = /* @__PURE__ */ new WeakSet();
+const wrappers = /* @__PURE__ */ new WeakMap();
+const spans = /* @__PURE__ */ new WeakMap();
+const reaper = new Reaper(collected);
+let version = 0;
+let cached;
+let lost = 0;
+/** Registered instances still reachable, claimed or not. */
+function registered() {
+	return [...live.values()].map((row) => row.held ?? row.ref.deref()).filter((state) => !!state);
+}
+/** Instances on the mainline: claimed, or too young to judge, or every one when no host renders. */
+function* mainline() {
+	const parents = ownership();
+	for (const state of registered()) if (!orphaned(state, parents)) yield state;
+}
+function orphaned(state, parents, seen = /* @__PURE__ */ new Set()) {
+	const span = spans.get(state);
+	if (span.claimed || !span.settled || !hosted()) return false;
+	if (provided(state)) {
+		claim(state);
+		return false;
+	}
+	const owner = parents.get(state);
+	if (!owner || seen.has(owner)) return true;
+	seen.add(state);
+	if (orphaned(owner, parents, seen)) return true;
+	if (spans.get(owner).claimed) claim(state);
+	return false;
+}
+function claim(state) {
+	const span = spans.get(state);
+	if (span.claimed) return;
+	span.claimed = true;
+	const row = live.get(String(state));
+	if (row) {
+		row.held = state;
+		reaper.unregister(state);
+	}
+	version++;
+}
+/** A `static global` instance currently holding its slot in the root context. */
+function provided(state) {
+	const type = state.constructor;
+	if (!(typeof type.global === "function" ? type.global(state) : type.global)) return false;
+	for (const set of Context.root.provide.values()) if (set) {
+		for (const [member] of set) if (member === state) return true;
+	}
+	return false;
+}
+function hosted() {
+	try {
+		isElement(null);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** A registered, unclaimed instance was garbage collected - it was abandoned. */
+function collected(id) {
+	if (!live.delete(id)) return;
+	lost++;
+	version++;
+}
+/** Navigable view of one instance - identity, ownership, reads, observation. One per state; outlives it. */
+var Instance = class Instance {
+	constructor(state) {
+		this.state = state;
+	}
+	static of(state) {
+		let instance = wrappers.get(state);
+		if (!instance) wrappers.set(state, instance = new Instance(state));
+		return instance;
+	}
+	get id() {
+		return String(this.state);
+	}
+	get type() {
+		return seen(this.state.constructor).type;
+	}
+	get alive() {
+		return live.has(this.id);
+	}
+	/** Reached by a host commit (`mount`), a claimed owner, or `static global`. Always true without a host. */
+	get claimed() {
+		return !orphaned(this.state, ownership());
+	}
+	/** Registration time (ms). */
+	get since() {
+		return spans.get(this.state).since;
+	}
+	/** Destruction time (ms), once destroyed. */
+	get until() {
+		return spans.get(this.state).until;
+	}
+	get parent() {
+		const owner = ownership().get(this.state);
+		return owner && Instance.of(owner);
+	}
+	get children() {
+		const parents = ownership();
+		return [...registered()].filter((state) => parents.get(state) === this.state).map(Instance.of);
+	}
+	/** First instance in this subtree, depth-first, matching `where` (a label or predicate). */
+	find(where) {
+		const test = typeof where === "string" ? (h) => h.type === where : where;
+		for (const child of this.children) {
+			if (test(child)) return child;
+			const deep = child.find(test);
+			if (deep) return deep;
+		}
+	}
+	get(path) {
+		return serialize(walk(this.state, path));
+	}
+	model() {
+		return describe(this.state, ownership());
+	}
+	/** Run `work`, settle, and return the frames it produced. */
+	act(work) {
+		return act(() => work(this.state));
+	}
+	/** Call `fn` on each update, and with `null` on destroy; `keys` narrows updates. Returns unsubscribe. */
+	watch(fn, keys) {
+		const updates = this.state.set((key) => {
+			if (typeof key === "string" && (!keys || keys.includes(key))) fn(key);
+		});
+		const destroy = this.state.get(null, () => fn(null));
+		return () => {
+			updates();
+			destroy();
+		};
+	}
+	frames(query = {}) {
+		return journal.frames({
+			...query,
+			id: this.id
+		});
+	}
+};
+function attach(Type = State) {
+	if (!hooks.has(Type)) hooks.set(Type, Type.on(function() {
+		const self = this.is;
+		const id = String(self);
+		const span = {
+			since: Date.now(),
+			claimed: false,
+			settled: false
+		};
+		seen(self.constructor);
+		live.set(id, { ref: weak(self) });
+		spans.set(self, span);
+		reaper.register(self, id, self);
+		setTimeout(() => {
+			span.settled = true;
+		}, 0);
+		version++;
+		if (recordsCalls()) wrap(self);
+		mounts(self);
+		const stop = self.set((key) => {
+			const store = entries(self);
+			if (typeof key === "string" && typeof store.get(key) === "object") version++;
+			note(self, key, store);
+		});
+		return () => {
+			stop();
+			live.delete(id);
+			reaper.unregister(self);
+			span.until = Date.now();
+			version++;
+			noteDestroy(self);
+		};
+	}));
+	return () => {
+		hooks.get(Type)?.();
+		hooks.delete(Type);
+	};
+}
+function detach() {
+	for (const stop of hooks.values()) stop();
+	hooks.clear();
+	live.clear();
+	cached = void 0;
+	lost = 0;
+	journal.reset();
+	forget();
+}
+/** Resolve an id or label to an instance - mainline first, then orphans. */
+function find(target) {
+	const byId = live.get(target);
+	const held = byId && (byId.held ?? byId.ref.deref());
+	if (held) return Instance.of(held);
+	for (const pool of [mainline(), abandoned()]) for (const state of pool) if (seen(state.constructor).type === target) return Instance.of(state);
+}
+function instances() {
+	return [...mainline()].map(Instance.of);
+}
+/** Registered and settled, but never claimed by a host commit, an owner, or root context. */
+function orphans() {
+	return [...abandoned()].map(Instance.of);
+}
+function* abandoned() {
+	const parents = ownership();
+	for (const state of registered()) if (orphaned(state, parents)) yield state;
+}
+/** Counts worth a look: live orphans, and unclaimed instances the collector already reaped. */
+function warnings() {
+	return {
+		orphans: orphans().length,
+		collected: lost
+	};
+}
+function roots() {
+	const parents = ownership();
+	return instances().filter((instance) => !parents.has(instance.state));
+}
+function models() {
+	const parents = ownership();
+	return [...mainline()].map((state) => describe(state, parents));
+}
+function tree() {
+	const parents = ownership();
+	const nodes = /* @__PURE__ */ new Map();
+	const out = [];
+	for (const state of mainline()) nodes.set(state, {
+		id: String(state),
+		type: seen(state.constructor).type,
+		children: []
+	});
+	for (const [state, node] of nodes) {
+		const parent = parents.get(state);
+		const owner = parent && nodes.get(parent);
+		if (owner) owner.children.push(node);
+		else out.push(node);
+	}
+	return out;
+}
+function get(address) {
+	if (!address) return models();
+	const { target, path } = parsePath(address);
+	return find(target)?.get(path);
+}
+function set(address, value) {
+	const { target, path } = parsePath(address);
+	const instance = find(target);
+	if (!instance || !path) throw new Error(`No model at ${address}.`);
+	const dot = path.lastIndexOf(".");
+	const key = path.slice(dot + 1);
+	const owner = dot < 0 ? instance.state : walk(instance.state, path.slice(0, dot));
+	if (owner == null || typeof owner !== "object") throw new Error(`No model at ${address}.`);
+	if (owner instanceof Map) owner.set(key, value);
+	else owner[key] = value;
+}
+async function call(address, ...args) {
+	const { target, path } = parsePath(address);
+	const state = find(target)?.state;
+	const method = state && path && state[path];
+	if (typeof method !== "function") throw new Error(`No method at ${address}.`);
+	return serialize(await method.apply(state, args));
+}
+function wrapAll() {
+	for (const state of registered()) wrap(state);
+}
+/** Observe the host commit: adapters call `mount?.()` once an instance is placed. */
+function mounts(state) {
+	const target = state;
+	const original = target.mount;
+	Object.defineProperty(target, "mount", {
+		configurable: true,
+		writable: true,
+		value(...args) {
+			claim(state);
+			return typeof original === "function" ? original.apply(this, args) : void 0;
+		}
+	});
+}
+function describe(state, parents) {
+	const stored = entries(state);
+	const declared = Object.entries(Object.getOwnPropertyDescriptors(state)).filter(([, desc]) => typeof desc.get === "function").map(([key]) => key);
+	const model = {
+		id: String(state),
+		...seen(state.constructor),
+		keys: [...stored.keys()],
+		absent: declared.filter((key) => !stored.has(key))
+	};
+	const parent = parents.get(state);
+	if (parent) model.parent = String(parent);
+	return model;
+}
+function wrap(state) {
+	if (wrapped.has(state)) return;
+	wrapped.add(state);
+	const target = state;
+	const seenKeys = new Set(["render"]);
+	for (let proto = Object.getPrototypeOf(state); proto !== State.prototype; proto = Object.getPrototypeOf(proto)) for (const [key, desc] of Object.entries(Object.getOwnPropertyDescriptors(proto))) {
+		if (seenKeys.has(key) || typeof desc.get !== "function" || desc.get !== desc.set) continue;
+		seenKeys.add(key);
+		const original = target[key];
+		target[key] = function(...args) {
+			noteCall(state, key, args);
+			return original.apply(this, args);
+		};
+	}
+}
+function ownership() {
+	if (cached?.version !== version) {
+		const parents = /* @__PURE__ */ new Map();
+		for (const owner of registered()) for (const [key, value] of entries(owner)) if (Object.getOwnPropertyDescriptor(owner, key)?.enumerable || !(value instanceof State)) own(parents, owner, value);
+		cached = {
+			version,
+			parents
+		};
+	}
+	return cached.parents;
+}
+function own(parents, owner, value) {
+	if (value instanceof State) {
+		if (!parents.has(value) && value !== owner) parents.set(value, owner);
+	} else if (value && typeof value === "object" && Symbol.iterator in value) {
+		const items = value instanceof Map ? value.values() : value;
+		for (const item of items) if (item instanceof State) own(parents, owner, item);
+	}
+}
+
+//#endregion
+export { label as _, find as a, serialize as b, models as c, set as d, tree as f, journal as g, act as h, detach as i, orphans as l, wrapAll as m, attach as n, get as o, warnings as p, call as r, instances as s, Instance as t, roots as u, resolve as v, parsePath as y };
+//# sourceMappingURL=inspect-D4NC5Mx5.js.map

package/dist/inspect-D4NC5Mx5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect-D4NC5Mx5.js","names":["run"],"sources":["../src/serialize.ts","../src/types.ts","../src/journal.ts","../src/inspect.ts"],"sourcesContent":["import { State } from '@expressive/mvc';\n\nconst MAX_STRING = 240;\nconst MAX_ARRAY = 24;\nconst MAX_KEYS = 40;\n\nexport type Address = { target: string; path?: string };\n\nexport function parsePath(raw: string): Address {\n  const trimmed = raw.trim();\n  const dot = trimmed.indexOf('.');\n  if (dot <= 0) return { target: trimmed };\n  return { target: trimmed.slice(0, dot), path: trimmed.slice(dot + 1) };\n}\n\n/** Raw stored entries of a State - never reads through accessors. */\nexport function entries(state: State): Map<string, unknown> {\n  return new Map(state);\n}\n\n/** Walk `path` without triggering getters, factories, or suspense. */\nexport function walk(value: unknown, path?: string): unknown {\n  if (!path) return value;\n  let cur: unknown = value;\n  for (const part of path.split('.')) {\n    if (cur == null || typeof cur !== 'object') return undefined;\n    if (cur instanceof State) cur = entries(cur).get(part);\n    else if (cur instanceof Map) cur = cur.get(part);\n    else cur = (cur as Record<string, unknown>)[part];\n  }\n  return cur;\n}\n\nexport function ref(state: State) {\n  return { $ref: String(state), $type: state.constructor.name };\n}\n\n/** JSON-safe, size-capped view. Nested States collapse to `$ref`. */\nexport function serialize(value: unknown, depth = 2): unknown {\n  if (value instanceof State) {\n    const out: Record<string, unknown> = ref(value);\n    for (const [key, child] of [...entries(value)].slice(0, MAX_KEYS))\n      out[key] = write(child, depth - 1);\n    return out;\n  }\n  return write(value, depth);\n}\n\nfunction write(value: unknown, depth: number): unknown {\n  if (value == null || typeof value === 'boolean') return value;\n  if (typeof value === 'number') return Number.isFinite(value) ? value : String(value);\n  if (typeof value === 'string')\n    return value.length > MAX_STRING ? `${value.slice(0, MAX_STRING - 1)}…` : value;\n  if (typeof value === 'bigint') return `${value}n`;\n  if (typeof value !== 'object') return undefined;\n  if (value instanceof State) return ref(value);\n  if (value instanceof Date) return value.toISOString();\n  if (value instanceof Error) return { name: value.name, message: value.message };\n  if (typeof (value as PromiseLike<unknown>).then === 'function') return '(pending)';\n\n  const items = list(value);\n\n  if (items) {\n    if (depth <= 0) return `[${items.length}]`;\n    const out = items.slice(0, MAX_ARRAY).map((row) => write(row, depth - 1));\n    if (items.length > MAX_ARRAY) out.push(`…+${items.length - MAX_ARRAY}`);\n    return out;\n  }\n\n  const pairs = value instanceof Map\n    ? [...value].map(([k, v]) => [String(k), v] as const)\n    : Object.entries(value);\n\n  if (depth <= 0) return `{${pairs.length}}`;\n\n  const out: Record<string, unknown> = {};\n  for (const [key, child] of pairs.slice(0, MAX_KEYS)) {\n    if (key === 'is') continue;\n    const next = write(child, depth - 1);\n    if (next !== undefined) out[key] = next;\n  }\n  if (pairs.length > MAX_KEYS) out['…'] = pairs.length - MAX_KEYS;\n  return out;\n}\n\nfunction list(value: object): unknown[] | undefined {\n  if (Array.isArray(value)) return value;\n  if (value instanceof Map) return undefined;\n  if (typeof (value as Iterable<unknown>)[Symbol.iterator] === 'function')\n    return [...(value as Iterable<unknown>)];\n  return undefined;\n}\n","import { State } from '@expressive/mvc';\n\nexport interface TypeInfo {\n  /** Opaque, stable for the life of the process. */\n  typeId: string;\n  /** Resolved display name - see `label`. */\n  type: string;\n  /** Construction stack captured at first sight, for a source-map resolver. */\n  site: string;\n}\n\nconst info = new Map<typeof State, TypeInfo>();\nconst labels = new Map<typeof State, string>();\nconst names = new Map<string, string>();\nlet count = 0;\n\nfunction register(Type: typeof State): TypeInfo {\n  let row = info.get(Type);\n  if (!row) {\n    const site = String(new Error().stack).split('\\n').slice(1, 16).join('\\n');\n    info.set(Type, (row = { typeId: `T${++count}`, type: '', site }));\n  }\n  return row;\n}\n\nexport function seen(Type: typeof State): TypeInfo {\n  const row = register(Type);\n  row.type = labelOf(Type);\n  return { ...row };\n}\n\nexport function labelOf(Type: typeof State): string {\n  const row = register(Type);\n  const explicit = labels.get(Type) ?? (Type as { displayName?: string }).displayName;\n  if (explicit) return explicit;\n  const named = names.get(row.typeId) ?? names.get(row.site);\n  if (named) return named;\n  return Type.name.length > 2 ? Type.name : row.typeId;\n}\n\nexport function label(Type: typeof State, name: string): void {\n  labels.set(Type, name);\n}\n\n/** Supply resolved names keyed by `typeId` or `site`, e.g. from a source-map pass. */\nexport function resolve(table: Record<string, string>): void {\n  for (const [key, name] of Object.entries(table)) names.set(key, name);\n}\n\nexport function forget(): void {\n  info.clear();\n  labels.clear();\n  names.clear();\n  count = 0;\n}\n","import { State } from '@expressive/mvc';\n\nimport { parsePath, serialize } from './serialize';\nimport { labelOf, seen } from './types';\n\nexport type Level = 'off' | 'keys' | 'values';\n\nexport interface Options {\n  level?: Level;\n  /** Labels to record. */\n  types?: string[];\n  /** `Type.key` addresses to record - label, `typeId`, or instance id on the left, property on the right. */\n  paths?: string[];\n  /** Property names to record on any type. */\n  keys?: string[];\n  /** Also record method calls (wraps instance methods except `render`). */\n  calls?: boolean;\n}\n\nexport interface Event {\n  id: string;\n  type: string;\n  key: string;\n  kind: 'update' | 'event' | 'call' | 'destroy';\n  value?: unknown;\n  args?: unknown[];\n}\n\nexport interface Frame {\n  seq: number;\n  at: number;\n  /** Frame whose flush scheduled the work that opened this one. */\n  cause?: number;\n  events: Event[];\n}\n\nexport interface Query {\n  since?: number;\n  type?: string;\n  id?: string;\n  key?: string;\n  cause?: number;\n}\n\nconst FRAME_CAP = 500;\n\nconst frames: Frame[] = [];\nconst config: Required<Options> = { level: 'off', types: [], paths: [], keys: [], calls: false };\nlet seq = 0;\nlet open: Frame | undefined;\nlet cause: number | undefined;\n\nexport const journal = {\n  record(options: Options = {}): Required<Options> {\n    Object.assign(config, options);\n    if (!options.level && options.calls && config.level === 'off') config.level = 'keys';\n    return { ...config, types: [...config.types], paths: [...config.paths], keys: [...config.keys] };\n  },\n\n  frames(query: Query = {}): Frame[] {\n    const out: Frame[] = [];\n    for (const frame of frames) {\n      if (query.since !== undefined && frame.seq <= query.since) continue;\n      if (query.cause !== undefined && frame.cause !== query.cause) continue;\n      const events = frame.events.filter((e) => matches(e, query));\n      if (events.length) out.push({ ...frame, events });\n    }\n    return out;\n  },\n\n  history(query: Query): Array<{ seq: number; at: number; event: Event }> {\n    const out = [];\n    for (const frame of journal.frames(query))\n      for (const event of frame.events) out.push({ seq: frame.seq, at: frame.at, event });\n    return out;\n  },\n\n  /** Frames reachable from `seq` through `cause` links, in order. */\n  downstream(from: number): Frame[] {\n    const roots = new Set([from]);\n    return frames.filter((frame) => {\n      if (frame.cause === undefined || !roots.has(frame.cause)) return false;\n      roots.add(frame.seq);\n      return true;\n    });\n  },\n\n  /** Current sequence - pass as `since` to read only what follows. */\n  seq(): number {\n    return seq;\n  },\n\n  /** One event per line, for bulk export to a sidecar. */\n  export(query: Query = {}): string {\n    return journal\n      .frames(query)\n      .flatMap((frame) =>\n        frame.events.map((event) =>\n          JSON.stringify({ seq: frame.seq, at: frame.at, cause: frame.cause, ...event })\n        )\n      )\n      .join('\\n');\n  },\n\n  clear(): void {\n    frames.length = 0;\n    open = undefined;\n    cause = undefined;\n    seq = 0;\n  },\n\n  reset(): void {\n    journal.clear();\n    Object.assign(config, { level: 'off', types: [], paths: [], keys: [], calls: false });\n  }\n};\n\nfunction matches(event: Event, query: Query) {\n  return (\n    (!query.type || event.type === query.type) &&\n    (!query.id || event.id === query.id) &&\n    (!query.key || event.key === query.key)\n  );\n}\n\n/** Filters OR together; none set records everything. Without a key only type-level filters apply. */\nexport function wants(state: State, key?: string): boolean {\n  if (config.level === 'off') return false;\n\n  const { types, paths, keys } = config;\n  if (!types.length && !paths.length && !keys.length) return true;\n\n  const Type = state.constructor as typeof State;\n  const label = labelOf(Type);\n  if (types.includes(label)) return true;\n  if (key !== undefined && keys.includes(key)) return true;\n\n  const targets = [label, seen(Type).typeId, String(state)];\n  for (const address of paths) {\n    const { target, path } = parsePath(address);\n    if (targets.includes(target) && (key === undefined || path === key)) return true;\n  }\n  return false;\n}\n\nexport function recordsCalls(): boolean {\n  return config.calls && config.level !== 'off';\n}\n\n/** Run `work` with recording forced on; returns the frames it produced. */\nexport async function act(work: () => unknown): Promise<Frame[]> {\n  const level = config.level;\n  const start = seq;\n  if (level === 'off') config.level = 'values';\n  try {\n    await work();\n    await new Promise((resolve) => setTimeout(resolve, 0));\n  } finally {\n    config.level = level;\n  }\n  return journal.frames({ since: start });\n}\n\nexport function note(state: State, key: unknown, store: Map<string, unknown>): void {\n  const name = String(key);\n  if (!wants(state, name)) return;\n\n  const event: Event = {\n    id: String(state),\n    type: labelOf(state.constructor as typeof State),\n    key: name,\n    kind: typeof key === 'string' && store.has(key) ? 'update' : 'event'\n  };\n\n  if (config.level === 'values' && event.kind === 'update')\n    event.value = serialize(store.get(name), 1);\n\n  push(event);\n}\n\nexport function noteCall(state: State, key: string, args: unknown[]): void {\n  if (!recordsCalls() || !wants(state, key)) return;\n\n  const event: Event = { id: String(state), type: labelOf(state.constructor as typeof State), key, kind: 'call' };\n  if (config.level === 'values') event.args = args.map((arg) => serialize(arg, 1));\n  push(event);\n}\n\nexport function noteDestroy(state: State): void {\n  if (!wants(state)) return;\n  push({ id: String(state), type: labelOf(state.constructor as typeof State), key: '', kind: 'destroy' });\n}\n\nfunction push(event: Event) {\n  if (!open) {\n    const frame: Frame = { seq: ++seq, at: Date.now(), events: [] };\n    if (cause !== undefined) frame.cause = cause;\n    open = frame;\n    frames.push(frame);\n    if (frames.length > FRAME_CAP) frames.splice(0, frames.length - FRAME_CAP);\n    queueMicrotask(() => {\n      open = undefined;\n      cause = frame.seq;\n      queueMicrotask(() => {\n        if (seq === frame.seq) cause = undefined;\n      });\n    });\n  }\n  open.events.push(event);\n}\n","import { Context, State } from '@expressive/mvc';\nimport { isElement } from '@expressive/mvc/runtime';\n\nimport { act as run, journal, note, noteCall, noteDestroy, recordsCalls, type Frame, type Query } from './journal';\nimport { entries, parsePath, serialize, walk } from './serialize';\nimport { forget, seen, type TypeInfo } from './types';\n\nexport interface Model extends TypeInfo {\n  id: string;\n  parent?: string;\n  /** Keys with a stored value. */\n  keys: string[];\n  /** Declared keys with no stored value yet - lazy, pending, or uncomputed. */\n  absent: string[];\n}\n\nexport interface Node {\n  id: string;\n  type: string;\n  children: Node[];\n}\n\ninterface Span {\n  since: number;\n  until?: number;\n  claimed: boolean;\n  settled: boolean;\n}\n\ninterface Row {\n  ref: { deref(): State | undefined };\n  held?: State;\n}\n\nconst Reaper: typeof FinalizationRegistry =\n  typeof FinalizationRegistry === 'function'\n    ? FinalizationRegistry\n    : (class {\n        register() {}\n        unregister() {}\n      } as unknown as typeof FinalizationRegistry);\n\nconst weak = (state: State): Row['ref'] =>\n  typeof WeakRef === 'function' ? new WeakRef(state) : { deref: () => state };\n\nconst live = new Map<string, Row>();\nconst hooks = new Map<typeof State, () => boolean>();\nconst wrapped = new WeakSet<State>();\nconst wrappers = new WeakMap<State, Instance>();\nconst spans = new WeakMap<State, Span>();\nconst reaper = new Reaper<string>(collected);\n\nlet version = 0;\nlet cached: { version: number; parents: Map<State, State> } | undefined;\nlet lost = 0;\n\n/** Registered instances still reachable, claimed or not. */\nfunction registered(): State[] {\n  return [...live.values()]\n    .map((row) => row.held ?? row.ref.deref())\n    .filter((state): state is State => !!state);\n}\n\n/** Instances on the mainline: claimed, or too young to judge, or every one when no host renders. */\nfunction* mainline(): Generator<State> {\n  const parents = ownership();\n  for (const state of registered()) if (!orphaned(state, parents)) yield state;\n}\n\nfunction orphaned(state: State, parents: Map<State, State>, seen = new Set<State>()): boolean {\n  const span = spans.get(state)!;\n  if (span.claimed || !span.settled || !hosted()) return false;\n  if (provided(state)) {\n    claim(state);\n    return false;\n  }\n  const owner = parents.get(state);\n  if (!owner || seen.has(owner)) return true;\n  seen.add(state);\n  if (orphaned(owner, parents, seen)) return true;\n  if (spans.get(owner)!.claimed) claim(state);\n  return false;\n}\n\nfunction claim(state: State) {\n  const span = spans.get(state)!;\n  if (span.claimed) return;\n  span.claimed = true;\n  const row = live.get(String(state));\n  if (row) {\n    row.held = state;\n    reaper.unregister(state);\n  }\n  version++;\n}\n\n/** A `static global` instance currently holding its slot in the root context. */\nfunction provided(state: State): boolean {\n  const type = state.constructor as typeof State;\n  const global = typeof type.global === 'function' ? type.global(state) : type.global;\n  if (!global) return false;\n  for (const set of Context.root.provide.values())\n    if (set) for (const [member] of set) if (member === state) return true;\n  return false;\n}\n\nfunction hosted(): boolean {\n  try {\n    isElement(null);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/** A registered, unclaimed instance was garbage collected - it was abandoned. */\nexport function collected(id: string): void {\n  if (!live.delete(id)) return;\n  lost++;\n  version++;\n}\n\n/** Navigable view of one instance - identity, ownership, reads, observation. One per state; outlives it. */\nexport class Instance {\n  private constructor(readonly state: State) {}\n\n  static of(state: State): Instance {\n    let instance = wrappers.get(state);\n    if (!instance) wrappers.set(state, (instance = new Instance(state)));\n    return instance;\n  }\n\n  get id() {\n    return String(this.state);\n  }\n\n  get type() {\n    return seen(this.state.constructor as typeof State).type;\n  }\n\n  get alive() {\n    return live.has(this.id);\n  }\n\n  /** Reached by a host commit (`mount`), a claimed owner, or `static global`. Always true without a host. */\n  get claimed() {\n    return !orphaned(this.state, ownership());\n  }\n\n  /** Registration time (ms). */\n  get since() {\n    return spans.get(this.state)!.since;\n  }\n\n  /** Destruction time (ms), once destroyed. */\n  get until() {\n    return spans.get(this.state)!.until;\n  }\n\n  get parent(): Instance | undefined {\n    const owner = ownership().get(this.state);\n    return owner && Instance.of(owner);\n  }\n\n  get children(): Instance[] {\n    const parents = ownership();\n    return [...registered()]\n      .filter((state) => parents.get(state) === this.state)\n      .map(Instance.of);\n  }\n\n  /** First instance in this subtree, depth-first, matching `where` (a label or predicate). */\n  find(where: string | ((instance: Instance) => boolean)): Instance | undefined {\n    const test = typeof where === 'string' ? (h: Instance) => h.type === where : where;\n    for (const child of this.children) {\n      if (test(child)) return child;\n      const deep = child.find(test);\n      if (deep) return deep;\n    }\n    return undefined;\n  }\n\n  get(path?: string): unknown {\n    return serialize(walk(this.state, path));\n  }\n\n  model(): Model {\n    return describe(this.state, ownership());\n  }\n\n  /** Run `work`, settle, and return the frames it produced. */\n  act(work: (state: State) => unknown): Promise<Frame[]> {\n    return run(() => work(this.state));\n  }\n\n  /** Call `fn` on each update, and with `null` on destroy; `keys` narrows updates. Returns unsubscribe. */\n  watch(fn: (key: string | null) => void, keys?: string[]): () => void {\n    const updates = this.state.set((key) => {\n      if (typeof key === 'string' && (!keys || keys.includes(key))) fn(key);\n    });\n    const destroy = this.state.get(null, () => fn(null));\n    return () => {\n      updates();\n      destroy();\n    };\n  }\n\n  frames(query: Query = {}): Frame[] {\n    return journal.frames({ ...query, id: this.id });\n  }\n}\n\nexport function attach(Type: typeof State = State): () => void {\n  if (!hooks.has(Type))\n    hooks.set(\n      Type,\n      Type.on(function (this: State) {\n        const self = this.is;\n        const id = String(self);\n        const span: Span = { since: Date.now(), claimed: false, settled: false };\n        seen(self.constructor as typeof State);\n        live.set(id, { ref: weak(self) });\n        spans.set(self, span);\n        reaper.register(self, id, self);\n        setTimeout(() => {\n          span.settled = true;\n        }, 0);\n        version++;\n        if (recordsCalls()) wrap(self);\n        mounts(self);\n        const stop = self.set((key) => {\n          const store = entries(self);\n          if (typeof key === 'string' && typeof store.get(key) === 'object') version++;\n          note(self, key, store);\n        });\n        return () => {\n          stop();\n          live.delete(id);\n          reaper.unregister(self);\n          span.until = Date.now();\n          version++;\n          noteDestroy(self);\n        };\n      })\n    );\n\n  return () => {\n    hooks.get(Type)?.();\n    hooks.delete(Type);\n  };\n}\n\nexport function detach(): void {\n  for (const stop of hooks.values()) stop();\n  hooks.clear();\n  live.clear();\n  cached = undefined;\n  lost = 0;\n  journal.reset();\n  forget();\n}\n\n/** Resolve an id or label to an instance - mainline first, then orphans. */\nexport function find(target: string): Instance | undefined {\n  const byId = live.get(target);\n  const held = byId && (byId.held ?? byId.ref.deref());\n  if (held) return Instance.of(held);\n  for (const pool of [mainline(), abandoned()])\n    for (const state of pool)\n      if (seen(state.constructor as typeof State).type === target) return Instance.of(state);\n  return undefined;\n}\n\nexport function instances(): Instance[] {\n  return [...mainline()].map(Instance.of);\n}\n\n/** Registered and settled, but never claimed by a host commit, an owner, or root context. */\nexport function orphans(): Instance[] {\n  return [...abandoned()].map(Instance.of);\n}\n\nfunction* abandoned(): Generator<State> {\n  const parents = ownership();\n  for (const state of registered()) if (orphaned(state, parents)) yield state;\n}\n\n/** Counts worth a look: live orphans, and unclaimed instances the collector already reaped. */\nexport function warnings(): { orphans: number; collected: number } {\n  return { orphans: orphans().length, collected: lost };\n}\n\nexport function roots(): Instance[] {\n  const parents = ownership();\n  return instances().filter((instance) => !parents.has(instance.state));\n}\n\nexport function models(): Model[] {\n  const parents = ownership();\n  return [...mainline()].map((state) => describe(state, parents));\n}\n\nexport function tree(): Node[] {\n  const parents = ownership();\n  const nodes = new Map<State, Node>();\n  const out: Node[] = [];\n\n  for (const state of mainline())\n    nodes.set(state, { id: String(state), type: seen(state.constructor as typeof State).type, children: [] });\n\n  for (const [state, node] of nodes) {\n    const parent = parents.get(state);\n    const owner = parent && nodes.get(parent);\n    if (owner) owner.children.push(node);\n    else out.push(node);\n  }\n\n  return out;\n}\n\nexport function get(address?: string): unknown {\n  if (!address) return models();\n  const { target, path } = parsePath(address);\n  return find(target)?.get(path);\n}\n\nexport function set(address: string, value: unknown): void {\n  const { target, path } = parsePath(address);\n  const instance = find(target);\n  if (!instance || !path) throw new Error(`No model at ${address}.`);\n\n  const dot = path.lastIndexOf('.');\n  const key = path.slice(dot + 1);\n  const owner = dot < 0 ? instance.state : walk(instance.state, path.slice(0, dot));\n\n  if (owner == null || typeof owner !== 'object') throw new Error(`No model at ${address}.`);\n\n  if (owner instanceof Map) owner.set(key, value);\n  else (owner as Record<string, unknown>)[key] = value;\n}\n\nexport async function call(address: string, ...args: unknown[]): Promise<unknown> {\n  const { target, path } = parsePath(address);\n  const state = find(target)?.state;\n  const method = state && path && (state as unknown as Record<string, unknown>)[path];\n\n  if (typeof method !== 'function') throw new Error(`No method at ${address}.`);\n\n  return serialize(await method.apply(state, args));\n}\n\nexport function wrapAll(): void {\n  for (const state of registered()) wrap(state);\n}\n\n/** Observe the host commit: adapters call `mount?.()` once an instance is placed. */\nfunction mounts(state: State) {\n  const target = state as State & { mount?: (...args: unknown[]) => unknown };\n  const original = target.mount;\n\n  Object.defineProperty(target, 'mount', {\n    configurable: true,\n    writable: true,\n    value(this: unknown, ...args: unknown[]) {\n      claim(state);\n      return typeof original === 'function' ? original.apply(this, args) : undefined;\n    }\n  });\n}\n\nfunction describe(state: State, parents: Map<State, State>): Model {\n  const stored = entries(state);\n  const declared = Object.entries(Object.getOwnPropertyDescriptors(state))\n    .filter(([, desc]) => typeof desc.get === 'function')\n    .map(([key]) => key);\n  const model: Model = {\n    id: String(state),\n    ...seen(state.constructor as typeof State),\n    keys: [...stored.keys()],\n    absent: declared.filter((key) => !stored.has(key))\n  };\n  const parent = parents.get(state);\n  if (parent) model.parent = String(parent);\n  return model;\n}\n\nfunction wrap(state: State) {\n  if (wrapped.has(state)) return;\n  wrapped.add(state);\n\n  const target = state as unknown as Record<string, Function>;\n  const seenKeys = new Set<string>(['render']);\n\n  for (let proto = Object.getPrototypeOf(state); proto !== State.prototype; proto = Object.getPrototypeOf(proto))\n    for (const [key, desc] of Object.entries(Object.getOwnPropertyDescriptors(proto))) {\n      if (seenKeys.has(key) || typeof desc.get !== 'function' || desc.get !== desc.set) continue;\n\n      seenKeys.add(key);\n\n      const original = target[key];\n\n      target[key] = function (this: unknown, ...args: unknown[]) {\n        noteCall(state, key, args);\n        return original.apply(this, args);\n      };\n    }\n}\n\nfunction ownership(): Map<State, State> {\n  if (cached?.version !== version) {\n    const parents = new Map<State, State>();\n\n    for (const owner of registered())\n      for (const [key, value] of entries(owner)) {\n        const field = Object.getOwnPropertyDescriptor(owner, key)?.enumerable;\n        if (field || !(value instanceof State)) own(parents, owner, value);\n      }\n\n    cached = { version, parents };\n  }\n\n  return cached.parents;\n}\n\nfunction own(parents: Map<State, State>, owner: State, value: unknown) {\n  if (value instanceof State) {\n    if (!parents.has(value) && value !== owner) parents.set(value, owner);\n  } else if (value && typeof value === 'object' && Symbol.iterator in value) {\n    const items = value instanceof Map ? value.values() : (value as Iterable<unknown>);\n    for (const item of items) if (item instanceof State) own(parents, owner, item);\n  }\n}\n"],"mappings":"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"}

package/dist/install.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/install.js

@@ -0,0 +1,10 @@
+import { n as attach } from "./inspect-D4NC5Mx5.js";
+import inspect from "./index.js";
+
+//#region src/install.ts
+attach();
+globalThis.__EXPRESSIVE_INSPECT__ = inspect;
+
+//#endregion
+export {  };
+//# sourceMappingURL=install.js.map

package/dist/install.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.js","names":[],"sources":["../src/install.ts"],"sourcesContent":["import { attach, inspect } from './index';\n\nattach();\n\nglobalThis.__EXPRESSIVE_INSPECT__ = inspect;\n"],"mappings":";;;;AAEA,QAAQ;AAER,WAAW,yBAAyB"}

package/dist/playwright.d.ts

@@ -0,0 +1,33 @@
+import { S as Frame, T as Query, w as Options } from "./serialize-FF81tr-L.js";
+import inspect$1 from "./index.js";
+
+//#region src/playwright.d.ts
+/**
+ * Anything that can run a function in the page: Playwright `Page`, `Frame`, or
+ * `Locator` (which passes the element first), puppeteer `Page` or `Frame`.
+ */
+interface Evaluates {
+  evaluate(fn: (...args: any[]) => unknown, arg?: unknown): Promise<unknown>;
+}
+/**
+ * Drive the page's inspector from a test. Every method is one `evaluate`;
+ * `around` brackets a step with the journal forced on and returns its frames.
+ */
+declare function inspect(target: Evaluates): {
+  get: (address?: string) => Promise<unknown>;
+  set: (address: string, value: unknown) => Promise<void>;
+  call: (address: string, ...args: unknown[]) => Promise<unknown>;
+  models: () => Promise<ReturnType<typeof inspect$1.models>>;
+  tree: () => Promise<ReturnType<typeof inspect$1.tree>>;
+  journal: {
+    record: (options?: Options) => Promise<Required<Options>>;
+    seq: () => Promise<number>;
+    frames: (query?: Query) => Promise<Frame[]>;
+    history: (query: Query) => Promise<ReturnType<typeof inspect$1.journal.history>>;
+    clear: () => Promise<void>;
+  };
+  around(step: () => unknown): Promise<Frame[]>;
+};
+//#endregion
+export { Evaluates, inspect };
+//# sourceMappingURL=playwright.d.ts.map

package/dist/playwright.js

@@ -0,0 +1,53 @@
+//#region src/playwright.ts
+function bridge(first, second) {
+	const call = second ?? first;
+	const api = globalThis.__EXPRESSIVE_INSPECT__;
+	if (!api) throw new Error("@expressive/inspect is not attached in this page - make '@expressive/inspect/install' the first import of the app entry.");
+	let target = api;
+	let owner;
+	for (const key of call[0]) {
+		owner = target;
+		target = target[key];
+	}
+	return target.apply(owner, call[1]);
+}
+/**
+* Drive the page's inspector from a test. Every method is one `evaluate`;
+* `around` brackets a step with the journal forced on and returns its frames.
+*/
+function inspect(target) {
+	const remote = (...path) => (...args) => target.evaluate(bridge, [path, args]);
+	const record = remote("journal", "record");
+	const seq = remote("journal", "seq");
+	const frames = remote("journal", "frames");
+	return {
+		get: remote("get"),
+		set: remote("set"),
+		call: remote("call"),
+		models: remote("models"),
+		tree: remote("tree"),
+		journal: {
+			record,
+			seq,
+			frames,
+			history: remote("journal", "history"),
+			clear: remote("journal", "clear")
+		},
+		async around(step) {
+			const before = await record();
+			const since = await seq();
+			if (before.level === "off") await record({ level: "values" });
+			try {
+				await step();
+				await target.evaluate(() => new Promise((resolve) => setTimeout(resolve, 0)));
+				return await frames({ since });
+			} finally {
+				if (before.level === "off") await record({ level: "off" });
+			}
+		}
+	};
+}
+
+//#endregion
+export { inspect };
+//# sourceMappingURL=playwright.js.map

package/dist/playwright.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"playwright.js","names":[],"sources":["../src/playwright.ts"],"sourcesContent":["import type { inspect as Inspect } from './index';\nimport type { Frame, Options, Query } from './journal';\n\n/**\n * Anything that can run a function in the page: Playwright `Page`, `Frame`, or\n * `Locator` (which passes the element first), puppeteer `Page` or `Frame`.\n */\nexport interface Evaluates {\n  evaluate(fn: (...args: any[]) => unknown, arg?: unknown): Promise<unknown>;\n}\n\ntype Call = [path: string[], args: unknown[]];\n\nfunction bridge(first: unknown, second?: unknown) {\n  const call = (second ?? first) as Call;\n  const api = (globalThis as { __EXPRESSIVE_INSPECT__?: Record<string, unknown> }).__EXPRESSIVE_INSPECT__;\n\n  if (!api)\n    throw new Error(\n      \"@expressive/inspect is not attached in this page - make '@expressive/inspect/install' the first import of the app entry.\"\n    );\n\n  let target: unknown = api;\n  let owner: unknown;\n\n  for (const key of call[0]) {\n    owner = target;\n    target = (target as Record<string, unknown>)[key];\n  }\n\n  return (target as Function).apply(owner, call[1]);\n}\n\n/**\n * Drive the page's inspector from a test. Every method is one `evaluate`;\n * `around` brackets a step with the journal forced on and returns its frames.\n */\nexport function inspect(target: Evaluates) {\n  const remote =\n    <R>(...path: string[]) =>\n    (...args: unknown[]) =>\n      target.evaluate(bridge, [path, args] as Call) as Promise<R>;\n\n  const record = remote<Required<Options>>('journal', 'record');\n  const seq = remote<number>('journal', 'seq');\n  const frames = remote<Frame[]>('journal', 'frames');\n\n  return {\n    get: remote<unknown>('get') as (address?: string) => Promise<unknown>,\n    set: remote<void>('set') as (address: string, value: unknown) => Promise<void>,\n    call: remote<unknown>('call') as (address: string, ...args: unknown[]) => Promise<unknown>,\n    models: remote<ReturnType<typeof Inspect.models>>('models') as () => Promise<ReturnType<typeof Inspect.models>>,\n    tree: remote<ReturnType<typeof Inspect.tree>>('tree') as () => Promise<ReturnType<typeof Inspect.tree>>,\n\n    journal: {\n      record: record as (options?: Options) => Promise<Required<Options>>,\n      seq: seq as () => Promise<number>,\n      frames: frames as (query?: Query) => Promise<Frame[]>,\n      history: remote<ReturnType<typeof Inspect.journal.history>>('journal', 'history') as (\n        query: Query\n      ) => Promise<ReturnType<typeof Inspect.journal.history>>,\n      clear: remote<void>('journal', 'clear') as () => Promise<void>\n    },\n\n    async around(step: () => unknown): Promise<Frame[]> {\n      const before = await record();\n      const since = await seq();\n\n      if (before.level === 'off') await record({ level: 'values' });\n\n      try {\n        await step();\n        await target.evaluate(() => new Promise((resolve) => setTimeout(resolve, 0)));\n        return await frames({ since });\n      } finally {\n        if (before.level === 'off') await record({ level: 'off' });\n      }\n    }\n  };\n}\n"],"mappings":";AAaA,SAAS,OAAO,OAAgB,QAAkB;CAChD,MAAM,OAAQ,UAAU;CACxB,MAAM,MAAO,WAAoE;AAEjF,KAAI,CAAC,IACH,OAAM,IAAI,MACR,2HACD;CAEH,IAAI,SAAkB;CACtB,IAAI;AAEJ,MAAK,MAAM,OAAO,KAAK,IAAI;AACzB,UAAQ;AACR,WAAU,OAAmC;;AAG/C,QAAQ,OAAoB,MAAM,OAAO,KAAK,GAAG;;;;;;AAOnD,SAAgB,QAAQ,QAAmB;CACzC,MAAM,UACA,GAAG,UACN,GAAG,SACF,OAAO,SAAS,QAAQ,CAAC,MAAM,KAAK,CAAS;CAEjD,MAAM,SAAS,OAA0B,WAAW,SAAS;CAC7D,MAAM,MAAM,OAAe,WAAW,MAAM;CAC5C,MAAM,SAAS,OAAgB,WAAW,SAAS;AAEnD,QAAO;EACL,KAAK,OAAgB,MAAM;EAC3B,KAAK,OAAa,MAAM;EACxB,MAAM,OAAgB,OAAO;EAC7B,QAAQ,OAA0C,SAAS;EAC3D,MAAM,OAAwC,OAAO;EAErD,SAAS;GACC;GACH;GACG;GACR,SAAS,OAAmD,WAAW,UAAU;GAGjF,OAAO,OAAa,WAAW,QAAQ;GACxC;EAED,MAAM,OAAO,MAAuC;GAClD,MAAM,SAAS,MAAM,QAAQ;GAC7B,MAAM,QAAQ,MAAM,KAAK;AAEzB,OAAI,OAAO,UAAU,MAAO,OAAM,OAAO,EAAE,OAAO,UAAU,CAAC;AAE7D,OAAI;AACF,UAAM,MAAM;AACZ,UAAM,OAAO,eAAe,IAAI,SAAS,YAAY,WAAW,SAAS,EAAE,CAAC,CAAC;AAC7E,WAAO,MAAM,OAAO,EAAE,OAAO,CAAC;aACtB;AACR,QAAI,OAAO,UAAU,MAAO,OAAM,OAAO,EAAE,OAAO,OAAO,CAAC;;;EAG/D"}

package/dist/serialize-FF81tr-L.d.ts

@@ -0,0 +1,123 @@
+import { State } from "@expressive/mvc";
+
+//#region src/journal.d.ts
+type Level = 'off' | 'keys' | 'values';
+interface Options {
+  level?: Level;
+  /** Labels to record. */
+  types?: string[];
+  /** `Type.key` addresses to record - label, `typeId`, or instance id on the left, property on the right. */
+  paths?: string[];
+  /** Property names to record on any type. */
+  keys?: string[];
+  /** Also record method calls (wraps instance methods except `render`). */
+  calls?: boolean;
+}
+interface Event {
+  id: string;
+  type: string;
+  key: string;
+  kind: 'update' | 'event' | 'call' | 'destroy';
+  value?: unknown;
+  args?: unknown[];
+}
+interface Frame {
+  seq: number;
+  at: number;
+  /** Frame whose flush scheduled the work that opened this one. */
+  cause?: number;
+  events: Event[];
+}
+interface Query {
+  since?: number;
+  type?: string;
+  id?: string;
+  key?: string;
+  cause?: number;
+}
+/** Run `work` with recording forced on; returns the frames it produced. */
+declare function act(work: () => unknown): Promise<Frame[]>;
+//#endregion
+//#region src/types.d.ts
+interface TypeInfo {
+  /** Opaque, stable for the life of the process. */
+  typeId: string;
+  /** Resolved display name - see `label`. */
+  type: string;
+  /** Construction stack captured at first sight, for a source-map resolver. */
+  site: string;
+}
+declare function label(Type: typeof State, name: string): void;
+/** Supply resolved names keyed by `typeId` or `site`, e.g. from a source-map pass. */
+declare function resolve(table: Record<string, string>): void;
+//#endregion
+//#region src/inspect.d.ts
+interface Model extends TypeInfo {
+  id: string;
+  parent?: string;
+  /** Keys with a stored value. */
+  keys: string[];
+  /** Declared keys with no stored value yet - lazy, pending, or uncomputed. */
+  absent: string[];
+}
+interface Node {
+  id: string;
+  type: string;
+  children: Node[];
+}
+/** Navigable view of one instance - identity, ownership, reads, observation. One per state; outlives it. */
+declare class Instance {
+  readonly state: State;
+  private constructor();
+  static of(state: State): Instance;
+  get id(): string;
+  get type(): string;
+  get alive(): boolean;
+  /** Reached by a host commit (`mount`), a claimed owner, or `static global`. Always true without a host. */
+  get claimed(): boolean;
+  /** Registration time (ms). */
+  get since(): number;
+  /** Destruction time (ms), once destroyed. */
+  get until(): number | undefined;
+  get parent(): Instance | undefined;
+  get children(): Instance[];
+  /** First instance in this subtree, depth-first, matching `where` (a label or predicate). */
+  find(where: string | ((instance: Instance) => boolean)): Instance | undefined;
+  get(path?: string): unknown;
+  model(): Model;
+  /** Run `work`, settle, and return the frames it produced. */
+  act(work: (state: State) => unknown): Promise<Frame[]>;
+  /** Call `fn` on each update, and with `null` on destroy; `keys` narrows updates. Returns unsubscribe. */
+  watch(fn: (key: string | null) => void, keys?: string[]): () => void;
+  frames(query?: Query): Frame[];
+}
+declare function attach(Type?: typeof State): () => void;
+declare function detach(): void;
+/** Resolve an id or label to an instance - mainline first, then orphans. */
+declare function find(target: string): Instance | undefined;
+declare function instances(): Instance[];
+/** Registered and settled, but never claimed by a host commit, an owner, or root context. */
+declare function orphans(): Instance[];
+/** Counts worth a look: live orphans, and unclaimed instances the collector already reaped. */
+declare function warnings(): {
+  orphans: number;
+  collected: number;
+};
+declare function roots(): Instance[];
+declare function models(): Model[];
+declare function tree(): Node[];
+declare function get(address?: string): unknown;
+declare function set(address: string, value: unknown): void;
+declare function call(address: string, ...args: unknown[]): Promise<unknown>;
+//#endregion
+//#region src/serialize.d.ts
+type Address = {
+  target: string;
+  path?: string;
+};
+declare function parsePath(raw: string): Address;
+/** JSON-safe, size-capped view. Nested States collapse to `$ref`. */
+declare function serialize(value: unknown, depth?: number): unknown;
+//#endregion
+export { Level as C, act as E, Frame as S, Query as T, warnings as _, Node as a, resolve as b, detach as c, instances as d, models as f, tree as g, set as h, Model as i, find as l, roots as m, serialize as n, attach as o, orphans as p, Instance as r, call as s, parsePath as t, get as u, TypeInfo as v, Options as w, Event as x, label as y };
+//# sourceMappingURL=serialize-FF81tr-L.d.ts.map

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@expressive/inspect",
+  "version": "0.0.1",
+  "description": "In-process inspector for Expressive MVC - registry, ownership tree, path queries, and a frame journal for agents, tests, and devtools.",
+  "keywords": [
+    "expressive",
+    "mvc",
+    "devtools",
+    "inspector",
+    "state"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Gabe Klein",
+    "email": "gabe@termtm.com",
+    "url": "https://github.com/gabeklein"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gabeklein/expressive-mvc.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": [
+    "./dist/install.js",
+    "./src/install.ts"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./install": {
+      "types": "./dist/install.d.ts",
+      "default": "./dist/install.js"
+    },
+    "./playwright": {
+      "types": "./dist/playwright.d.ts",
+      "default": "./dist/playwright.js"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "tsc --noEmit && vitest run --coverage"
+  },
+  "peerDependencies": {
+    "@expressive/mvc": "^0.84.0"
+  },
+  "devDependencies": {
+    "@expressive/mvc": "workspace:*",
+    "tsdown": "^0.20.1"
+  }
+}