@fundamental-engine/platform 0.5.1 → 0.7.0

package/README.md

@@ -1,107 +1,17 @@
-# @fundamental-engine/platform
+# @fundamental-engine/platform — deprecated
 
-**The platform layer for [Fundamental](../core)** — the native browser primitives the engine wishes
-existed, built on the ones it has. The core is renderer-agnostic; this package owns DOM participation:
-it supplies the browser host, the six registries that let the engine treat the DOM as a connected,
-measurable, semantic environment, the frame scheduler that keeps reads and writes from thrashing, and
-the runtime that runs recipes and binds data.
+**Renamed to [`@fundamental-engine/dom`](https://www.npmjs.com/package/@fundamental-engine/dom).**
 
-→ Live at **[fundamental-engine.com](https://fundamental-engine.com)**.
+This package is now a thin alias that re-exports `@fundamental-engine/dom` so existing installs keep
+working. The layer it names is the DOM binding for the engine — `browserHost()`, the six registries
+(measurement / state / feedback / relationships / visual-bindings / overlays), the frame scheduler,
+`lintPlatform`, and `bindData` — so the honest name is `dom`.
 
-## Install
+Switch your imports:
 
-```sh
-npm i @fundamental-engine/platform
+```diff
+- import { browserHost } from '@fundamental-engine/platform';
++ import { browserHost } from '@fundamental-engine/dom';
 ```
 
-The public surface is frozen for `0.x` (see
-[API stability](../../docs/canonical/api-stability.md)).
-
-## The browser host
-
-The core's `createField` is renderer-agnostic and requires a `FieldHost`. `browserHost()` is the
-canonical DOM implementation, and `createBrowserField()` is the host-bundled shortcut:
-
-```ts
-import { createField } from '@fundamental-engine/core';
-import { browserHost, createBrowserField } from '@fundamental-engine/platform';
-
-const canvas = document.querySelector('canvas')!;
-const field = createField(canvas, { host: browserHost() });
-// or, equivalently:
-const same = createBrowserField(canvas, {});
-```
-
-## The platform
-
-`createFieldPlatform(root)` wires the six native-first registries on a root element and a frame
-scheduler that runs them in order: **discover → read → compute → state → write → render**.
-
-| Registry | Role |
-|---|---|
-| `MeasurementRegistry` | frame-stable geometry snapshots (read-phase only) |
-| `StateRegistry` | typed numeric / boolean / vector2 element state (not ARIA) |
-| `FeedbackRegistry` | write-phase CSS vars + thresholded, debounced events |
-| `RelationshipRegistry` | normalize native links (`href#id`, `aria-controls`, `for`, …) into one graph |
-| `VisualBindingRegistry` | bind a Canvas / SVG / WebGL visual layer to its semantic source |
-| `OverlayRegistry` | relationship / field-line / debug render layers |
-
-```ts
-import { createFieldPlatform } from '@fundamental-engine/platform';
-
-const platform = createFieldPlatform(document.documentElement);
-platform.measure.register(card, { role: 'body' });
-platform.state.set(card, 'density', 0.72);
-platform.feedback.bind(card, { density: '--field-density' });
-platform.feedback.threshold(card, 'field:lit', { metric: 'density', enter: 0.7, exit: 0.45 });
-platform.tick(); // run one frame through the scheduler
-```
-
-`createFieldPlatform` returns a `FieldPlatform` — the surface the inspector and tools read.
-
-## Recipes and data
-
-The platform runs recipes and binds application data to the field. `compileRecipe()` (the pure
-compiler) lives in [the core](../core); application lives here:
-
-```ts
-import { applyRecipe, bindData } from '@fundamental-engine/platform';
-import { recipeById } from '@fundamental-engine/core';
-
-// Run a recipe over a region; inspect the live run; tear it down.
-const applied = applyRecipe(root, recipeById('reading-field')!);
-applied.inspect(); // { frame, measurements, relationships, lint }
-
-// Bind records → bodies. Updates diff by id; removed records decay out.
-const binding = bindData(listEl, tasks, (t) => ({
-  id: t.id,
-  body: { tokens: ['attract'], strength: 0.4 + t.priority },
-  metrics: { priority: t.priority },
-  label: t.title,
-}), { recipe: 'priority-well' });
-binding.update(nextTasks);
-```
-
-`computeMetrics()` (pure) turns measurements and relationships into the metric values recipes track.
-
-## Lint
-
-`lintPlatform(platform)` runs pure rules over the live registries and the markup (missing
-relationship targets, sinks that capture without `data-feedback`, styles reading feedback
-variables no body writes, unregistered state, overlays without links, off-phase measurement,
-orphan visuals, …) and returns structured diagnostics. The inspector reads it each frame.
-
-## Dependency direction
-
-Strict and one-way: **`platform → core`**. The core stays renderer-agnostic and never imports this
-package. During the migration window, writes mirror `--field-*` to `--forces-*` and `field:*` events to
-`forces:*`. See [`docs/canonical/platform-architecture.md`](../../docs/canonical/platform-architecture.md).
-
-## Related
-
-[`Fundamental`](../core) · [`@fundamental-engine/elements`](../elements) · [`@fundamental-engine/react`](../react) ·
-[`@fundamental-engine/vanilla`](../vanilla) · the [documentation map](../../docs/README.md).
-
-## License
-
-MIT © Zach Shallbetter
+The alias will be removed in a future major release.

package/dist/index.d.ts

@@ -1,39 +1,16 @@
 /**
- * @fundamental-engine/platform — the platform-adjacent layer: native-first registries that let the field
- * engine treat the DOM as a connected, measurable, semantic environment. Strict dependency
- * direction: this package depends on `Fundamental` (core) for contracts; core never depends on it.
+ * @fundamental-engine/platform — DEPRECATED.
  *
- * Registries: MeasurementRegistry · StateRegistry · FeedbackRegistry · RelationshipRegistry ·
- * VisualBindingRegistry · OverlayRegistry, bound by createFieldPlatform.
+ * This package was renamed to `@fundamental-engine/dom` (it is the DOM-binding layer:
+ * `browserHost()`, the six registries, the frame scheduler, `lintPlatform`, `bindData`).
+ * This alias re-exports it unchanged so existing installs keep working; switch your imports:
  *
- * Also the browser environment adapter for the renderer-agnostic core engine: `browserHost()` (the
- * default FieldHost), `createBrowserField()` (createField + browserHost), and the DOM download
- * helpers — so core can import zero DOM.
+ * ```diff
+ * - import { browserHost } from '@fundamental-engine/platform';
+ * + import { browserHost } from '@fundamental-engine/dom';
+ * ```
+ *
+ * The alias will be removed in a future major. See https://fundamental-engine.com.
  */
-import { type FieldHandle, type FieldOptions } from '@fundamental-engine/core';
-export * from './types.ts';
-export * from './env.ts';
-export * from './schedule.ts';
-export * from './measurement.ts';
-export * from './state.ts';
-export * from './feedback.ts';
-export * from './relationships.ts';
-export * from './visual-bindings.ts';
-export * from './overlays.ts';
-export * from './lint.ts';
-export * from './platform.ts';
-export * from './metrics.ts';
-export * from './apply-recipe.ts';
-export * from './field-nav.ts';
-export * from './bind-data.ts';
-export * from './browser-host.ts';
-export * from './export-dom.ts';
-export * from './governor.ts';
-export * from './flip.ts';
-export * from './text-bodies.ts';
-export * from './contours.ts';
-export * from './thread-overlay.ts';
-export * from './perf.ts';
-/** Start the core engine on a canvas with the default browser host — `createField` + `browserHost()`. */
-export declare function createBrowserField(canvas: HTMLCanvasElement, opts?: Omit<FieldOptions, 'host'>): FieldHandle;
+export * from '@fundamental-engine/dom';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAe,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG5F,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAE1B,yGAAyG;AACzG,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,iBAAiB,EAAE,IAAI,GAAE,IAAI,CAAC,YAAY,EAAE,MAAM,CAAM,GAAG,WAAW,CAEhH"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,cAAc,yBAAyB,CAAC"}

package/dist/index.js

@@ -1,42 +1,16 @@
 /**
- * @fundamental-engine/platform — the platform-adjacent layer: native-first registries that let the field
- * engine treat the DOM as a connected, measurable, semantic environment. Strict dependency
- * direction: this package depends on `Fundamental` (core) for contracts; core never depends on it.
+ * @fundamental-engine/platform — DEPRECATED.
  *
- * Registries: MeasurementRegistry · StateRegistry · FeedbackRegistry · RelationshipRegistry ·
- * VisualBindingRegistry · OverlayRegistry, bound by createFieldPlatform.
+ * This package was renamed to `@fundamental-engine/dom` (it is the DOM-binding layer:
+ * `browserHost()`, the six registries, the frame scheduler, `lintPlatform`, `bindData`).
+ * This alias re-exports it unchanged so existing installs keep working; switch your imports:
  *
- * Also the browser environment adapter for the renderer-agnostic core engine: `browserHost()` (the
- * default FieldHost), `createBrowserField()` (createField + browserHost), and the DOM download
- * helpers — so core can import zero DOM.
+ * ```diff
+ * - import { browserHost } from '@fundamental-engine/platform';
+ * + import { browserHost } from '@fundamental-engine/dom';
+ * ```
+ *
+ * The alias will be removed in a future major. See https://fundamental-engine.com.
  */
-import { createField } from '@fundamental-engine/core';
-import { browserHost } from "./browser-host.js";
-export * from "./types.js";
-export * from "./env.js";
-export * from "./schedule.js";
-export * from "./measurement.js";
-export * from "./state.js";
-export * from "./feedback.js";
-export * from "./relationships.js";
-export * from "./visual-bindings.js";
-export * from "./overlays.js";
-export * from "./lint.js";
-export * from "./platform.js";
-export * from "./metrics.js";
-export * from "./apply-recipe.js";
-export * from "./field-nav.js";
-export * from "./bind-data.js";
-export * from "./browser-host.js";
-export * from "./export-dom.js";
-export * from "./governor.js";
-export * from "./flip.js";
-export * from "./text-bodies.js";
-export * from "./contours.js";
-export * from "./thread-overlay.js";
-export * from "./perf.js";
-/** Start the core engine on a canvas with the default browser host — `createField` + `browserHost()`. */
-export function createBrowserField(canvas, opts = {}) {
-    return createField(canvas, { ...opts, host: browserHost() });
-}
+export * from '@fundamental-engine/dom';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,WAAW,EAAuC,MAAM,0BAA0B,CAAC;AAC5F,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAE1B,yGAAyG;AACzG,MAAM,UAAU,kBAAkB,CAAC,MAAyB,EAAE,OAAmC,EAAE;IACjG,OAAO,WAAW,CAAC,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,CAAC,CAAC;AAC/D,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,cAAc,yBAAyB,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fundamental-engine/platform",
-  "version": "0.5.1",
-  "description": "The platform-adjacent layer for Fundamental — native-first registries for measurement, semantic state, feedback, relationships, visual-semantic bindings, and overlays. The browser primitives Fundamental wishes existed, built on the ones it has.",
+  "version": "0.7.0",
+  "description": "DEPRECATED — renamed to @fundamental-engine/dom. A thin alias that re-exports it so existing installs keep working; switch your imports to @fundamental-engine/dom.",
   "type": "module",
   "license": "MIT",
   "author": "Zach Shallbetter <hi@zachshallbetter.com> (https://zachshallbetter.com)",
@@ -16,13 +16,7 @@
   },
   "keywords": [
     "Fundamental",
-    "dom",
-    "measurement",
-    "relationships",
-    "state",
-    "feedback",
-    "overlays",
-    "web"
+    "deprecated"
   ],
   "sideEffects": false,
   "files": [
@@ -46,7 +40,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@fundamental-engine/core": "0.5.1"
+    "@fundamental-engine/dom": "0.7.0"
   },
   "devDependencies": {
     "typescript": "^5.9.3"

package/dist/apply-recipe.d.ts

@@ -1,103 +0,0 @@
-/**
- * applyRecipe — the DOM counterpart to core's `compileRecipe`. Turns a `FieldRecipe` from a record
- * into a running field program: it registers the recipe's bodies (TOKEN lane only — concepts are never
- * executed), binds its metrics to feedback variables, discovers its relationships, computes metric
- * state each frame, installs a reduced-motion output when motion is reduced, and returns a handle that
- * can be inspected and destroyed.
- *
- * It runs on a scoped `createFieldPlatform(root)` — the registry/feedback layer, not a particle canvas
- * — so it works on ordinary content the way the Reading Field studies do.
- */
-import { type FieldPlatform } from './platform.ts';
-import { type FieldRecipe, type CompiledRecipe } from '@fundamental-engine/core';
-export interface ApplyRecipeOptions {
-    /** existing elements (or a selector within root) to annotate as the recipe's bodies; if omitted, demo elements are created. */
-    bodies?: Element[] | string;
-    /** when bodies are provided, whether to overwrite their data-body attributes with the recipe's (default true). Set false to keep caller-owned tokens (e.g. bindData) while still binding the recipe's metrics. */
-    annotateBodies?: boolean;
-    /** force the reduced-motion output (defaults to the OS prefers-reduced-motion setting). */
-    reducedMotion?: boolean;
-    /** compute + bind metrics (default true). */
-    metrics?: boolean;
-    /** run the rAF loop (default true). Set false to drive `tick()` yourself. */
-    drive?: boolean;
-    /** text for created demo bodies (default: the body's tokens). */
-    label?: (recipe: FieldRecipe, index: number) => string;
-    /**
-     * Apply the recipe with its render stack stripped (`render: []`) — the scoped invisible-field
-     * idiom the example family runs: the field exists purely as metrics/feedback signals on real
-     * content, with no drawn layers. The caller's recipe object is NEVER mutated (it may be the
-     * shared catalog object); `applyRecipe` derives an effective copy, which is what the returned
-     * handle's `recipe`/`compiled` reflect.
-     */
-    renderless?: boolean;
-    /**
-     * A live field to DRIVE with the recipe's render plan (#370) — the missing execution half of
-     * `recipe.render`. Structural: a `FieldHandle` or a `<field-root>` element both satisfy it.
-     * When provided (and not `renderless`/reduced-motion), the compiled plan executes — underlay
-     * matter mode via setRender, the additive overlay reading stack via setOverlay, the heatmap
-     * toggle — and `destroy()` resets the surfaces it drove (dots / off / false). Omitted → the
-     * recipe stays signals-only, exactly as before (fully additive).
-     */
-    field?: RecipeFieldTarget;
-    /**
-     * Extra metric lanes appended to the recipe's `metrics` (deduped, original order preserved) —
-     * e.g. `['attention', 'recency']`. Each appended metric gains the standard feedback binding
-     * (`attention` → `--field-attention`) and flows through the per-frame metric pipeline exactly
-     * like a recipe-declared one. Same no-mutation guarantee as `renderless`.
-     */
-    extraMetrics?: string[];
-}
-export interface AppliedRecipeInspection {
-    id: string;
-    frame: number;
-    measurements: number;
-    /** resolved relationships (both endpoints known). */
-    relationships: number;
-    /** declared relationships whose target id-ref resolves to no element. */
-    relationshipsUnresolved: number;
-    /** resolved / (resolved + unresolved); undefined when no relationships are declared. */
-    relationshipResolution?: number;
-    /** the unresolved declarations, so inspection can name each missing endpoint. */
-    unresolvedRelationships: Array<{
-        from: string;
-        type: string;
-        target: string;
-    }>;
-    /** elementKey → metric → value (the compiled recipe's lanes, live). */
-    metrics: Record<string, Record<string, number>>;
-    lint: number;
-    reducedMotion: boolean;
-}
-export interface AppliedRecipe {
-    id: string;
-    recipe: FieldRecipe;
-    compiled: CompiledRecipe;
-    platform: FieldPlatform;
-    root: Element;
-    elements: Element[];
-    reducedMotion: boolean;
-    inspect(): AppliedRecipeInspection;
-    tick(now?: number): void;
-    destroy(): void;
-}
-/**
- * Apply a recipe to a root element. Validates, compiles, registers bodies, binds metrics, discovers
- * relationships, installs the reduced-motion output, and returns a destroyable, inspectable handle.
- */
-/** The slice of a live field a recipe can drive — FieldHandle and <field-root> both fit. */
-export interface RecipeFieldTarget {
-    setRender?(mode: string): void;
-    setOverlay?(mode: string | string[]): void;
-    setHeatmap?(on: boolean): void;
-}
-/** Execute a compiled render plan on a field target. Exported for tests and custom hosts. */
-export declare function driveRenderPlan(field: RecipeFieldTarget, plan: {
-    underlay: string | null;
-    overlay: string[];
-    heatmap: boolean;
-}): void;
-export declare function applyRecipe(root: Element, recipe: FieldRecipe, options?: ApplyRecipeOptions): AppliedRecipe;
-/** Tear down an applied recipe (alias of `applied.destroy()`). */
-export declare function destroyRecipe(applied: AppliedRecipe): void;
-//# sourceMappingURL=apply-recipe.d.ts.map

package/dist/apply-recipe.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"apply-recipe.d.ts","sourceRoot":"","sources":["../src/apply-recipe.ts"],"names":[],"mappings":"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"}

package/dist/apply-recipe.js

@@ -1,271 +0,0 @@
-/**
- * applyRecipe — the DOM counterpart to core's `compileRecipe`. Turns a `FieldRecipe` from a record
- * into a running field program: it registers the recipe's bodies (TOKEN lane only — concepts are never
- * executed), binds its metrics to feedback variables, discovers its relationships, computes metric
- * state each frame, installs a reduced-motion output when motion is reduced, and returns a handle that
- * can be inspected and destroyed.
- *
- * It runs on a scoped `createFieldPlatform(root)` — the registry/feedback layer, not a particle canvas
- * — so it works on ordinary content the way the Reading Field studies do.
- */
-import { createFieldPlatform } from "./platform.js";
-import { lintPlatform } from "./lint.js";
-import { prefersReducedMotion } from "./env.js";
-import { computeMetrics, groundedRecency, METRIC_KINDS } from "./metrics.js";
-import { validateRecipe, compileRecipe, } from '@fundamental-engine/core';
-const isMetricKind = (m) => METRIC_KINDS.includes(m);
-const num = (v) => {
-    if (v == null)
-        return undefined;
-    const n = Number(v);
-    return Number.isFinite(n) ? n : undefined;
-};
-const elementKey = (el, i) => el.id || `${el.tagName.toLowerCase()}#${i}`;
-/** Execute a compiled render plan on a field target. Exported for tests and custom hosts. */
-export function driveRenderPlan(field, plan) {
-    if (plan.underlay && field.setRender)
-        field.setRender(plan.underlay);
-    if (field.setOverlay)
-        field.setOverlay(plan.overlay.length ? plan.overlay : 'off');
-    if (field.setHeatmap)
-        field.setHeatmap(plan.heatmap);
-}
-export function applyRecipe(root, recipe, options = {}) {
-    // Derive the effective recipe from the scoped-field options — a copy, so a shared catalog
-    // recipe object is never mutated by an applied run (`renderless` strips the render stack;
-    // `extraMetrics` appends + dedupes metric lanes). No options → the input recipe, untouched.
-    const extra = options.extraMetrics ?? [];
-    if (options.renderless || extra.length) {
-        recipe = {
-            ...recipe,
-            ...(options.renderless ? { render: [] } : {}),
-            ...(extra.length ? { metrics: [...new Set([...(recipe.metrics ?? []), ...extra])] } : {}),
-        };
-    }
-    const problems = validateRecipe(recipe);
-    if (problems.length)
-        throw new Error(`applyRecipe: invalid recipe "${recipe.id}": ${problems.map((p) => `${p.path} (${p.issue})`).join('; ')}`);
-    const compiled = compileRecipe(recipe);
-    const wantMetrics = options.metrics !== false;
-    // the execution half of recipe.render (#370): drive the supplied field with the compiled plan.
-    // Reduced motion skips the drive entirely — the recipe's static plan is the equivalent, and a
-    // field left at its resting surfaces (dots / off) IS the static reading.
-    let droveField = null;
-    const reducedMotion = options.reducedMotion ?? prefersReducedMotion();
-    const platform = createFieldPlatform(root);
-    if (options.field && !options.renderless && !reducedMotion) {
-        driveRenderPlan(options.field, compiled.render);
-        droveField = options.field;
-    }
-    // ── resolve body elements: annotate provided ones, or create demo bodies ──────────────
-    const created = [];
-    const restore = [];
-    let elements;
-    if (options.bodies) {
-        elements = typeof options.bodies === 'string' ? Array.from(root.querySelectorAll(options.bodies)) : options.bodies.slice();
-        if (options.annotateBodies !== false) {
-            elements.forEach((el, i) => {
-                const body = compiled.bodies[i % compiled.bodies.length];
-                const snap = {};
-                for (const [k, v] of Object.entries(body.attributes)) {
-                    snap[k] = el.getAttribute(k);
-                    el.setAttribute(k, v);
-                }
-                restore.push({ el, attrs: snap });
-            });
-        }
-    }
-    else {
-        elements = compiled.bodies.map((body, i) => {
-            const el = (root.ownerDocument ?? document).createElement('span');
-            for (const [k, v] of Object.entries(body.attributes))
-                el.setAttribute(k, v);
-            el.setAttribute('data-recipe-body', recipe.id);
-            el.textContent = options.label ? options.label(recipe, i) : body.tokens.join(' ');
-            root.appendChild(el);
-            created.push(el);
-            return el;
-        });
-    }
-    // ── register for measurement + bind the metric lane to feedback variables ──────────────
-    const varMap = {};
-    for (const f of compiled.feedback)
-        varMap[f.metric] = f.var;
-    for (const el of elements) {
-        platform.measure.register(el, { role: 'recipe-body' });
-        if (wantMetrics && compiled.feedback.length)
-            platform.feedback.bind(el, varMap);
-    }
-    // ── discover relationships once ──────────────────────────────────────────────────────
-    let discovered = false;
-    platform.on('discover', () => {
-        if (!discovered) {
-            platform.relationships.discover(root);
-            discovered = true;
-        }
-    });
-    // ── metric computation (compute → state); write phase flushes state → --field-* vars ───
-    const prev = new Map();
-    if (wantMetrics) {
-        const pending = new Map();
-        platform.on('compute', (ctx) => {
-            const vh = ctx.viewport?.height ?? (typeof window !== 'undefined' ? window.innerHeight : 800);
-            const centre = vh / 2;
-            // WORLD TIME, once per frame: ctx.now is the scheduler's rAF timebase, not an epoch, so
-            // the declared-timestamp derivation samples the wall clock HERE — one instant shared by
-            // every element in the frame, never a per-element Date.now().
-            const worldNow = Date.now();
-            const rels = platform.relationships.all();
-            const unresolved = platform.relationships.unresolvedAll();
-            for (const m of platform.measure.last()) {
-                const el = m.element;
-                const proximity = Math.max(0, 1 - Math.abs(m.rect.cy - centre) / (vh * 0.55));
-                const engaged = el.matches(':hover, :focus, :focus-within') || el.hasAttribute('data-active');
-                // a body touches a relationship if either endpoint is the body or sits inside it (child anchors)
-                const touching = rels.filter((r) => el.contains(r.from) || el.contains(r.to));
-                // declared-but-unresolved edges originating in this body count toward the total but not the
-                // resolved set, so resolution is real: a citation pointing at nothing lowers it (raising entropy).
-                const touchingUnresolved = unresolved.filter((u) => el.contains(u.from));
-                const relResolved = touching.length;
-                const relTotal = touching.length + touchingUnresolved.length;
-                const relConflict = touching.filter((r) => r.type === 'contradicts' || r.type === 'opposes' || r.type === 'conflicts-with').length;
-                const supplied = {};
-                for (const k of METRIC_KINDS) {
-                    const s = num(el.getAttribute(`data-field-${k}`));
-                    if (s != null)
-                        supplied[k] = s;
-                }
-                // A declared world timestamp (data-field-at) GROUNDS the recency lane: recency becomes
-                // freshness(at, now, halfLife) — data time, not interaction time. An explicit
-                // data-field-recency still wins; without either, computeMetrics infers recency from
-                // interaction (the existing eased behavior, unchanged).
-                if (supplied.recency == null) {
-                    const r = groundedRecency(el, worldNow);
-                    if (r != null)
-                        supplied.recency = r;
-                }
-                pending.set(el, computeMetrics({
-                    proximity,
-                    visible: m.visibilityRatio,
-                    engaged,
-                    dtFrames: 1,
-                    relResolved,
-                    relTotal,
-                    relConflict,
-                    supplied,
-                    prev: prev.get(el) ?? {},
-                }));
-            }
-        });
-        platform.on('state', () => {
-            for (const [el, computed] of pending) {
-                prev.set(el, computed);
-                for (const metric of compiled.metrics) {
-                    const value = isMetricKind(metric)
-                        ? computed[metric]
-                        : (num(el.getAttribute(`data-field-${metric}`)) ?? 0);
-                    if (value == null) {
-                        // The metric is absent this frame — e.g. the host supplied data-field-confidence on an
-                        // earlier frame and has since removed it. Drop any stale state AND clear the bound CSS
-                        // var, so the write phase neither re-emits a value nor leaves one written on a previous
-                        // flush lingering on the element. Absent must read as absent, not last-known. Both calls
-                        // are no-ops when nothing was ever set, so the common "never supplied" case stays cheap.
-                        platform.state.delete(el, metric);
-                        platform.feedback.clearVar(el, metric);
-                        continue;
-                    }
-                    platform.state.set(el, metric, value);
-                }
-            }
-        });
-    }
-    // ── reduced-motion output: a real static surface, not just prose ──────────────────────
-    let staticNode = null;
-    if (reducedMotion) {
-        root.dataset.recipeReduced = 'on';
-        const doc = root.ownerDocument ?? document;
-        staticNode = doc.createElement('aside');
-        staticNode.className = 'recipe-static';
-        staticNode.setAttribute('data-recipe-static', recipe.id);
-        staticNode.innerHTML =
-            `<p class="rs-note">${escapeHtml(compiled.reducedMotion.meaningWithoutMotion)}</p>` +
-                (compiled.metrics.length ? `<p class="rs-metrics">Metrics: ${compiled.metrics.map((m) => `<span>${escapeHtml(m)}</span>`).join(' ')}</p>` : '') +
-                (compiled.relationships.length ? `<p class="rs-rels">Relationships: ${compiled.relationships.map((r) => `${escapeHtml(r.from)}→${escapeHtml(r.to)}`).join(', ')}</p>` : '');
-        root.appendChild(staticNode);
-    }
-    // ── drive ─────────────────────────────────────────────────────────────────────────────
-    let raf = 0;
-    const viewport = () => (typeof window !== 'undefined' ? { width: window.innerWidth, height: window.innerHeight } : undefined);
-    const tick = (now = 0) => {
-        platform.tick(now, viewport());
-    };
-    if (options.drive !== false && typeof requestAnimationFrame !== 'undefined') {
-        const loop = (now) => {
-            tick(now);
-            raf = requestAnimationFrame(loop);
-        };
-        raf = requestAnimationFrame(loop);
-    }
-    const inspect = () => {
-        const metrics = {};
-        elements.forEach((el, i) => {
-            const row = {};
-            for (const metric of compiled.metrics)
-                row[metric] = platform.state.number(el, metric);
-            metrics[elementKey(el, i)] = row;
-        });
-        const unresolved = platform.relationships.unresolvedAll();
-        const resolvedCount = platform.relationships.all().length;
-        const declaredTotal = resolvedCount + unresolved.length;
-        return {
-            id: recipe.id,
-            frame: platform.scheduler.frame,
-            measurements: platform.measure.size,
-            relationships: resolvedCount,
-            relationshipsUnresolved: unresolved.length,
-            relationshipResolution: declaredTotal > 0 ? resolvedCount / declaredTotal : undefined,
-            unresolvedRelationships: unresolved.map((u) => ({
-                from: u.from.id || u.from.tagName.toLowerCase(),
-                type: u.type,
-                target: u.target,
-            })),
-            metrics,
-            lint: lintPlatform(platform).length,
-            reducedMotion,
-        };
-    };
-    const destroy = () => {
-        if (raf)
-            cancelAnimationFrame(raf);
-        raf = 0;
-        // release the surfaces this recipe drove — the field returns to its resting reading
-        if (droveField) {
-            driveRenderPlan(droveField, { underlay: 'dots', overlay: [], heatmap: false });
-            droveField = null;
-        }
-        // clear the feedback variables this recipe wrote, so a torn-down recipe leaves the DOM plain
-        // (typeof-guarded like every other global here, so destroy() is safe off-DOM too)
-        if (typeof HTMLElement !== 'undefined')
-            for (const el of elements)
-                if (el instanceof HTMLElement)
-                    for (const f of compiled.feedback)
-                        el.style.removeProperty(f.var);
-        for (const el of created)
-            el.remove();
-        for (const { el, attrs } of restore)
-            for (const [k, v] of Object.entries(attrs))
-                v == null ? el.removeAttribute(k) : el.setAttribute(k, v);
-        staticNode?.remove();
-        if (reducedMotion)
-            delete root.dataset.recipeReduced;
-    };
-    return { id: recipe.id, recipe, compiled, platform, root, elements, reducedMotion, inspect, tick, destroy };
-}
-/** Tear down an applied recipe (alias of `applied.destroy()`). */
-export function destroyRecipe(applied) {
-    applied.destroy();
-}
-function escapeHtml(s) {
-    return s.replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' })[c] ?? c);
-}
-//# sourceMappingURL=apply-recipe.js.map