@vibecook/ice 0.10.0 → 0.14.0

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

@@ -3,7 +3,7 @@
  * scene systems · doc kit · publish step · engine facade · reflector registry.
  * Import wall: strata-ecs + @ice/kernel ONLY — never react/dom/three (enforced).
  */
-export declare const CORE_VERSION = "0.10.0";
+export declare const CORE_VERSION = "0.11.0";
 export { defineSchemaOnce, hmrInvalidateOnSchemaChange } from "./boot/hmr";
 export { All, Any, Not, Related, createWorld, defineQuery, defineSystem, defineTickSystem, enumOf, field, Local, } from "@vibecook/strata-ecs";
 export type { Batch, Component, Condition, Entity, OrderPlace, Pipeline, Query, Relation, Resource, System, SystemCtx, Tag, TickSystem, World, } from "@vibecook/strata-ecs";
@@ -14,10 +14,12 @@ export { FrameInfo, setFrameInfo } from "./engine/frame-info";
 export { createPipelineRegistry, PHASE_GROUPS, type AnySystem, type PhaseGroup, type PipelineRegistry } from "./engine/pipeline";
 export { createReflectorRegistry, type ReflectorDef, type ReflectorObserve, type ReflectorQuerySpec, type ReflectorRegistry, } from "./engine/reflectors";
 export { createEngine, type Engine, type EngineOpts, type FrameTelemetry, type PublishHook, type SystemRunRecord, } from "./engine/engine";
-export { createFrameControl, SETTLE_CAP, type FrameControl } from "./engine/frame-control";
+export { createFrameControl, SETTLE_CAP, SLEEP_TAIL, type FrameControl, type SleepStats } from "./engine/frame-control";
+export { interactionPending } from "./interaction/wakes";
 export { createGuestRegistry, GUEST_BUDGET, type GuestFactory, type GuestFrame, type GuestGeneration, type GuestInstance, type GuestLedgerRecord, type GuestRegistry, type GuestRegistryOpts, type GuestRun, type GuestSpec, type GuestStatus, } from "./engine/guests";
 export { behaviors, defineBehavior, describeBehavior } from "./behavior/define-behavior";
-export type { BehaviorRegistrationOptions } from "./behavior/runtime";
+export { createBehaviorRuntime } from "./behavior/runtime";
+export type { BehaviorPresence, BehaviorRegistrationOptions, BehaviorRuntime, BehaviorRuntimeOpts, BehaviorSession, } from "./behavior/runtime";
 export { BEHAVIOR_DEFAULT_PHASE, BEHAVIOR_PHASES, type AnyBehaviorAttachSpec, type AnyBehaviorDef, type BehaviorAttachSpec, type BehaviorChanges, type BehaviorCtxBase, type BehaviorCtxFor, type BehaviorDescription, type BehaviorFrame, type BehaviorHandle, type BehaviorHookName, type BehaviorHooks, type BehaviorPhase, type BehaviorPropDescription, type BehaviorQuery, type BehaviorQuerySpec, type BehaviorRead, type BehaviorReadDescription, type BehaviorSchema, type BehaviorSpec, type BehaviorStore, type BehaviorTx, type BehaviorWorld, type DataOf, type DurableBehaviorCtx, type EphemeralBehaviorCtx, type PeerFacet, type RuntimeBehaviorCtx, } from "./behavior/types";
 export { compileBehavior, isDurableEligible, type CompiledBehavior } from "./behavior/compile";
 export { behaviorMarkerKey, classifyBehaviorVersion, docBehaviorVersion, stampBehaviorMarker, BEHAVIOR_MARKER_PREFIX, type BehaviorMeta, type BehaviorVerdict, } from "./behavior/migrate";
@@ -49,31 +51,50 @@ export { createWireSync, type WireSyncSystem } from "./systems/l1-wires";
 export { createPortMaterialize } from "./systems/l3-ports";
 export { createConnectSystems, type ConnectSystems, type WirePreviewBuffer, } from "./systems/l3-connect";
 export { ENGINE_SCHEMA_VERSION, ENVELOPE_MAGIC, ENVELOPE_VERSION, EnvelopeError, decodeEnvelope, encodeEnvelope, type EnvelopeHeader, } from "./doc/envelope";
-export { gateVerdict, readDocVersionReport, stampEngineMeta, type DocVersionReport, type GateVerdict, } from "./doc/version-gate";
-export { createDocCommitSink, createReadOnlyCommitSink } from "./doc/doc-commit-sink";
+export { gateVerdict, readEnvelopeVersionReport, readDocVersionReport, stampEngineMeta, type DocVersionScope, type DocVersionReport, type GateVerdict, } from "./doc/version-gate";
+export { type CommitExtender, createDocCommitSink, createReadOnlyCommitSink } from "./doc/doc-commit-sink";
 export { DurableUndoStatus } from "@vibecook/strata-ecs/durable";
 export type { DurableUndoStatusValue } from "@vibecook/strata-ecs/durable";
 export { createDocSession, openDocSession, type DocSession, type DocSessionOpts, type OpenDocResult, } from "./doc/doc-kit";
 export { runMigrations, type MigrationCtx, type MigrationOutcome } from "./doc/migrate";
 export { p, type JsonShape, type PropSpec, type PropsDecl, type StandardSchemaV1 } from "./widget/props";
-export { WidgetEquipped, defineWidget, renames, widgets, type SizeMode, type WidgetDef, type WidgetGroup, type WidgetInteraction, type WidgetPortDecl, type WidgetBehaviorDecl, type WidgetBehaviorEntry, type WidgetRename, type WidgetRenameEntry, type WidgetSurface, type WidgetType, } from "./widget/define-widget";
+export { WidgetEquipped, defineWidget, renames, widgets, type WidgetDef, type WidgetGroup, type WidgetInteraction, type WidgetContainerDef, type WidgetContainerEntry, type WidgetPortalInsets, type WidgetPortDecl, type WidgetBehaviorDecl, type WidgetBehaviorEntry, type WidgetRename, type WidgetRenameEntry, type WidgetType, type TrayEntry, trayTakeProps, } from "./widget/define-widget";
+export { type HeldGlyph, type HeldToolApi, type HeldToolDef, isHeldGlyph, type KeyChord, keyMatches, matchHeldTool } from "./widget/held-tools";
+export { type MenuActionApi, type MenuActionDef, menuActionsFor } from "./widget/menu-actions";
+export { DefaultCanvasType, ROOT_CANVAS_META_KEY, canvasIdentityOf, canvasPackId, canvasTypes, contributeCanvasCatalog, defineCanvasType, encodeCanvasIdentity, parseCanvasIdentity, sameCanvasIdentity, type CanvasCatalogSection, type CanvasCatalogContribution, type CanvasPlacementDef, type CanvasType, type CanvasTypeDef, type CanvasTypeIdentity, } from "./canvas/define-canvas-type";
+export { defineContainer, type ContainerDef, type ContainerIngressDef, } from "./canvas/define-container";
+export { bindEngineCatalog, compileEngineCatalog, dataPrefabFor, durablePrefabFor, engineCatalogFor, resolveToolFor, toolTypeFor, widgetTypeFor, type EngineCatalog, type EngineCatalogCompileOpts, } from "./canvas/engine-catalog";
+export { createPlacementAuthority, type PlacementAuthority, type PlacementAuthorityOpts, type PlacementDecision, type PlacementReason, } from "./canvas/placement";
+export { CanvasIntentScope, CanvasSession, createCanvasSessionController, type CanvasSessionController, type CanvasSessionValue, } from "./canvas/session";
+export { collectCanvasDiagnostics, type CanvasDiagnostic, type CanvasDiagnosticCode, type CanvasDiagnosticSnapshot, } from "./canvas/diagnostics";
+export { resolveFrameChildren, resolveFrameView, resolvePortal, type CanvasRect, type FrameChildrenOpts, type ResolvedFrameView, type ResolvedPortal, } from "./canvas/frame-view";
+export { defineFrameProjection, frameProjections, type CanvasPreviewDeclaration, type FrameProjection, type FrameProjectionChildRef, type FrameProjectionContext, type FrameProjectionDef, type FrameProjectionRelationRow, } from "./canvas/frame-projection";
+export { createFramePreviewStore, FRAME_PREVIEW_DEFAULT_BYTES, FRAME_PREVIEW_DEFAULT_CHILDREN, FRAME_PREVIEW_MAX_BYTES, FRAME_PREVIEW_MAX_CHILDREN, FRAME_PREVIEW_MIN_BYTES, type FramePreviewBudgets, type FramePreviewChild, type FramePreviewSnapshot, type FramePreviewStats, type FramePreviewStore, type FramePreviewStoreOpts, type FramePreviewValidity, } from "./canvas/frame-preview";
+export { createPresentationTransitionCoordinator, type FrameSwitchDescriptor, type FrameSwitchRequest, type PreparedFrameSwitch, type PresentationMotion, type PresentationPlane, type PresentationReleaseReason, type PresentationRetainer, type PresentationTransitionAdapter, type PresentationTransitionCoordinator, type PresentationTransitionFrame, type PresentationTransitionStats, } from "./canvas/presentation-transition";
+export { canvasRuntimeExtensions, defineCanvasRuntimeExtension, defineFrameBehavior, frameBehaviorPackId, frameBehaviors, type CanvasReadFacet, type CanvasRuntimeChanges, type CanvasRuntimeExtension, type CanvasRuntimeExtensionContext, type CanvasRuntimeExtensionDef, type CanvasScopedReader, type CanvasSemanticMigration, type CanvasSemanticMigrationContext, type ExistingPlacementPosture, type FrameBehavior, type FrameBehaviorDef, type FrameBehaviorWriteContext, } from "./canvas/extensions";
 export { createWidgetEquipSystem } from "./widget/equip";
 export { attachSpawnBehaviors, attachSpawnParent, spawnWidget, widgetSpawnInits, type SpawnWidgetOpts } from "./widget/spawn";
+export type { FramePickSlot, FramePickSource } from "./systems/l1-pick";
 export { setWidgetProps } from "./widget/set-props";
-export { createWidgetRuntime, installWidgetRuntime, type MountEntry, type WidgetMountStore, type WidgetRuntime, } from "./widget/mount-store";
+export { createWidgetRuntime, installWidgetRuntime, type WidgetRuntime } from "./widget/mount-store";
 export * from "./settings/defaults";
-export * from "./settings/ground-config";
-export { CameraInertia, createCameraSystems, type CameraSystems } from "./systems/camera-sim";
+export { CameraInertia, WheelZoomStep, createCameraSystems, type CameraSystems } from "./systems/camera-sim";
 export { restoreAutosave, startAutosave, type Autosave, type AutosaveOpts, type AutosaveState, type AutosaveStatus, type AutosaveStorageRead, type AutosaveStorageWrite, type CancelScheduled, type RestoreResult, } from "./doc/autosave";
 export { attachBroadcastRelay, type BroadcastRelay, type BroadcastRelayOpts, type RelayChannel, } from "./doc/broadcast-relay";
-export { createMeasureQueue, type MeasureEvent, type MeasureQueue } from "./input/measure-queue";
-export { createMeasureIngest } from "./systems/measure-ingest";
 export { createBreakpointSystem, createSelectionChromeSystem } from "./systems/chrome";
 export { createActiveMembership, createNestedCanvas, currentNavEntry, currentNavFrame, type NavOpts, type NestedCanvas, type NestedCanvasOpts, } from "./nav/nested-canvas";
-export { abortNavFlight, createNavFlight, navFlightActive, NavTransition, startNavFlight, } from "./systems/nav-flight";
+export { defaultArrivalCamera, fallbackNavFace, type NavFace, type NavGeometrySlot, type NavGeometrySource, NavIntent, NavRedress, resolveNavFace, smoothstep, staticFace, } from "./nav/nav-geometry";
+export { createNavTap, NavTapMemo, type NavTapOpts } from "./systems/nav-tap";
+export { createHeldInput, heldEntity, HOLD_INPUT, type HeldPoseSlot, type HeldPoseSource, type HeldScreenFrame } from "./systems/held";
+export { createPressWheel } from "./systems/press-wheel";
+export { createTrayInput, createTrayLay, hungTypes, scrollBy, specimensOf, TRAY_INPUT, type TrayPoseSlot, type TrayPoseSource, type TrayScreenFrame } from "./systems/tray";
+export { closeTray, ensureTray, openTray, scrollTray, setTrayCategory, toggleTray, trayCategories, trayCategory, type TrayCategory, trayEntity, trayEntryCount, trayOpen } from "./ops/tray";
+export { createZoomThrough, type ZoomThroughOpts } from "./systems/zoom-through";
+export { abortNavFlight, createNavFlight, departedCameraOf, type DepartedCameraInputs, navFlightActive, NavTransition, publishNavCut, startNavFlight, type NavTransitionIdentity, } from "./systems/nav-flight";
 export { attachPresence, createPresencePublish, createRemoteCursorsSystem, DEFAULT_PRESENCE_TTL_MS, installPresence, type InstallPresenceOpts, type PresenceOpts, type PresencePublishOpts, type PresenceSession, } from "./presence";
 export { joinDoc, offerBase, type BootstrapClock, type JoinDocOpts, type JoinResult, } from "./doc/bootstrap";
 export { broadcastChannelByteChannel, webSocketByteChannel, type ByteChannel, type OwnedByteChannel, type WebSocketLike, } from "./doc/channels";
 export { createDrawTool, defineTool, tools, type CanvasDragRoute, type Tool, type ToolDef, type ToolGates, type ToolRoute, type WidgetDragRoute, } from "./tools/define-tool";
-export { createCanvasEngine, type CanvasDocs, type CanvasEngine, type CanvasEngineOpts, type StageControl, type CanvasOps, } from "./facade/create-canvas-engine";
+export { createCanvasEngine, type CanvasDocs, type CanvasEngine, type CanvasEngineOpts, type CurrentCanvasScope, type StageControl, type CanvasOps, } from "./facade/create-canvas-engine";
 export { createDrawBehavior } from "./systems/l3-draw";
+export { acquireCompositorDevice, GpuUnavailableError, type AcquireDeviceOpts, type EngineGpu, type GpuUncapturedError, } from "./surface/gpu-device";

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

@@ -6,7 +6,9 @@
  * 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.
+ * system reads it, nothing observes it, and it holds nothing across a drain but
+ * the tail ingest hands back — the events past a pointer's transition, which
+ * are the next tick's facts (l0-input.ts, the fold's cut).
  *
  * Pointer identity: `pointerId` is the adapter's stable string for a device
  * pointer — `"mouse"` for the one mouse, `"touch:<n>"` per touch contact,

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

@@ -17,15 +17,26 @@ import { SpatialIndex } from "../../../kernel/src/index";
 import { type CommitSink } from "../engine/commit-sink";
 import type { Engine } from "../engine/engine";
 import type { InputQueue } from "../input/queue";
+import { type FramePickSlot } from "../systems/l1-pick";
 import { type SpawnProfiles } from "../systems/l2-recognize";
 import { type WirePreviewBuffer } from "../systems/l3-connect";
+import { type DropPlacementPolicy } from "../systems/l3-drop";
 import { type MarqueeBuffer } from "../systems/l3-marquee";
+import { type HeldPoseSlot } from "../systems/held";
+import { type TrayPoseSlot } from "../systems/tray";
+import type { NavGeometrySlot } from "../nav/nav-geometry";
 /** 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;
+    /** Typed Canvas SDK placement truth; omission retains compatibility cells. */
+    readonly placement?: DropPlacementPolicy;
+    /** Is this entity a container the engine may ENTER (the facade's catalog-backed test; design-015 §9's gesture and zoom-through)? Default: the `Container` tag. */
+    readonly isContainer?: (entity: Entity) => boolean;
+    /** Is this entity an object that OPENS (design-015 §8's double-tap; the facade's catalog-backed test — its type declares `openable`)? Default: nothing opens. */
+    readonly isOpenable?: (entity: Entity) => boolean;
 }
 export interface InteractionCore {
     readonly queue: InputQueue;
@@ -42,6 +53,25 @@ export interface InteractionStack extends InteractionCore {
     readonly marqueeBuffer: MarqueeBuffer;
     /** Connect preview render buffer (out-of-ECS — design-004 §6; M8). */
     readonly wirePreview: WirePreviewBuffer;
+    /** The frame pick source's slot (design-014, B3b): the ground layer sets `current` at mount, clears it at dispose. */
+    readonly framePick: FramePickSlot;
+    /**
+     * The nav geometry seam (design-015 §9; D2b) beside `framePick`: the renderer's word on a
+     * container's DRAWN face, the inside's arrival and the exact cut camera — core's nav, the
+     * zoom-through and the drop-into read it when set; the renderer sets it at mount, clears it at dispose.
+     */
+    readonly navGeometry: NavGeometrySlot;
+    /**
+     * The held pose seam (design-015 §8; D4b) beside the two above: the renderer's word on where the object in
+     * hand is ON SCREEN this frame, through which every pointer is mapped while something is held; the renderer
+     * sets it at mount, clears it at dispose.
+     */
+    readonly heldPose: HeldPoseSlot;
+    /**
+     * The tray pose seam (design-017 §4; K3) beside `heldPose`: the renderer's word on where the pegboard drawer is ON SCREEN this
+     * frame (its rect mid-slide, its scroll range), which the tray's input hit-tests and clamps by; set at mount, cleared at dispose.
+     */
+    readonly trayPose: TrayPoseSlot;
     /** Nav-op seam (design-004 §7): forget spatialSync's last-known AABBs. */
     clearCaches(): void;
     /** L4 cursor readout for the DOM cursor reflector. */

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

@@ -0,0 +1,24 @@
+/**
+ * THE INTERACTION STACK'S REGISTERED WAKE (2026-09-27, ICE M21 K7a — engine/frame-control.ts's sleep). A sleeping loop asks
+ * after every step when the stack is next due; it is due EVERY frame while any of its time-driven work is pending, and
+ * otherwise never on its own (the next input wakes the loop through the queue). Each pending state is a fact in the world
+ * (the engine's law: all interaction state lives there), read O(1) — a queue's length, a resource, `firstOf` a query:
+ *  - input waiting in the queue;
+ *  - a gesture RECOGNIZER alive (systems/l2-recognize.ts): a press held (the long-press timer), a tap's multi-tap window
+ *    after its release, a drag, a pinch, a wheel gesture's end silence (`wheelEndSilenceMs`) — each reaped once it ended;
+ *  - the camera gesturing, or its inertia still moving (systems/camera-sim.ts `cameraInertia`);
+ *  - a transform tween running (`TransformTween`, camera-sim.ts `tweenSystem`);
+ *  - a nav flight (`NavTransition.active`, systems/nav-flight.ts);
+ *  - the pegboard's band stretched (systems/tray.ts: it lets go `letGoMs` after the last wheel);
+ *  - ports materialized (systems/l3-ports.ts: staged over frames, reaped `portReapGraceMs` after their trigger lapsed).
+ * The one-tick protocols after an input (the tags `oneTickClear` clears, a recognizer reaped a tick after it ended) are the
+ * sleep's tail (`SLEEP_TAIL`), not this reporter's.
+ */
+import type { World } from "@vibecook/strata-ecs";
+import type { InputQueue } from "../input/queue";
+/** Which of the stack's time-driven work is pending now — the first found, or undefined when the stack is at rest. */
+export declare function interactionPending(world: World, queue: InputQueue): string | undefined;
+/** The stack's registered wake: `now` (the next frame) while anything is pending, else never on its own. */
+export declare function interactionDue(world: World, queue: InputQueue): (now: number) => number;
+/** The input queue, waking the loop on every enqueue (Law 2: the adapters only enqueue — this is the one door they share). */
+export declare function wakefulQueue(queue: InputQueue, wake: () => void): InputQueue;

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

@@ -0,0 +1,100 @@
+import type { Entity, World } from "@vibecook/strata-ecs";
+import { type CameraState, type PortalAffine } from "../../../kernel/src/index";
+import { type CanvasRect } from "../canvas/frame-view";
+/** A container's face and its inside's embedding, under one host camera. */
+export interface NavFace {
+    /** The FACE — the portal rect — in the parent frame's world units, as drawn this frame (springs included) or at rest. */
+    readonly face: CanvasRect;
+    /** The inside's arrival camera: what its lattice is dressed for and what a flight lands on. */
+    readonly arrival: CameraState;
+    /** The embedding `M`: inside → parent (`portalAffine(visibleRect(arrival), face)`), the flight's own. */
+    readonly affine: PortalAffine;
+    /** The camera the inside renders under at the host camera — the enter cut's exact `c0` (`outgoingCamera(M, cam)`). */
+    readonly camera: CameraState;
+    /** The gate's answer at the host camera, 0..1: 0 = the far LOD alone, 1 = the live inside whole. */
+    readonly presence: number;
+    /** Does the face cover the whole viewport at the host camera by `marginPx` CSS px (negative: it may poke out by that much)? */
+    covers(marginPx: number): boolean;
+}
+/** What a renderer with a word on its containers' geometry answers. */
+export interface NavGeometrySource {
+    /**
+     * The container's face under the host camera `cam`: as DRAWN when the container is in the current
+     * frame, at REST when it is not (the current frame's own container, an exit's); `undefined` = no
+     * word — core computes from the static rect.
+     */
+    face(container: Entity, cam: CameraState): NavFace | undefined;
+}
+/** The stack's slot for the nav geometry source — a mutable box beside `framePick`, so the renderer can arrive after install. */
+export interface NavGeometrySlot {
+    current: NavGeometrySource | null;
+}
+/** Smooth at both ends; exactly 0 below `a` and 1 above `b`. */
+export declare const smoothstep: (a: number, b: number, x: number) => number;
+/**
+ * The DEFAULT arrival camera for a frame (design-006 as amended; nested-canvas's rule): kernel
+ * `fitCamera` over its direct content, capped into the natural band (FIT_DEFAULTS ∩ the
+ * session's CameraLimits ∩ the canvas type's camera policy); identity when empty or headless.
+ */
+export declare function defaultArrivalCamera(world: World, frame: Entity, isContainer?: (e: Entity) => boolean): CameraState;
+/** The container's STATIC face: its body rect through its `portal` insets, parent-frame units (`resolvePortal`). */
+export declare function staticFace(world: World, container: Entity): CanvasRect | undefined;
+/**
+ * A `NavFace` from the STATIC geometry — core's own word when no renderer has one: the face is
+ * the portal rect, the arrival `defaultArrivalCamera`'s, the cover test sharp-cornered (the
+ * desk's mini mat's face has square corners too — its face law's `radius` 0, K8a — so the two agree where both answer).
+ */
+export declare function fallbackNavFace(world: World, container: Entity, cam: CameraState, opts?: {
+    readonly face?: CanvasRect;
+    readonly arrival?: CameraState;
+    readonly isContainer?: (e: Entity) => boolean;
+}): NavFace | undefined;
+/**
+ * THE one door core's nav reads a container's face through: the renderer's word when a source is
+ * mounted and answers, else the fallback. `overrides` are an op's own numbers (`NavOpts.face` /
+ * `.arrival`), which outrank both.
+ */
+export declare function resolveNavFace(world: World, container: Entity, cam: CameraState, slot: NavGeometrySlot | undefined, overrides?: {
+    readonly face?: CanvasRect;
+    readonly arrival?: CameraState;
+    readonly isContainer?: (e: Entity) => boolean;
+}): NavFace | undefined;
+/**
+ * A nav op asked for from INSIDE the tick — by the double-tap gesture (`navTap`) or the
+ * zoom-through — for the facade to apply once the tick is over. `epoch` bumps per request;
+ * `transition` is the op's (a `"cut"` states `NavRedress` itself). `target` is the container to
+ * enter (unused on exit).
+ */
+export declare const NavIntent: import("@vibecook/strata-ecs").Resource<import("@vibecook/strata-ecs").ValueOf<{
+    readonly kind: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"enter" | "exit">, true>;
+    readonly target: import("@vibecook/strata-ecs").FieldSpec<"eid", true>;
+    readonly transition: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"zoom" | "none" | "cut">, true>;
+    readonly source: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"tap" | "through">, true>;
+    readonly epoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>, {
+    readonly kind: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"enter" | "exit">, true>;
+    readonly target: import("@vibecook/strata-ecs").FieldSpec<"eid", true>;
+    readonly transition: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"zoom" | "none" | "cut">, true>;
+    readonly source: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"tap" | "through">, true>;
+    readonly epoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>;
+/**
+ * A zoom-through cut left a desk dressed for another zoom (design-015 §9): `in` — the desk
+ * entered was dressed for its arrival (`from`) as a face and re-dresses to the camera's zoom;
+ * `out` — the desk left, now the live inside of `frame`, was dressed for the camera it was cut
+ * at (`from`) and re-dresses to its arrival. Stated by the nav ops on every `transition: "cut"`
+ * (one writer); the renderer eases; `epoch` bumps per cut.
+ */
+export declare const NavRedress: import("@vibecook/strata-ecs").Resource<import("@vibecook/strata-ecs").ValueOf<{
+    readonly kind: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"in" | "out">, true>;
+    readonly from: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    /** The container whose desk re-dresses: the one entered (`in`), the one left (`out`). */
+    readonly frame: import("@vibecook/strata-ecs").FieldSpec<"eid", true>;
+    readonly epoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>, {
+    readonly kind: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"in" | "out">, true>;
+    readonly from: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+    /** The container whose desk re-dresses: the one entered (`in`), the one left (`out`). */
+    readonly frame: import("@vibecook/strata-ecs").FieldSpec<"eid", true>;
+    readonly epoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+}>;

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

@@ -26,6 +26,15 @@
  *   project both rows of that tx. A bare runtime `world.setRelation(e,
  *   ChildOf, …)` with no Position write on a pre-existing entity is OUTSIDE
  *   the contract and goes stale until the next resweep.
+ *   THE SELECTION IS SCOPED HERE (design-011 §6/§16 `Selected ⇒ Active`,
+ *   2026-09-26): a widget classified OUT of the frame loses `Selected` in the
+ *   same flush — a drop into a mini mat, a peer's reparent, an undo or a redo
+ *   that carries it away. The collector journals `Selected` too, so a
+ *   selection written onto a standing non-member (the undo stack's selection
+ *   restore of a stale key, an app's raw write) is dropped the next tick.
+ *   Found at D4a's landing: a note dropped into a mini mat stayed selected
+ *   inside it — no marks, no menu, but reachable by every consumer that does
+ *   not filter by membership (the nudge, the tape, a drag of the rest).
  * - 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.
@@ -54,14 +63,31 @@
  *   calls snap, preserving the pre-T1 behavior exactly.
  */
 import type { Entity, TickSystem, World } from "@vibecook/strata-ecs";
-import type { SpatialIndex } from "../../../kernel/src/index";
+import type { CameraState, SpatialIndex } from "../../../kernel/src/index";
+import { type NavTransitionIdentity } from "../systems/nav-flight";
+import type { CanvasRect } from "../canvas/frame-view";
+import type { FrameSwitchRequest, PreparedFrameSwitch, PresentationReleaseReason } from "../canvas/presentation-transition";
+import { type NavGeometrySlot } from "./nav-geometry";
 /** 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;
-/** Per-op transition choice (design-006 §3.1); default is the portal zoom. */
+/**
+ * Per-op transition choice (design-006 §3.1); default is the portal zoom. `"none"` snaps to
+ * the arrival; `"cut"` (design-015 §9, the zoom-through — D2b) moves nothing either but lands
+ * on the CONTINUITY camera — the one the destination was already rendering under through the
+ * face (`c0`) — so the cut changes no pixel; the renderer then re-dresses.
+ *
+ * The three overrides are the renderer's word on the container's DRAWN geometry (the nav
+ * geometry seam, nav-geometry.ts): the face `K` in the parent's units, the inside's `arrival`,
+ * and the exact `c0`. Given, they outrank the seam and core's own computation; absent, the op
+ * asks the seam, then computes.
+ */
 export interface NavOpts {
-    readonly transition?: "zoom" | "none";
+    readonly transition?: "zoom" | "none" | "cut";
+    readonly face?: CanvasRect;
+    readonly arrival?: CameraState;
+    readonly c0?: CameraState;
 }
 export interface NestedCanvas {
     readonly activeMembership: TickSystem;
@@ -82,6 +108,23 @@ export interface NestedCanvasOpts {
      * stale entries still exist).
      */
     readonly clearSpatialCaches: () => void;
+    /** EngineCatalog-backed container validity; legacy rigs may omit it. */
+    readonly isContainer?: (entity: Entity) => boolean;
+    /** The nav geometry seam (design-015 §9; D2b): the renderer's word on a container's drawn face, arrival and exact `c0`. */
+    readonly navGeometry?: NavGeometrySlot;
+    /** Runs synchronously before an explicit enter/exit visibility cut. */
+    readonly beforeSwitch?: () => void;
+    /** Presentation gate: false forces an atomic cut (for example, cross-ground before T2). */
+    readonly transitionAllowed?: (fromFrame: Entity | undefined, toFrame: Entity | undefined) => boolean;
+    /** Trusted synchronous pre-cut presentation capture. It cannot veto the cut. */
+    readonly prepareTransition?: (request: FrameSwitchRequest) => PreparedFrameSwitch;
+    /** Integrity/doc recovery releases any adapter holds without animation. */
+    readonly abortTransition?: (reason: PresentationReleaseReason) => void;
+    /** Capture stable frame/type/document identity before the authority cut. */
+    readonly transitionIdentity?: (fromFrame: Entity | undefined, toFrame: Entity | undefined) => NavTransitionIdentity;
+    /** One publication per completed switch or integrity pop. */
+    readonly onSwitch?: (frame: Entity | undefined, depth: number, restoreTool: string | undefined) => void;
+    readonly maxDepth?: number;
 }
 /**
  * The membership stamper alone — installed by `installWidgetRuntime` (before
@@ -95,4 +138,4 @@ export interface NestedCanvasOpts {
  * PER IDLE FRAME at 100k widgets nested 8 deep.
  */
 export declare function createActiveMembership(world: World): TickSystem;
-export declare function createNestedCanvas(world: World, opts: NestedCanvasOpts): NestedCanvas;
+export declare function createNestedCanvas(world: World, config: NestedCanvasOpts): NestedCanvas;

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

@@ -7,7 +7,8 @@
  * 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
+ * Beyond the wires, any source of a DEPENDENT relation pointing at a doomed entity dies with it (`defineRelation({ dependent:
+ * true })`, design-015 D3t-c). 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.

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

@@ -10,6 +10,12 @@
  * 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.
+ *
+ * The KEYBOARD is a continuous gesture too (design-015 §6.1, D2c): an object
+ * carrying the runtime `Editing` rider is claimed by the one focused editor's
+ * typing session, which live-writes its text and commits it once at the
+ * session's end — a third SOURCE of the gesture claim, not a third kind of
+ * grant (design-009 §3's divergence law stands: a claim or a tween).
  */
 import type { Entity, World } from "@vibecook/strata-ecs";
 export declare function makeDefaultMayDiverge(world: World): (e: Entity) => boolean;

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

@@ -15,6 +15,10 @@
  *       500ms over a palette;
  *     - `SweepsContained`: a comment ghost at the tray's world point must not
  *       sweep the widgets resting under the tray into the insert.
+ *     And one is always GIVEN (K5b, design-017 §9): `Movable` — the adoption
+ *     drag is core's whatever the kind's own carry (a print is not core-movable:
+ *     its carry is its physics), so every kind taken off the tray runs the
+ *     ordinary drag to its drop.
  *     The projected twin gets the FULL tag set from the equip system.
  *
  *  2. Enqueue ONE synthetic un-flagged `down` (Law 2 — this op is an adapter

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

@@ -12,7 +12,10 @@
  * ONE comparator paint and pick share). Deliberately NOT plane-stratified:
  * cross-plane z is stratified visually (P2 GL composites above P1 DOM), but
  * pick order is sibling order across all surfaces — design-004 §1 names the
- * mixed-overlap consequence and accepts it; do not "fix" it here.
+ * mixed-overlap consequence and accepts it; do not "fix" it here. (The desk's
+ * `Stratum` bands — design-015 §4.2 — are NOT that stratification: they are
+ * the desk's PAINT order, read inside compareStackOrder, so pick still equals
+ * paint. No pre-desk widget carries one.)
  */
 import type { Component, Entity } from "@vibecook/strata-ecs";
 import type { Cubic, SpatialIndex } from "../../../kernel/src/index";

package/dist/types/packages/core/src/ops/sibling-order.d.ts

@@ -6,6 +6,12 @@
  * — every renderer/pick consumer shares this module so the orders can never
  * diverge (the point-pick lesson, extended to the comparator).
  *
+ * THE DESK'S STRATA (design-015 §4.2, D2a-core, 2026-09-25) rank ABOVE the
+ * sequence: `compareStackOrder` orders by `Stratum.band` first (pads · sheets ·
+ * things; absent = things) and by sibling order within a band, so an object's
+ * pick order is its paint order across kinds. No pre-desk widget carries a
+ * `Stratum`, so every existing board is one band and orders as it always did.
+ *
  * LEGACY FALLBACK (must keep working): when the `BoardRoot` resource is absent
  * (a pre-schema-2 doc opened read-only, or a doc-less runtime world) OR an
  * entity carries no `ChildOf` edge (bare runtime spawns), stacking falls back
@@ -41,10 +47,14 @@ export declare function frameParent(world: World): Entity | undefined;
 export declare function buildOrdinals(world: World, parent: Entity): Map<Entity, number>;
 /**
  * THE stacking comparator (ascending = paint order; the pick tier takes the
- * max). Ordinal-mapped entities order by sibling position; entities missing
- * from the map use the legacy `(StackZ asc, entity asc)` fallback among
- * themselves and sort ABOVE the ordinal-mapped set (see the header note on
- * nominally-impossible mixed frames).
+ * max). The desk's STRATUM first (design-015 §4.2, D-D4 — D2a-core): pads
+ * under sheets under things, whatever the sibling order says, so what the desk
+ * paints on top is what a point picks; an entity with no `Stratum` is a thing,
+ * which is every pre-desk widget — an all-dom board is one band and orders
+ * exactly as before. Within a band: ordinal-mapped entities order by sibling
+ * position; entities missing from the map use the legacy `(StackZ asc, entity
+ * asc)` fallback among themselves and sort ABOVE the ordinal-mapped set (see
+ * the header note on nominally-impossible mixed frames).
  */
 export declare function compareStackOrder(reader: StackOrderReader, ordinals: ReadonlyMap<Entity, number>, a: Entity, b: Entity): number;
 export interface SiblingOrderIndex {

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

@@ -0,0 +1,48 @@
+/**
+ * THE TRAY'S OPS (design-017 §2; K3) — the ways a host, the keymap and a rig move the pegboard drawer's facts (`Tray`, runtime, one
+ * per view). Outside the tick, world-taking like `cancelActiveGestures`; the tray's input system (systems/tray.ts) is their one
+ * in-tick peer. Opening is refused while an object is in hand (the hand is a focus of its own — put it down first) and cancels every
+ * gesture in flight (widgetlab's hygiene: nothing freezes mid-drag under the drawer); closing lets the band go. design-018 §6 (R2):
+ * the drawer's CATEGORY — which of the entries it lays ("" all), and the categories the frame hangs, for a host's chips.
+ */
+import type { Entity, World } from "@vibecook/strata-ecs";
+/**
+ * The view's tray entity, spawned (runtime, closed) if the world has none — at install, and after a reset. It ROOTS the tray's
+ * runtime canvas (K5a — a `Container`, so its specimens' first container is it, never a frame: none is ever `Active`), its
+ * content not yet laid.
+ */
+export declare function ensureTray(world: World): Entity;
+/** The view's tray entity, if there is one. */
+export declare function trayEntity(world: World): Entity | undefined;
+/** Is the drawer out? */
+export declare function trayOpen(world: World): boolean;
+/** Open the drawer: refused (false) while an object is in hand; every gesture in flight is cancelled. */
+export declare function openTray(world: World): boolean;
+/** Close the drawer; the band lets go. */
+export declare function closeTray(world: World): void;
+/** Open a closed drawer, close an open one; returns whether it is open now. */
+export declare function toggleTray(world: World): boolean;
+/** Set the board's scroll (CSS px past its top) — a host's or a rig's door; any value (the input clamps what it moves). */
+export declare function scrollTray(world: World, scroll: number): void;
+/** A tray category as a host's chip shows it (design-018 §6): its id (an entry's `category`), its label, how many entries the frame hangs in it. */
+export interface TrayCategory {
+    readonly id: string;
+    /** The id with its first letter capitalized ("surfaces" → "Surfaces"). */
+    readonly label: string;
+    readonly count: number;
+}
+/** The category the drawer shows ("" — all). */
+export declare function trayCategory(world: World): string;
+/**
+ * Show one category of the tray's entries ("" — all): the lay (systems/tray.ts `createTrayLay`) hangs only its entries, zeroes the
+ * scroll and the band on the change, and falls back to all when the frame hangs none of it (an id no entry names included).
+ */
+export declare function setTrayCategory(world: World, id: string): void;
+/**
+ * The categories PRESENT among the entries the drawer's frame hangs (design-018 §6) — the catalog's tray entries the current frame
+ * takes (K9 S13), before the category's filter — in the lay's order, each with its label and count: a host's chips. An entry that
+ * names no category is laid under all alone (it has no chip). Empty until the lay has run (the renderer's first frame).
+ */
+export declare function trayCategories(world: World): TrayCategory[];
+/** How many entries the drawer's frame hangs, every category (before the filter) — 0: the tray has nothing to offer here. */
+export declare function trayEntryCount(world: World): number;

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

@@ -22,6 +22,11 @@ export interface PresenceOpts {
      * `console.error`.
      */
     readonly onFault?: (where: "outbound" | "leave" | "heal", error: unknown) => void;
+    /**
+     * A peer's presence ARRIVED or AGED OUT (the Loro store's imports and its TTL sweep — never this peer's own sets): it is
+     * projected at the next `world.sync()`, so the host's next frame must come — the facade wakes a sleeping loop here (K7a).
+     */
+    readonly onRemote?: () => void;
 }
 export interface PresenceSession {
     /** This session's peer id (the ephemeral partition prefix). */

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

@@ -21,6 +21,8 @@ export interface ComponentMeta {
 export interface RelationMeta {
     name: string;
     arity: "one" | "many";
+    /** A DEPENDENT edge (design-015 D3t-c): its source dies with its target — the cascade walks it as it walks a wire's ends. */
+    dependent?: boolean;
 }
 export interface ResourceMeta {
     name: string;
@@ -41,9 +43,15 @@ export declare function defineComponent<const Sch extends RawSchema>(name: strin
  */
 export declare function ensureComponent<const Sch extends RawSchema>(name: string, schema: Sch): Component;
 export declare function defineTag(name: string): Tag;
+/**
+ * A relation. `dependent` (design-015 D3t-c — a reified edge, the wire's precedent generalised: the desk calendar's pin → its note):
+ * the entity the edge goes OUT of dies with the entity it points AT — `cascadeDestroy` takes it in the same transaction, so one undo
+ * brings both back.
+ */
 export declare function defineRelation(name: string, opts?: {
     arity?: "one" | "many";
     ordered?: boolean;
+    dependent?: boolean;
 }): Relation;
 export declare function defineResource<const Sch extends RawSchema>(name: string, schema: Sch, opts?: {
     durable?: boolean;
@@ -52,5 +60,7 @@ export declare const schemaMeta: {
     component(c: Component): ComponentMeta | undefined;
     tagName(t: Tag): string | undefined;
     relation(r: Relation): RelationMeta | undefined;
+    /** The relations whose sources die with their targets (`defineRelation({ dependent: true })`). */
+    dependents(): readonly Relation[];
     resource(r: Resource): ResourceMeta | undefined;
 };

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

@@ -48,6 +48,14 @@ export interface PrefabDef {
      * compared at open. Bump when the prefab's durable shape changes. Default 1.
      */
     version?: number;
+    /**
+     * A DATA prefab's own migration chain (design-015 §5.1, D3t-a — an object's data children, the board's
+     * strokes): `{ fromVersion: (prev) => next }` over the flat record of its essential components' fields,
+     * every version `1..version-1` covered — defineWidget's `migrate` shape. The M9 runner applies it to a
+     * document whose `engine.pack.<id>` marker is older, when an engine catalog tracks the prefab (an
+     * object's `data`). A widget's own prefab migrates by its widget's chain instead.
+     */
+    migrate?: Readonly<Record<number, (prev: Record<string, unknown>) => Record<string, unknown>>>;
 }
 export interface Prefab extends PrefabDef {
     id: string;

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

@@ -17,7 +17,11 @@ export declare const GESTURE_DEFAULTS: {
     readonly multiTapSlopPx: 20;
     readonly wheelZoomSensitivity: 0.01;
     readonly wheelZoomMaxStep: 10;
+    readonly wheel: "pan";
+    readonly wheelZoomRate: 0.0016;
 };
+/** What a plain wheel does to the camera (`GestureSettings.wheel`, design-015 §9). */
+export type WheelMode = "pan" | "zoom";
 /** Pick radii + retarget dead-band (design-003 §3 L1 targeting). */
 export declare const POINTER_DEFAULTS: {
     readonly radiusMousePx: 0;
@@ -43,9 +47,8 @@ export declare const SNAP_DEFAULTS: {
 };
 /**
  * Selection-chrome knobs (2026-07-17). `liftScale` mirrors the app's visual
- * drag-lift scale (widgetlab CardShell: 1.05) so the union box can inflate a
- * grabbed member's rect and keep WRAPPING the card it sees; 1 = no lift
- * visual, no inflation.
+ * drag-lift scale so the resize handles can inflate a grabbed member's rect
+ * and keep WRAPPING the card it sees; 1 = no lift visual, no inflation.
  */
 export declare const CHROME_DEFAULTS: {
     readonly liftScale: 1;
@@ -90,10 +93,26 @@ export declare const NAV_TRANSITION_DEFAULTS: {
     readonly settleP: 0.999;
     readonly settleV: 0.02;
 };
-/** Widget/FBO/port budgets (design-004 §2 host pipeline, §3 FBO pool, §6 port materialization; ported into design-005 §4 engine facade). */
+/**
+ * The zoom-through (design-015 §9, PORTAL.md §8 — D2b): a wheel zoom IN that leaves a
+ * container's face covering the whole view by `in` CSS px cuts into it; a zoom OUT that
+ * leaves the current frame's face `out` px short of covering cuts back out — both as cuts
+ * nobody can see. `gate` is the face's short side (CSS px) across which a live inside comes
+ * in over its far LOD (presence 0 → 1); a face enters only at presence 1. OFF by default: the
+ * desk turns it on (`settings.nav.zoomThrough.enabled`); every other app keeps explicit entry.
+ */
+export declare const ZOOM_THROUGH_DEFAULTS: {
+    readonly enabled: false;
+    readonly in: 2;
+    readonly out: 6;
+    readonly gate: readonly [number, number];
+};
+/**
+ * Port and cull budgets (design-004 §6 port materialization; ported into design-005 §4 engine
+ * facade). `keepMountedWidgets` and `fboBytes` left at design-015 D5b with the mount LRU and the
+ * GL allocation ledger they bounded.
+ */
 export declare const RUNTIME_BUDGETS: {
-    readonly keepMountedWidgets: 256;
-    readonly fboBytes: 268435456;
     readonly portSpawnPerFrame: 64;
     readonly portLightUpRadiusPx: 600;
     readonly portReapGraceMs: 1000;