@vibecook/ice 0.1.0

package/dist/types/packages/core/src/input/measure-queue.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The measurement queue — the ONE ingest path for auto-sized widget sizes
+ * (design-004 §2 host pipeline). Mirrors {@link ../input/queue.ts} exactly:
+ * pre-ingest TRANSPORT, not world state. A DOM `ResizeObserver` adapter (the
+ * `measure-adapter` in @ice/dom) enqueues normalized `{ entity, w, h }` samples
+ * as content boxes resize; `measureIngest` drains once per tick and folds them
+ * into the `MeasuredSize` session rider. No system reads it, nothing observes
+ * it, it holds nothing across a drain.
+ *
+ * Measurements are content-box sizes in CSS px (screen == world here — the
+ * host's content plane carries the camera transform, so a widget's content is
+ * laid out in world units). The adapter NEVER enqueues a `0×0` sample (from a
+ * `display:none` host) and ingest skips it a second time — the §2 double wall
+ * against a full→0 collapse corrupting bounds/cull on re-entry.
+ */
+import type { Entity } from "@vibecook/strata-ecs";
+export interface MeasureEvent {
+    /** The widget entity whose content element resized (a runtime handle). */
+    readonly entity: Entity;
+    readonly w: number;
+    readonly h: number;
+}
+export interface MeasureQueue {
+    enqueue(event: MeasureEvent): void;
+    /** Drain in arrival order. Called ONLY by `measureIngest`, once per tick. */
+    drain(): readonly MeasureEvent[];
+    /** Samples waiting (telemetry / the ingest `runIf` guard). */
+    size(): number;
+}
+export declare function createMeasureQueue(): MeasureQueue;

package/dist/types/packages/core/src/input/queue.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The input queue — the ONE input path's front door (Law 2, design-003 §2).
+ *
+ * Adapters (DOM pointer/wheel/keyboard, R3F router verdicts, test drivers) ONLY
+ * enqueue normalized {@link InputEvent}s; `pointerIngest` drains the queue once
+ * per tick and turns events into world facts. Handlers run mid-frame at
+ * arbitrary times — the queue is what keeps every world write inside the frame
+ * contract (design-002 §3). It is pre-ingest TRANSPORT, not world state: no
+ * system reads it, nothing observes it, it holds nothing across a drain.
+ *
+ * Pointer identity: `pointerId` is the adapter's stable string for a device
+ * pointer — `"mouse"` for the one mouse, `"touch:<n>"` per touch contact,
+ * `"pen"` for a stylus. Ingest keys pointer entities off it (`Pointer.id`).
+ */
+export type InputEventKind = "down" | "move" | "up" | "cancel" | "wheel" | "key";
+export interface InputMods {
+    readonly shift: boolean;
+    readonly ctrl: boolean;
+    readonly alt: boolean;
+    readonly meta: boolean;
+    /** Space-held (pan gesture modifier, design-003 §4.4) — not a PointerMods field. */
+    readonly space: boolean;
+}
+export interface InputEvent {
+    readonly kind: InputEventKind;
+    /** Stable adapter pointer id ("mouse" | "touch:<n>" | "pen"). Empty for kind:"key". */
+    readonly pointerId: string;
+    readonly device: "mouse" | "touch" | "pen";
+    /** Canvas-container-relative CSS px (the kernel screen space). */
+    readonly screenX: number;
+    readonly screenY: number;
+    /** Button bitmask as of this event (PointerEvent.buttons semantics). */
+    readonly buttons: number;
+    readonly mods: InputMods;
+    /** Wheel deltas for kind:"wheel" (`pinch` = ctrl-wheel / trackpad zoom signal). */
+    readonly wheel?: {
+        readonly dx: number;
+        readonly dy: number;
+        readonly pinch: number;
+    };
+    /** GL-island opt-out (pinned widget-event contract, design-002 §8): fact still lands, recognizers skip. */
+    readonly surfaceHandled?: boolean;
+    /**
+     * Event timestamp (DOMHighResTimeStamp — the same clock rAF hands
+     * `engine.step`). Gesture timing anchors on THIS, not the processing frame:
+     * a stalled main thread (GC, cold paints) otherwise eats into hold windows —
+     * a 640 ms stall at pointerdown made long-press unreachable (2026-07-12
+     * field debugging). Absent ⇒ the processing frame's now.
+     */
+    readonly tMs?: number;
+}
+export declare const NO_MODS: InputMods;
+export interface InputQueue {
+    enqueue(event: InputEvent): void;
+    /** Drain in arrival order. Called ONLY by `pointerIngest`, once per tick. */
+    drain(): readonly InputEvent[];
+    /** Events waiting (telemetry/tests). */
+    size(): number;
+}
+export declare function createInputQueue(): InputQueue;

package/dist/types/packages/core/src/interaction/install.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Interaction-stack installation (design-002 §2 phase layout × design-003).
+ *
+ * Composable: `installInteractionCore` wires the M4 spine (L0 ingest, L2
+ * lifecycle + kinds + arbitration, ctl:claim, select/move behaviors, cleanup).
+ * Later slices (picking, snap, drop, resize, marquee, camera) install through
+ * their own module functions into the same phase groups — group order is the
+ * only ordering contract between them; within-group order is the design-003 §5
+ * in-phase order, so later installers pass explicit `before`-free appends in
+ * the documented sequence.
+ *
+ * The canvas-surface anchor entity is guaranteed here (design-001 §4: picking
+ * always resolves to SOMETHING; L0 ingest schedules on it).
+ */
+import type { Entity, World } from "@vibecook/strata-ecs";
+import { SpatialIndex } from "@ice/kernel";
+import { type CommitSink } from "../engine/commit-sink";
+import type { Engine } from "../engine/engine";
+import type { InputQueue } from "../input/queue";
+import { type SpawnProfiles } from "../systems/l2-recognize";
+import { type WirePreviewBuffer } from "../systems/l3-connect";
+import { type MarqueeBuffer } from "../systems/l3-marquee";
+/** Ensure the guaranteed pick-fallback entity exists (idempotent; outside tick). */
+export declare function ensureCanvasSurface(world: World): Entity;
+export interface InteractionCoreOpts {
+    readonly queue?: InputQueue;
+    readonly sink?: CommitSink;
+    readonly profiles?: SpawnProfiles;
+}
+export interface InteractionCore {
+    readonly queue: InputQueue;
+    readonly sink: CommitSink;
+    readonly canvasSurface: Entity;
+    /** Remove every installed system (HMR / doc switch). */
+    uninstall(): void;
+}
+export declare function installInteractionCore(engine: Engine, opts?: InteractionCoreOpts): InteractionCore;
+export interface InteractionStack extends InteractionCore {
+    /** The one spatial index (picking/snap/drop/marquee/wires/ports share it). */
+    readonly index: SpatialIndex<Entity>;
+    /** Marquee preview render buffer (out-of-ECS by design — design-003 §5.7). */
+    readonly marqueeBuffer: MarqueeBuffer;
+    /** Connect preview render buffer (out-of-ECS — design-004 §6; M8). */
+    readonly wirePreview: WirePreviewBuffer;
+    /** Nav-op seam (design-004 §7): forget spatialSync's last-known AABBs. */
+    clearCaches(): void;
+    /** L4 cursor readout for the DOM cursor reflector. */
+    readCursor(): string;
+}
+/**
+ * The FULL M4 stack. Not a wrapper over `installInteractionCore`: within-group
+ * order is registration order and design-003 §5's in-phase sequence
+ * (select → snap → move → drop → resize → marquee → camera) interleaves spine
+ * and non-spine systems, so the full installer registers everything itself in
+ * the documented order. `installInteractionCore` remains the spine-only slice
+ * (what the spine traces run against).
+ */
+export declare function installInteractionStack(engine: Engine, opts?: InteractionCoreOpts): InteractionStack;

package/dist/types/packages/core/src/nav/nested-canvas.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Nested canvas (design-004 §7 rev 2 — "the missing systems"; design-001
+ * §5.7/§5.8 catalog).
+ *
+ * - `Active` = derived membership tag: a widget is Active iff the FIRST
+ *   container ancestor on its `ChildOf` chain is the current nav frame
+ *   (at root: no container ancestor at all). Children of a deeper container
+ *   are that container's content — not Active until you enter it.
+ * - `activeMembership` (derive tick, before cull): recomputes membership and
+ *   flips Active/Visible/Culled CHANGE-ONLY. A nav switch is O(frame
+ *   content) tag flips — bounded, rare, migration-free. Boards without
+ *   containers converge to "everything Active" on the first pass and never
+ *   write again (M3–M7 demos unaffected).
+ * - Nav stack = SESSION entities: `NavEntry` rows carry NavDepth + NavCamera
+ *   (the camera to restore on exit) + NavFrame(entry→container). Root =
+ *   empty stack. Current frame = deepest live entry's NavFrame target.
+ * - `enterContainer`/`exitContainer` ops own the SPATIAL INDEX REBUILD:
+ *   membership flips don't move Transforms, so the incremental spatialSync
+ *   cache never fires on nav — the ops clear the index + caches and bump
+ *   `SpatialVersion`; spatialSync repopulates from the new Active set on the
+ *   next tick (its sweep-by-`seen` semantics make clear+repopulate exact).
+ * - `navIntegrity` (react tick, before picking): if the current frame's
+ *   container died (undo/remote — NavFrame edge auto-cleared), pop to the
+ *   nearest LIVE ancestor entry (skipping dead ones) or root, restore that
+ *   camera, rebuild. The recognizer-integrity pattern applied to nav.
+ * - Camera memory: enter saves the live camera on the pushed entry
+ *   (NavCamera) and applies the container's `ContainerCamera` rider (else
+ *   zoom-to-fit over the frame's content, else identity); exit writes the
+ *   rider back (per-user view memory; lost on undo-despawn — accepted) and
+ *   restores the entry's NavCamera.
+ */
+import type { Entity, TickSystem, World } from "@vibecook/strata-ecs";
+import type { SpatialIndex } from "@ice/kernel";
+/** Deepest live nav entry, or undefined at root. */
+export declare function currentNavEntry(world: World): Entity | undefined;
+/** The container the user is inside, or undefined at root. */
+export declare function currentNavFrame(world: World): Entity | undefined;
+export interface NestedCanvas {
+    readonly activeMembership: TickSystem;
+    readonly navIntegrity: TickSystem;
+    enterContainer(container: Entity): void;
+    exitContainer(): void;
+    /** Depth of the nav stack (0 = root). */
+    depth(): number;
+}
+export interface NestedCanvasOpts {
+    /** THE spatial index (nav ops clear it; spatialSync repopulates). */
+    readonly index: SpatialIndex<Entity>;
+    /**
+     * Clear spatialSync's private last-known cache alongside the index (the
+     * install seam wires this; without it the compare-and-skip would believe
+     * stale entries still exist).
+     */
+    readonly clearSpatialCaches: () => void;
+}
+/**
+ * The membership stamper alone — installed by `installWidgetRuntime` (before
+ * cull) so EVERY app partitions correctly, containers or not: a board with no
+ * containers converges to all-Active on the first pass and never writes again.
+ */
+export declare function createActiveMembership(world: World): TickSystem;
+export declare function createNestedCanvas(world: World, opts: NestedCanvasOpts): NestedCanvas;

package/dist/types/packages/core/src/ops/cascade.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Engine-owned destroy cascade (design-001 §5.1, §5.3, design-003 §5).
+ *
+ * strata clears an entity's edges on `tx.destroy` but does NOT recurse, so the
+ * engine walks containment itself: depth-first over `getReverse(e, ChildOf)`,
+ * destroying descendants before their parent, then the root. Wires are reified
+ * edge entities, so a wire whose `WireFrom`/`WireTo` endpoint dies is destroyed
+ * with it (reverse-index lookup, same transaction).
+ *
+ * The walk reads runtime world state via `getReverse`; `tx.destroy` only RECORDS
+ * (applied at seal / projection), so the reverse indices stay whole for the whole
+ * walk. A `visited` set guards against cycles and double-destroying a wire that
+ * touches two doomed endpoints.
+ */
+import type { Entity, World } from "@vibecook/strata-ecs";
+import type { Mutator } from "@vibecook/strata-ecs/durable";
+/** Depth-first destroy `root` and its `ChildOf` subtree + any wires bound to a destroyed entity. */
+export declare function cascadeDestroy(tx: Mutator, world: World, root: Entity): void;

package/dist/types/packages/core/src/ops/claims.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The DEFAULT divergence predicate for the live-write guard (design-001 §3):
+ * an entity's doc cells may diverge iff
+ *   - some recognizer in `GestureActive` currently `Captures` or `Drags` it, or
+ *   - it carries a live `TransformTween` (fly-back holds the claim after the
+ *     recognizer is reaped — design-003 review M3 / design-001 §3 amendment).
+ *
+ * This replaces the "inject a stub" posture (review finding A2): engines wire
+ * `createLiveWriter(world, { keyOf, mayDiverge: makeDefaultMayDiverge(world), … })`
+ * by default; tests and special hosts may still inject their own predicate.
+ * Discrete claims (`GestureRecognized`) deliberately do NOT grant divergence —
+ * design-001 §3 live-writes happen only under continuous Active gestures.
+ */
+import type { Entity, World } from "@vibecook/strata-ecs";
+export declare function makeDefaultMayDiverge(world: World): (e: Entity) => boolean;

package/dist/types/packages/core/src/ops/gestures.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Gesture ops — app-handler write paths (design-003 §2/§8).
+ *
+ * `cancelActiveGestures` sets the ONE-TICK CancelRequest resource: escape, tool
+ * switch, and doc detach all converge here; the ctl:spawn sweep transitions
+ * every non-terminal recognizer → Cancelled next tick, behaviors restore from
+ * riders, and cleanup clears the flag.
+ */
+import type { World } from "@vibecook/strata-ecs";
+export declare function cancelActiveGestures(world: World): void;

package/dist/types/packages/core/src/ops/point-pick.d.ts

@@ -0,0 +1,42 @@
+/**
+ * THE point-pick (Law 15: the spatial index is the only hit path; this
+ * function is its only narrow-phase). Shared verbatim by the in-tick
+ * `picking` system (L1, via SystemCtx) and the pointer router's synchronous
+ * event-time pick (design-004 §4 GL path, via World — world reads outside
+ * the tick are verified-unrestricted). One implementation so the two can
+ * never disagree on ordering.
+ *
+ * Priority: HandleSpec chrome first (nearest edge), then widgets by StackZ
+ * descending. Deliberately NOT plane-stratified: cross-plane z is stratified
+ * visually (P2 GL composites above P1 DOM), but pick order is StackZ across
+ * all surfaces — design-004 §1 names the mixed-overlap consequence and
+ * accepts it; do not "fix" it here.
+ */
+import type { Component, Entity } from "@vibecook/strata-ecs";
+import type { Cubic, SpatialIndex } from "@ice/kernel";
+/** Structural reads both `World` and `SystemCtx` provide. */
+export interface PickReader {
+    isAlive(e: Entity): boolean;
+    has(e: Entity, c: Component): boolean;
+    hasTag(e: Entity, t: import("@vibecook/strata-ecs").Tag): boolean;
+    get<S>(e: Entity, c: Component<S>): S | undefined;
+}
+/** Wire narrow-phase source: cached cubics from wireSync (M8). */
+export interface WirePickSource {
+    cubicOf(e: Entity): Cubic | undefined;
+    /** Pick slop in WORLD units (screen slop / zoom, caller-converted). */
+    readonly slopWorld: number;
+}
+/** Distance from a point to the nearest edge of an AABB (0 iff inside). */
+export declare function distPointToBox(px: number, py: number, minX: number, minY: number, maxX: number, maxY: number): number;
+/**
+ * Top pick under a world point within `rWorld` (point-in-box when 0).
+ * Tier order (design-003 §3, amended for M8): HandleSpec chrome → PORT
+ * entities (interaction affordances sit atop their widget edge) → widgets by
+ * StackZ → WIRES (render in P0 under content; pick below widgets, above
+ * canvas — render order and pick order agree). The canvas fallback stays the
+ * caller's. Wires narrow-phase against their cached cubic (`wires` source;
+ * without one, wire entries are skipped — coarse AABB hits would make fat
+ * bounding boxes steal canvas taps).
+ */
+export declare function pickTopAt(reader: PickReader, index: SpatialIndex<Entity>, wx: number, wy: number, rWorld: number, wires?: WirePickSource): Entity | undefined;

package/dist/types/packages/core/src/ops/port-geometry.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Port-slot resolution: a widget's port DECLARATIONS (from the widget registry,
+ * design-005 §2) → kernel `PortSlot`s (side + even-distribution index/count).
+ *
+ * The single source of a port's world anchor is the kernel's pure
+ * `portAnchor(widgetRect, slot)` — geometry NEVER reads a port ENTITY (design-001
+ * §5.3), so wires, the connect preview, and materialized-port anchors all agree
+ * by construction and culled endpoints resolve for free. Ports sharing a side are
+ * numbered by their declared `index` when given, else by declaration order; the
+ * side's `count` drives the even spacing.
+ */
+import type { PortSlot } from "@ice/kernel";
+import type { WidgetPortDecl } from "../widget/define-widget";
+/** Map every declared port id → its `PortSlot` (side/index/count for even spacing). */
+export declare function portSlots(decls: readonly WidgetPortDecl[]): Map<string, PortSlot>;
+/** The `PortSlot` for one port id (undefined if the widget declares no such port). */
+export declare function portSlotOf(decls: readonly WidgetPortDecl[], portId: string): PortSlot | undefined;

package/dist/types/packages/core/src/ops/selection.d.ts

@@ -0,0 +1,14 @@
+import type { Entity, World } from "@vibecook/strata-ecs";
+export type SelectionMode = "replace" | "toggle" | "add";
+/** All entities currently carrying the `Selected` rider. */
+export declare function selectedEntities(world: World): Entity[];
+/**
+ * Apply a selection.
+ *  - `replace`: exactly `entities` end up selected (others cleared).
+ *  - `toggle`: flip each of `entities`.
+ *  - `add`: union `entities` into the current selection.
+ * `onChange` fires once, only if a tag actually flipped.
+ */
+export declare function setSelection(world: World, entities: Iterable<Entity>, mode: SelectionMode, onChange?: () => void): void;
+/** Clear the whole selection. `onChange` fires once, only if something was selected. */
+export declare function clearSelection(world: World, onChange?: () => void): void;

package/dist/types/packages/core/src/presence/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @ice/core presence layer (design-005 §6.5, design-001 §5.6) — attach, publish,
+ * remote-cursor projection, and the install seam.
+ */
+export { attachPresence, DEFAULT_PRESENCE_TTL_MS, type PresenceOpts, type PresenceSession, } from "./presence-kit";
+export { createPresencePublish, type PresencePublishOpts } from "./publish";
+export { createRemoteCursorsSystem, installPresence, type InstallPresenceOpts, } from "./remote-cursors";

package/dist/types/packages/core/src/presence/presence-kit.d.ts

@@ -0,0 +1,39 @@
+import type { Entity, World } from "@vibecook/strata-ecs";
+import { type EphemeralSource, type EphemeralStore } from "@vibecook/strata-ecs/ephemeral";
+/** Default per-entry TTL — a presence entity self-expires this long after its last keepalive. */
+export declare const DEFAULT_PRESENCE_TTL_MS = 5000;
+export interface PresenceOpts {
+    /** SESSION-unique peer id (006 B5). Defaults to `crypto.randomUUID()`. */
+    readonly peerId?: string;
+    /** Display name — must be real (bare, no default). */
+    readonly name: string;
+    /** Display color — must be real (bare, no default). */
+    readonly color: string;
+    /** Per-entry TTL (design §15.3), default {@link DEFAULT_PRESENCE_TTL_MS}. */
+    readonly ttlMs?: number;
+}
+export interface PresenceSession {
+    /** This session's peer id (the ephemeral partition prefix). */
+    readonly peerId: string;
+    /** The writer-partitioned Mutator for this peer's own presence entities. */
+    readonly eph: EphemeralStore;
+    /** The local peer entity (facets: PresenceInfo + PresencePeer + Local; cursor/selection added by publish). */
+    readonly localPeer: Entity;
+    /**
+     * The LoroEphemeralSnapshot surface. INBOUND presence bytes go through
+     * `wire.apply(bytes)`; the encoders (`encodeChanged`/`encodeKeys`/…) are
+     * driven by the binding's own timers — do not call them externally.
+     */
+    readonly wire: EphemeralSource;
+    /** Subscribe to the binding's OUTBOUND presence bytes (its two timers). Returns an unsubscribe. */
+    onOutbound(fn: (bytes: Uint8Array) => void): () => void;
+    /** Leave (ship tombstones) then tear down the binding + destroy the owned Loro store. Idempotent. */
+    detach(): void;
+}
+/**
+ * Attach an ephemeral presence layer to `world`. The returned session owns the
+ * Loro store; the app (or the bootstrap kit) wires `wire.apply` / `onOutbound`
+ * to a byte channel and installs the publish hook + remote-cursor system via
+ * {@link installPresence}.
+ */
+export declare function attachPresence(world: World, opts: PresenceOpts): PresenceSession;

package/dist/types/packages/core/src/presence/publish.d.ts

@@ -0,0 +1,14 @@
+import type { Entity, World } from "@vibecook/strata-ecs";
+import type { PublishHook } from "../engine/engine";
+import type { PresenceSession } from "./presence-kit";
+export interface PresencePublishOpts {
+    /** Durable key for a selected entity — the doc session's `store.keyOf`. Absent ⇒ no keys carried. */
+    readonly keyOf?: (e: Entity) => string | undefined;
+    /** Max selection keys carried (default {@link SELECTION_KEY_CAP}). */
+    readonly maxKeys?: number;
+}
+/**
+ * Build the publish hook that maintains `session.localPeer`'s cursor + selection
+ * facets. Register it with `engine.onPublish` (installPresence does this).
+ */
+export declare function createPresencePublish(world: World, session: PresenceSession, opts?: PresencePublishOpts): PublishHook;

package/dist/types/packages/core/src/presence/remote-cursors.d.ts

@@ -0,0 +1,18 @@
+import type { TickSystem, World } from "@vibecook/strata-ecs";
+import type { Engine } from "../engine/engine";
+import { type PresencePublishOpts } from "./publish";
+import type { PresenceSession } from "./presence-kit";
+/**
+ * The derive tick system that pools + reaps remote cursor entities. `world` is
+ * unused directly (iteration goes through `ctx`), kept for factory symmetry with
+ * the other `create*System(world)` builders.
+ */
+export declare function createRemoteCursorsSystem(_world: World): TickSystem;
+export type InstallPresenceOpts = PresencePublishOpts;
+/**
+ * Wire a presence session into an engine: the publish hook (outbound facet
+ * derivation) + the remote-cursor derive system. Returns an uninstall that
+ * removes both. Does NOT own the session's lifecycle — call `session.detach()`
+ * separately.
+ */
+export declare function installPresence(engine: Engine, session: PresenceSession, opts?: InstallPresenceOpts): () => void;

package/dist/types/packages/core/src/schema/meta.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Schema metadata registry (design-001 §2, design-005 §1).
+ *
+ * Components/tags/relations stay PURE (rev-2 sovereignty) — but prefab
+ * validation (eid ban, required-field defaults) and devtools badges need to
+ * know what a component's fields look like. strata does not expose schema
+ * introspection publicly, so ALL engine + userland definitions go through
+ * these thin wrappers: they record the raw schema in a side registry, then
+ * delegate to strata unchanged. The returned handles are strata's own.
+ */
+import { defineComponent as strataDefineComponent, defineResource as strataDefineResource, type Component, type FieldInput, type Relation, type Resource, type Tag } from "@vibecook/strata-ecs";
+export type RawSchema = Record<string, FieldInput>;
+export interface ComponentMeta {
+    name: string;
+    schema: RawSchema;
+    /** Field names whose type is `eid` (runtime-local handles — banned in durable cells). */
+    eidFields: string[];
+    /** Field names with no default (strata requires them at spawn). */
+    requiredFields: string[];
+}
+export interface RelationMeta {
+    name: string;
+    arity: "one" | "many";
+}
+export interface ResourceMeta {
+    name: string;
+    /** design-001 §2 rule 7: resources declare durable|runtime at definition. */
+    durable: boolean;
+}
+export declare function defineComponent<const Sch extends RawSchema>(name: string, schema: Sch): ReturnType<typeof strataDefineComponent<Sch>>;
+export declare function defineTag(name: string): Tag;
+export declare function defineRelation(name: string, opts?: {
+    arity?: "one" | "many";
+}): Relation;
+export declare function defineResource<const Sch extends RawSchema>(name: string, schema: Sch, opts?: {
+    durable?: boolean;
+}): ReturnType<typeof strataDefineResource<Sch>>;
+export declare const schemaMeta: {
+    component(c: Component): ComponentMeta | undefined;
+    tagName(t: Tag): string | undefined;
+    relation(r: Relation): RelationMeta | undefined;
+    resource(r: Resource): ResourceMeta | undefined;
+};

package/dist/types/packages/core/src/schema/prefab.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Prefabs — sovereignty at the entity level (design-001 §2, rev 2).
+ *
+ * A prefab declares an entity kind's ESSENTIAL component set, its
+ * durable-ELIGIBLE extras, and its class; the class IS the spawn path:
+ *   durable → tx.spawn · runtime → world/ctx.spawn · ephemeral → eph.spawn
+ *
+ * Validation set (design-005 §1, all DEV-throw at definition time):
+ *  - eligible components eid-free (durable prefabs)
+ *  - every essential component's required fields supplied by its init value
+ *  - ephemeral prefabs: components + tags only (no relations)
+ *  - owner:"derive" only on runtime prefabs
+ *  - prefab ids unique
+ */
+import type { Component, Entity, EntityKey, Relation, Tag } from "@vibecook/strata-ecs";
+/** Durable identity stamp (design-001 §2 rule 5) — subsumes WidgetType. */
+export declare const PrefabId: Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly id: "string";
+}>, {
+    readonly id: "string";
+}>;
+export type PrefabClass = "durable" | "runtime" | "ephemeral";
+/** Scalar shapes strata accepts as field writes at spawn. */
+export type FieldWrite = string | number | boolean | Entity | EntityKey | null;
+export type ComponentInit = readonly [Component, Record<string, FieldWrite>];
+/**
+ * Typed component-init pair: `init(Position, { x: 0, y: 0 })` gets full
+ * compile-time field checking (missing/extra/mistyped fields error) before
+ * erasing to the registry's loose `ComponentInit`. Prefer this in every
+ * prefab definition and instantiate override; raw pairs remain legal for
+ * dynamic construction (review finding B4).
+ */
+export declare function init<S extends Record<string, FieldWrite>>(c: Component<S>, v: S): ComponentInit;
+export interface PrefabDef {
+    store: PrefabClass;
+    /** Essential set: spawned with, committed for durable prefabs. */
+    components: readonly ComponentInit[];
+    tags?: readonly Tag[];
+    /** Durable-eligible beyond essential (attachable later via tx); facets for ephemeral. */
+    optional?: readonly Component[];
+    /** Eligible outgoing relations (durable prefabs; runtime relations are unrestricted). */
+    relations?: readonly Relation[];
+    /** Write-ownership badge (devtools) — runtime prefabs only. */
+    owner?: "derive";
+    /**
+     * Pack version for the document version gate (design-001 §5.2, design-005
+     * §6.3): stamped as an `engine.pack.<id>.<v>` marker key at doc creation and
+     * compared at open. Bump when the prefab's durable shape changes. Default 1.
+     */
+    version?: number;
+}
+export interface Prefab extends PrefabDef {
+    id: string;
+    /** Eligible component set = essential ∪ optional ∪ {PrefabId}. */
+    eligible: ReadonlySet<Component>;
+    eligibleRelations: ReadonlySet<Relation>;
+}
+export declare function definePrefab(id: string, def: PrefabDef): Prefab;
+export declare const prefabs: {
+    get(id: string): Prefab | undefined;
+    /** Every registered prefab (the version gate stamps/compares the full set). */
+    all(): Prefab[];
+};
+/**
+ * TEST-ONLY registry wipe. Deliberately a standalone export that the public
+ * barrel does NOT re-export (review finding A8) — tests import it from this
+ * module path directly.
+ */
+export declare function __resetPrefabsForTests(): void;

package/dist/types/packages/core/src/settings/defaults.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Runtime default constants transcribed from the reviewed design docs.
+ * Not exported from the package barrel yet (design-005 §4 engine facade wires these in later).
+ */
+/** Recognizer timing/slop defaults (design-003 §4.2 kind table; inertia constants from §5 item 9; multi-tap from v2 gesture.ts). */
+export declare const GESTURE_DEFAULTS: {
+    readonly tapMaxMs: 250;
+    readonly tapSlopPx: 8;
+    readonly longPressMs: 500;
+    readonly longPressSlopPx: 10;
+    readonly dragSlopPx: 10;
+    readonly pinchSlopPx: 6;
+    readonly wheelEndSilenceMs: 150;
+    readonly inertiaMinVelocityPxPerS: 120;
+    readonly inertiaDecayMs: 325;
+    readonly multiTapWindowMs: 280;
+    readonly multiTapSlopPx: 20;
+};
+/** Pick radii + retarget dead-band (design-003 §3 L1 targeting). */
+export declare const POINTER_DEFAULTS: {
+    readonly radiusMousePx: 0;
+    readonly radiusTouchPx: 12;
+    readonly radiusPenPx: 4;
+    readonly hoverReleaseDeadBandPx: 4;
+};
+/**
+ * Wire/port picking geometry (design-003 §3 wires-below-widgets; design-004 §6).
+ * `wirePickSlopPx` is added to the pointer radius (screen px, `/zoom` at use) so a
+ * thin bezier stays grab-able; `portIndexHalfWorld` is the half-extent of the tiny
+ * world AABB a materialized port occupies in the spatial index (design-004 §6 —
+ * ports are pickable but carry no Position/Size, so spatialSync never sees them).
+ */
+export declare const GRAPH_PICK_DEFAULTS: {
+    readonly wirePickSlopPx: 8;
+    readonly portIndexHalfWorld: 6;
+};
+/** SnapConfig resource defaults (design-005 §4 engine facade). */
+export declare const SNAP_DEFAULTS: {
+    readonly enabled: true;
+    readonly thresholdPx: 5;
+};
+/** Zoom clamp (design-003 §5 item 9 cameraControl) and frame dt clamp (design-002 §1). */
+export declare const CAMERA_DEFAULTS: {
+    readonly minZoom: 0.1;
+    readonly maxZoom: 5;
+    readonly dtClampMs: 64;
+};
+/** Widget/FBO/port budgets (design-004 §2 host pipeline, §3 FBO pool, §6 port materialization; ported into design-005 §4 engine facade). */
+export declare const RUNTIME_BUDGETS: {
+    readonly keepMountedWidgets: 256;
+    readonly fboBytes: 268435456;
+    readonly portSpawnPerFrame: 64;
+    readonly portLightUpRadiusPx: 600;
+    readonly portReapGraceMs: 1000;
+    readonly cullOverscanWorldPerZoom: 200;
+};

package/dist/types/packages/core/src/systems/camera-sim.d.ts

@@ -0,0 +1,19 @@
+import type { System, TickSystem, World } from "@vibecook/strata-ecs";
+/**
+ * Runtime pan-inertia velocity (screen px/s), seeded by `cameraControl` at pan
+ * release and decayed by `cameraInertia`. A resource (not closure state) so
+ * devtools sees it and there is no hidden singleton (design-003 §9).
+ */
+export declare const CameraInertia: import("@vibecook/strata-ecs").Resource<import("@vibecook/strata-ecs").ValueOf<{
+    readonly vx: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly vy: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+}>, {
+    readonly vx: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly vy: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+}>;
+export interface CameraSystems {
+    cameraControl: TickSystem;
+    cameraInertia: TickSystem;
+    tweenSystem: System;
+}
+export declare function createCameraSystems(world: World): CameraSystems;