Fundamental

Recipes

The recipe model

A FieldRecipe is a portable, serializable field program — the reusable unit that connects the natural-field model, engine primitives, DOM authoring, platform feedback, diagnostics, and the accessibility fallback. The catalog ships 64 recipes across 4 tiers (8 first-release), composed from 23 distinct runtime tokens. See them all in the recipe gallery.

Recipe prose can be expressive. Runtime tokens must be real. A recipe may say “completion releases pressure and decays into memory,” but its runtime fields stay strict: primitives: ["morph", "memory"]. The conformance gate rejects any recipe whose primitives are not real passported tokens — or that puts a diagnostic, metric, condition, or concept in the token lane.

The vocabulary lanes

A recipe separates these on purpose. A word lives in exactly one lane, and the lane says which:

Natural field
conceptual translation — gravity, electromagnetic, strong, weak
Runtime token
a real passported engine force (attract, gravity, fieldflow…) — strict, conformance-gated
Concept
human-facing product language (orbit, spring, trust, staleness) — not a token
Metric
measured / semantic state (mass, attention, pressure, confidence)
Diagnostic
inspection or render mode (potential, topology, causality, field-lines)
Condition
activation logic (dwell, threshold, stale, in-view, focused)
Scheduler phase
runtime step — discover → read → compute → state → write → render
Compatibility alias
older naming (--d, --mass) — kept, but not the primary path

The schema

FieldRecipe 
type FieldRecipe = {
  id: string;
  name: string;
  intent: string;
  tier: "core" | "applied" | "systems" | "operational";
  naturalField?: "gravity" | "electromagnetic" | "strong" | "weak";  // FIELD lane (conceptual)
  translation?: string;                  // a short natural-field phrase

  // ── the lanes — a word lives in exactly one ───────────────────────────
  primitives: ForceToken[];   // RUNTIME TOKEN — strict, passported, conformance-gated
  concepts?:  string[];       // CONCEPT       — orbit, spring, trust, staleness
  metrics:    string[];       // METRIC        — mass, attention, pressure, confidence
  diagnostics:string[];       // DIAGNOSTIC    — potential, topology, causality
  conditions?:string[];       // CONDITION     — dwell, threshold, stale, in-view

  bodies: BodyRecipe[];       // how the runtime tokens are authored on elements
  render: RenderLayer[];
  accessibility: {            // required — no recipe is motion-only
    reducedMotion: string;
    meaningWithoutMotion: string;
  };
  status: "shipped" | "experimental" | "planned" | "conceptual";
};

Concept → token mapping

When a product word is not a real engine token, it goes to its proper lane — it is never invented as a force. No new force tokens are added for recipes.

Concept wordLaneResolution
mass metric a measured property — use gravity / attract as the token
potential diagnostic a field-sampling overlay — never a token
spring concept runtime token: tether
drag concept runtime token: viscosity
reflect concept runtime token: wall
absorb concept runtime token: sink
threshold condition runtime token: gate (if a gate is intended)
orbit concept composed from gravity + magnetism + tether
emitter concept runtime token: spawn
phase / decay concept runtime token: morph / memory
trust / risk / confidence metric measured state — never a token

A worked recipe

Every recipe is plain, serializable data. This is Guided Flow straight from the catalog — note the strict primitives beside the expressive notes:

guided-flow.json 
{
  "id": "guided-flow",
  "name": "Guided Flow",
  "intent": "move particles or attention along field lines, relationships, or paths",
  "naturalField": "electromagnetic",
  "primitives": [
    "magnetism",
    "fieldflow",
    "stream",
    "propagate"
  ],
  "bodies": [
    {
      "body": "magnetism",
      "strength": 1,
      "range": 420,
      "spin": 1
    },
    {
      "body": "fieldflow",
      "strength": 0.8,
      "range": 0
    },
    {
      "body": "stream",
      "strength": 0.6,
      "range": 320,
      "angle": 0
    },
    {
      "body": "propagate",
      "strength": 0.5,
      "range": 300
    }
  ],
  "render": [
    "streamlines",
    "field-lines",
    "trails",
    "particles"
  ],
  "metrics": [
    "flow",
    "velocity",
    "density"
  ],
  "diagnostics": [
    "field-lines",
    "force-vectors",
    "prediction"
  ],
  "accessibility": {
    "reducedMotion": "a static path contour with a numbered route and direction markers",
    "meaningWithoutMotion": "the route is an ordered list of steps with direction labels"
  },
  "notes": "Matter and attention move along field lines / relationship paths (electromagnetic + transport). Magnetism bends, fieldflow carries — the recipe-level expression of field.flowTo() and fieldflow.",
  "tier": "core",
  "status": "shipped"
}

What the conformance gate enforces

  • Every runtime token is a real, passported engine force.
  • No token is a diagnostic , metric , condition , or concept .
  • Declared primitives exactly match the body tokens (no drift).
  • Every diagnostic is a real render / inspection mode.
  • Every natural field is one of gravity / electromagnetic / strong / weak.
  • Every recipe declares a reduced-motion equivalent — no recipe is motion-only.

Data binding — bindData()

Recipes make behavior portable; bindData() makes real records participate in it. Records become bodies, mapped metrics become state, mapped relationships become edges, and a recipe supplies the behavior. Updates are deterministic and removed records decay rather than pop.

—