@vibecook/ice 0.11.0 → 0.14.0

package/dist/types/packages/core/src/canvas/extensions.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Governed Canvas SDK logic definitions.
+ *
+ * These handles are immutable declarations. Like WidgetType/Tool/CanvasType,
+ * their process registries are authoring-time identity stores only; an
+ * EngineCatalog decides which declarations exist in one engine.
+ */
+import type { Component, Entity, Relation, Resource, Tag } from "@vibecook/strata-ecs";
+import type { CanvasSessionValue } from "./session";
+export type CanvasReadFacet = Component | Tag | Relation | Resource;
+export interface CanvasRuntimeChanges {
+    readonly full: boolean;
+    readonly changed: readonly Entity[];
+    readonly removed: readonly Entity[];
+}
+export interface CanvasScopedReader {
+    readonly frame: Entity;
+    readonly children: readonly Entity[];
+    read<S>(entity: Entity, component: Component<S>): S;
+    get<S>(entity: Entity, component: Component<S>): S | undefined;
+    hasTag(entity: Entity, tag: Tag): boolean;
+    getRelation(entity: Entity, relation: Relation): Entity | undefined;
+    getRelations(entity: Entity, relation: Relation): readonly Entity[];
+    getReverse(entity: Entity, relation: Relation): readonly Entity[];
+    getResource<S>(resource: Resource<S>): S | undefined;
+}
+export interface CanvasRuntimeExtensionContext extends CanvasScopedReader {
+    readonly session: CanvasSessionValue & {
+        readonly state: "attached";
+    };
+    readonly changes: CanvasRuntimeChanges;
+    readonly signal: AbortSignal;
+    /** Set one declared runtime-only output on the frame owner or a direct child. */
+    set<S>(entity: Entity, component: Component<S>, value: S): void;
+    /** Remove one declared runtime-only output owned by this extension. */
+    remove(entity: Entity, component: Component): void;
+}
+export interface CanvasRuntimeExtensionDef {
+    readonly id: string;
+    /** Runtime/cache identity only; never a document requirement. */
+    readonly version: number;
+    readonly phase?: "derive";
+    readonly after?: readonly string[];
+    readonly before?: readonly string[];
+    readonly reads?: readonly CanvasReadFacet[];
+    readonly writesRuntime?: readonly Component[];
+    readonly budgetMs?: number;
+    run(context: CanvasRuntimeExtensionContext): void;
+}
+export interface CanvasRuntimeExtension extends CanvasRuntimeExtensionDef {
+    readonly __canvasRuntimeExtension: true;
+    readonly phase: "derive";
+    readonly after: readonly string[];
+    readonly before: readonly string[];
+    readonly reads: readonly CanvasReadFacet[];
+    readonly writesRuntime: readonly Component[];
+}
+export interface FrameBehaviorWriteContext extends CanvasScopedReader {
+    readonly canvasTypeId: string;
+    /** Absolute, change-only component write queued into this behavior's transaction. */
+    set<S>(entity: Entity, component: Component<S>, value: S): void;
+    remove(entity: Entity, component: Component): void;
+    setRelation(entity: Entity, relation: Relation, target: Entity): void;
+    removeRelation(entity: Entity, relation: Relation, target?: Entity): void;
+}
+export interface FrameBehaviorDef {
+    readonly id: string;
+    readonly version: number;
+    readonly phase?: "postSettle";
+    readonly after?: readonly string[];
+    readonly before?: readonly string[];
+    readonly reads?: readonly CanvasReadFacet[];
+    readonly writesDurable?: readonly Component[];
+    readonly writesRelations?: readonly Relation[];
+    readonly budget?: {
+        readonly entities?: number;
+        readonly ms?: number;
+    };
+    run(context: FrameBehaviorWriteContext): void;
+}
+export interface FrameBehavior extends FrameBehaviorDef {
+    readonly __frameBehavior: true;
+    readonly phase: "postSettle";
+    readonly after: readonly string[];
+    readonly before: readonly string[];
+    readonly reads: readonly CanvasReadFacet[];
+    readonly writesDurable: readonly Component[];
+    readonly writesRelations: readonly Relation[];
+    readonly budget: {
+        readonly entities: number;
+        readonly ms: number;
+    };
+}
+export type ExistingPlacementPosture = "preserve-and-warn" | "repair";
+export interface CanvasSemanticMigrationContext extends CanvasScopedReader {
+    readonly canvasTypeId: string;
+    readonly from: number;
+    readonly to: number;
+    set<S>(entity: Entity, component: Component<S>, value: S): void;
+    remove(entity: Entity, component: Component): void;
+    setRelation(entity: Entity, relation: Relation, target: Entity): void;
+    removeRelation(entity: Entity, relation: Relation, target?: Entity): void;
+    /** Explicit frame-ownership repair; target must be a live valid frame. */
+    reparent(entity: Entity, targetFrame: Entity): void;
+}
+export interface CanvasSemanticMigration {
+    readonly from: number;
+    readonly to: number;
+    readonly reads?: readonly CanvasReadFacet[];
+    readonly writes?: readonly (Component | Relation)[];
+    readonly existingPlacement: ExistingPlacementPosture;
+    migrate(context: CanvasSemanticMigrationContext): void;
+}
+export declare const canvasRuntimeExtensions: {
+    get(id: string): CanvasRuntimeExtension | undefined;
+    all(): readonly CanvasRuntimeExtension[];
+};
+export declare const frameBehaviors: {
+    get(id: string): FrameBehavior | undefined;
+    all(): readonly FrameBehavior[];
+};
+export declare function defineCanvasRuntimeExtension(def: CanvasRuntimeExtensionDef): CanvasRuntimeExtension;
+export declare function defineFrameBehavior(def: FrameBehaviorDef): FrameBehavior;
+/** Existing pack-gate namespace reserved for semantic frame behavior code. */
+export declare function frameBehaviorPackId(id: string): string;

package/dist/types/packages/core/src/canvas/frame-behavior-host.d.ts

@@ -0,0 +1,16 @@
+/** View-independent, dirt-routed semantic FrameBehavior host. */
+import { type World } from "@vibecook/strata-ecs";
+import type { DocSession } from "../doc/doc-kit";
+import type { Engine } from "../engine/engine";
+import type { EngineCatalog } from "./engine-catalog";
+export interface FrameBehaviorHost {
+    isCanvasWritable(canvasTypeId: string): boolean;
+    dispose(): void;
+}
+export declare function installFrameBehaviors(opts: {
+    readonly world: World;
+    readonly engine: Engine;
+    readonly catalog: EngineCatalog;
+    readonly session: () => DocSession | undefined;
+    readonly onAvailabilityChange?: () => void;
+}): FrameBehaviorHost;

package/dist/types/packages/core/src/canvas/frame-preview.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Demand-driven, immutable semantic previews for container frames.
+ *
+ * This store intentionally has no timer and no eager frame index. A frame pays
+ * for observers and projection work only while at least one consumer is
+ * subscribed. Projection authors receive declared, bounded plain reads rather
+ * than a World or document handle.
+ */
+import { type Entity, type World } from "@vibecook/strata-ecs";
+import type { DurableStore } from "@vibecook/strata-ecs/durable";
+import type { CanvasDiagnostic } from "./diagnostics";
+import type { EngineCatalog } from "./engine-catalog";
+import { type CanvasRect } from "./frame-view";
+export declare const FRAME_PREVIEW_DEFAULT_CHILDREN = 128;
+export declare const FRAME_PREVIEW_DEFAULT_BYTES: number;
+export declare const FRAME_PREVIEW_MAX_CHILDREN = 256;
+export declare const FRAME_PREVIEW_MAX_BYTES: number;
+/** Smallest budget that can contain the mandatory immutable preview envelope. */
+export declare const FRAME_PREVIEW_MIN_BYTES = 512;
+export type FramePreviewValidity = "valid" | "incompatible" | "malformed-parent";
+export interface FramePreviewChild {
+    readonly key: string;
+    readonly widgetType: string;
+    readonly rect: CanvasRect;
+    readonly order: number;
+    readonly validity: FramePreviewValidity;
+}
+export interface FramePreviewSnapshot {
+    readonly revision: number;
+    readonly frameKey: string;
+    readonly bounds: CanvasRect;
+    readonly resolvedView: {
+        readonly x: number;
+        readonly y: number;
+        readonly zoom: number;
+    };
+    /** Destination viewport used by the shared arrival-camera solve. */
+    readonly viewport: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly portal: CanvasRect;
+    readonly totalChildren: number;
+    readonly truncated: boolean;
+    readonly children: readonly FramePreviewChild[];
+    readonly facets: Readonly<Record<string, unknown>>;
+}
+export interface FramePreviewBudgets {
+    readonly children?: number;
+    readonly bytes?: number;
+}
+export interface FramePreviewStats {
+    readonly activeFrames: number;
+    readonly observers: number;
+    readonly rebuilds: number;
+    readonly projectionRuns: number;
+}
+export interface FramePreviewStore {
+    /** Pure snapshot read. It never arms observers or performs a projection. */
+    snapshot(frame: Entity): FramePreviewSnapshot;
+    /** First subscriber activates; the last exact inverse removes every observer. */
+    subscribe(frame: Entity, onChange: () => void): () => void;
+    /** Re-arm active entries after a document import/reset invalidates reactivity. */
+    rebind(): void;
+    stats(): FramePreviewStats;
+    dispose(): void;
+}
+export interface FramePreviewStoreOpts {
+    readonly world: World;
+    readonly catalog: EngineCatalog;
+    readonly session: () => {
+        readonly documentEpoch: number;
+        readonly store?: Pick<DurableStore, "keyOf">;
+    };
+    readonly diagnostics: () => readonly CanvasDiagnostic[];
+    readonly budgets?: FramePreviewBudgets;
+    readonly onFault?: (projectionId: string, error: unknown) => void;
+}
+export declare function createFramePreviewStore(opts: FramePreviewStoreOpts): FramePreviewStore;

package/dist/types/packages/core/src/canvas/frame-projection.d.ts

@@ -0,0 +1,38 @@
+/** Declared, bounded custom facets for semantic container previews. */
+import type { Component, Relation } from "@vibecook/strata-ecs";
+export interface FrameProjectionChildRef {
+    readonly key: string;
+    readonly widgetType: string;
+    readonly order: number;
+}
+export interface FrameProjectionRelationRow {
+    readonly source: string;
+    readonly target: string;
+}
+export interface FrameProjectionContext {
+    readonly frameKey: string;
+    readonly children: readonly FrameProjectionChildRef[];
+    get<S>(childKey: string, component: Component<S>): S | undefined;
+    relations(relation: Relation): readonly FrameProjectionRelationRow[];
+}
+export interface FrameProjectionDef {
+    readonly id: string;
+    readonly version?: number;
+    readonly reads?: readonly Component[];
+    readonly relations?: readonly Relation[];
+    project(context: FrameProjectionContext): unknown;
+}
+export interface FrameProjection extends FrameProjectionDef {
+    readonly __frameProjection: true;
+    readonly version: number;
+    readonly reads: readonly Component[];
+    readonly relations: readonly Relation[];
+}
+export interface CanvasPreviewDeclaration {
+    readonly projection?: FrameProjection;
+}
+export declare const frameProjections: {
+    get(id: string): FrameProjection | undefined;
+    all(): readonly FrameProjection[];
+};
+export declare function defineFrameProjection(def: FrameProjectionDef): FrameProjection;

package/dist/types/packages/core/src/canvas/frame-view.d.ts

@@ -0,0 +1,36 @@
+/** Shared portal geometry and frame-arrival view resolution. */
+import type { Entity, World } from "@vibecook/strata-ecs";
+import { type CameraState } from "../../../kernel/src/index";
+import type { CanvasType } from "./define-canvas-type";
+import type { WidgetContainerEntry } from "../widget/define-widget";
+export interface CanvasRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface ResolvedPortal {
+    readonly local: CanvasRect;
+    readonly parent: CanvasRect;
+    /** False means authored insets were invalid at the effective instance size. */
+    readonly authored: boolean;
+}
+export interface ResolvedFrameView {
+    readonly bounds: CanvasRect;
+    readonly camera: CameraState;
+    readonly totalChildren: number;
+}
+export interface FrameChildrenOpts {
+    /** When supplied, malformed descendants inherit the nearest container frame. */
+    readonly isContainer?: (entity: Entity) => boolean;
+}
+/**
+ * Converged effective frame order. Without a container predicate this is the
+ * ordinary direct sequence. Compatibility callers supply the engine-scoped
+ * predicate to include malformed descendants and stop at nested frames.
+ */
+export declare function resolveFrameChildren(world: World, frame: Entity, opts?: FrameChildrenOpts): readonly Entity[];
+/** One source for preview clipping and navigation/transition portal math. */
+export declare function resolvePortal(world: World, container: Entity, binding: WidgetContainerEntry | undefined): ResolvedPortal | undefined;
+/** One source for arrival camera and semantic preview projection. */
+export declare function resolveFrameView(world: World, frame: Entity, canvas: CanvasType | undefined, opts?: FrameChildrenOpts): ResolvedFrameView;

package/dist/types/packages/core/src/canvas/migrate.d.ts

@@ -0,0 +1,14 @@
+/** CanvasType semantic migrations — bounded, frame-scoped, and view-independent. */
+import { type World } from "@vibecook/strata-ecs";
+import type { DurableStore } from "@vibecook/strata-ecs/durable";
+import type { DocVersionReport } from "../doc/version-gate";
+import type { EngineCatalog } from "./engine-catalog";
+export interface CanvasMigrationOutcome {
+    readonly migrated: readonly string[];
+    readonly skipped: readonly string[];
+}
+/**
+ * Run semantic steps after structural/prefab normalization. Each step plans
+ * every bound frame before writing, then stamps its reached version last.
+ */
+export declare function runCanvasSemanticMigrations(store: DurableStore, world: World, catalog: EngineCatalog, initialReport: DocVersionReport): CanvasMigrationOutcome;

package/dist/types/packages/core/src/canvas/placement.d.ts

@@ -0,0 +1,30 @@
+/** One semantic placement authority for facade mutation and typed drop paths. */
+import type { Entity, World } from "@vibecook/strata-ecs";
+import type { EngineCatalog } from "./engine-catalog";
+export type PlacementReason = "ok" | "unknown-widget" | "pack-disabled" | "target-dead" | "target-not-frame" | "unknown-canvas" | "canvas-pack-disabled" | "frame-behavior-unavailable" | "widget-not-allowed" | "ingress-rejected" | "cycle" | "malformed-parent" | "depth-limit";
+export type PlacementDecision = {
+    readonly ok: true;
+    readonly canvasTypeId: string;
+    readonly targetFrame: Entity;
+} | {
+    readonly ok: false;
+    readonly reason: Exclude<PlacementReason, "ok">;
+    readonly message: string;
+};
+export interface PlacementAuthority {
+    canPlace(widgetTypeId: string, targetFrame: Entity): PlacementDecision;
+    canIngress(widgetTypeId: string, targetContainer: Entity): PlacementDecision;
+    validateReparent(entity: Entity, targetFrame: Entity): PlacementDecision;
+    assertPlace(widgetTypeId: string, targetFrame: Entity, operation: string): void;
+    assertReparent(entity: Entity, targetFrame: Entity, operation: string): void;
+}
+export interface PlacementAuthorityOpts {
+    readonly world: World;
+    readonly catalog: EngineCatalog;
+    readonly rootCanvasTypeId: () => string | undefined;
+    readonly packEnabled?: (id: string, version: number) => boolean;
+    /** False while a required semantic FrameBehavior is faulted/suspended. */
+    readonly canvasWritable?: (canvasTypeId: string) => boolean;
+    readonly maxDepth?: number;
+}
+export declare function createPlacementAuthority(opts: PlacementAuthorityOpts): PlacementAuthority;

package/dist/types/packages/core/src/canvas/presentation-transition.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Epoch-keyed presentation retention for cut-first nested-canvas navigation.
+ *
+ * Core owns only timing, identity, and exact release. DOM/GL/Ground adapters
+ * synchronously capture their already-presented state in `prepare`; they never
+ * receive a World and cannot delay or veto the authority cut.
+ */
+import type { Entity, World } from "@vibecook/strata-ecs";
+import type { CameraState, PortalAffine } from "../../../kernel/src/index";
+import type { Engine } from "../engine/engine";
+/**
+ * The ONE presentation plane (design-015 §1, D5b). Until D5b this was
+ * `"ground" | "dom" | "gl"` — a DOM widget needed the `dom` plane's adapter to
+ * prepare its outgoing hosts and a GL island the `gl` plane's — and
+ * `presentationPlanesOf(widget)` said which a type needed. Everything under the
+ * camera is the desk's now, so a flight prepares `ground` and nothing else; the
+ * type stays a union of one so the coordinator's plane ownership keeps its shape.
+ */
+export type PresentationPlane = "ground";
+export type PresentationReleaseReason = "settled" | "interrupted" | "superseded" | "detached" | "fault" | "timeout" | "cancelled";
+export interface FrameSwitchDescriptor {
+    readonly kind: "enter" | "exit";
+    readonly documentEpoch: number;
+    readonly fromFrame: Entity;
+    readonly toFrame: Entity;
+    readonly fromTypeId: string;
+    readonly toTypeId: string;
+    readonly fromCamera: CameraState;
+    readonly toCamera: CameraState;
+    readonly affine: PortalAffine;
+    /** Geometry and caller policy permit motion; adapter completeness is evaluated later. */
+    readonly requestedMotion: boolean;
+    /** Cross-program motion may proceed only when every required plane prepared. */
+    readonly requiresFullT2: boolean;
+    readonly requiredPlanes: readonly PresentationPlane[];
+}
+/** Geometry/identity assembled by core navigation before policy adds plane requirements. */
+export type FrameSwitchRequest = Omit<FrameSwitchDescriptor, "requiresFullT2" | "requiredPlanes">;
+export type PresentationMotion = "flight" | "crossfade" | "fast-fade";
+export interface PresentationTransitionFrame {
+    readonly epoch: number;
+    readonly descriptor: FrameSwitchDescriptor;
+    readonly motion: PresentationMotion;
+    readonly camera: CameraState;
+    readonly outgoingCamera: CameraState;
+    readonly progress: number;
+    readonly outgoingOpacity: number;
+    readonly incomingOpacity: number;
+    readonly frozen: boolean;
+}
+export interface PresentationRetainer {
+    update(frame: PresentationTransitionFrame): void;
+    /** Exact and idempotent on the adapter side. */
+    release(reason: PresentationReleaseReason): void;
+}
+export interface PresentationTransitionAdapter {
+    readonly id: string;
+    readonly plane: PresentationPlane;
+    /** `null` means this plane has no outgoing visual but prepared successfully. */
+    prepare(descriptor: FrameSwitchDescriptor): PresentationRetainer | null;
+}
+export interface PreparedFrameSwitch {
+    readonly complete: boolean;
+    readonly allowFlight: boolean;
+    commit(): void;
+    /**
+     * Release a preparation that will not commit. `cancelled` is reserved for a
+     * rollback before navigation authority changes; callers that already
+     * mutated authority must pass the actual terminal reason (normally
+     * `fault`).
+     */
+    cancel(reason?: PresentationReleaseReason): void;
+}
+export interface PresentationTransitionStats {
+    readonly active: boolean;
+    readonly epoch: number;
+    readonly motion?: PresentationMotion;
+    readonly retainers: number;
+    readonly adapters: number;
+    readonly reducedMotion: boolean;
+}
+export interface PresentationTransitionCoordinator {
+    register(adapter: PresentationTransitionAdapter): () => void;
+    /**
+     * The id of the adapter that owns `plane`, or `undefined` when the plane is
+     * free (D-C4.6). A plane is single-owner and {@link register} THROWS on a
+     * second claim — inside a `useEffect` that unmounts the React tree — so a
+     * host that may be mounted twice on one engine asks here first.
+     */
+    ownerOf(plane: PresentationPlane): string | undefined;
+    prepare(descriptor: FrameSwitchDescriptor): PreparedFrameSwitch;
+    abort(reason?: PresentationReleaseReason): void;
+    setReducedMotion(value: boolean): void;
+    reducedMotion(): boolean;
+    stats(): PresentationTransitionStats;
+    dispose(): void;
+}
+export declare function createPresentationTransitionCoordinator(world: World, engine: Engine, opts?: {
+    readonly onFault?: (adapterId: string, error: unknown) => void;
+}): PresentationTransitionCoordinator;

package/dist/types/packages/core/src/canvas/runtime-extension-host.d.ts

@@ -0,0 +1,16 @@
+/** Current-frame CanvasRuntimeExtension dispatcher and fault/output governor. */
+import { type World } from "@vibecook/strata-ecs";
+import type { Engine } from "../engine/engine";
+import type { CanvasSessionValue } from "./session";
+import type { EngineCatalog } from "./engine-catalog";
+export interface CanvasRuntimeExtensionHost {
+    /** Force output teardown at the synchronous authority cut. */
+    invalidate(): void;
+    dispose(): void;
+}
+export declare function installCanvasRuntimeExtensions(opts: {
+    readonly world: World;
+    readonly engine: Engine;
+    readonly catalog: EngineCatalog;
+    readonly session: () => CanvasSessionValue;
+}): CanvasRuntimeExtensionHost;

package/dist/types/packages/core/src/canvas/session.d.ts

@@ -0,0 +1,47 @@
+/** Generation-safe local CanvasSession resource and its engine-owned writer. */
+import { type Entity, type World } from "@vibecook/strata-ecs";
+export declare const CanvasSession: import("@vibecook/strata-ecs").Resource<import("@vibecook/strata-ecs").ValueOf<{
+    readonly state: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"detached" | "attached">, true>;
+    readonly documentEpoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    readonly epoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    /** Ignored while detached. Zero is a sentinel, never a retained entity API. */
+    readonly frame: import("@vibecook/strata-ecs").FieldSpec<"eid", true>;
+    readonly typeId: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly depth: import("@vibecook/strata-ecs").FieldSpec<"u8", true>;
+}>, {
+    readonly state: import("@vibecook/strata-ecs").FieldSpec<import("@vibecook/strata-ecs").EnumType<"detached" | "attached">, true>;
+    readonly documentEpoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    readonly epoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    /** Ignored while detached. Zero is a sentinel, never a retained entity API. */
+    readonly frame: import("@vibecook/strata-ecs").FieldSpec<"eid", true>;
+    readonly typeId: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+    readonly depth: import("@vibecook/strata-ecs").FieldSpec<"u8", true>;
+}>;
+/** Gesture-start latch used to reject commits after a document/nav switch. */
+export declare const CanvasIntentScope: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly documentEpoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    readonly canvasEpoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    readonly frame: import("@vibecook/strata-ecs").FieldSpec<"eid", true>;
+}>, {
+    readonly documentEpoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    readonly canvasEpoch: import("@vibecook/strata-ecs").FieldSpec<"u32", true>;
+    readonly frame: import("@vibecook/strata-ecs").FieldSpec<"eid", true>;
+}>;
+export type CanvasSessionValue = {
+    readonly state: "detached" | "attached";
+    readonly documentEpoch: number;
+    readonly epoch: number;
+    readonly frame: Entity;
+    readonly typeId: string;
+    readonly depth: number;
+};
+export interface CanvasSessionController {
+    current(): CanvasSessionValue;
+    attach(frame: Entity, typeId: string): CanvasSessionValue;
+    detach(): CanvasSessionValue;
+    switchFrame(frame: Entity, typeId: string, depth: number): CanvasSessionValue;
+    bumpCapabilities(): CanvasSessionValue;
+    /** Re-publish closure state after world.reset() clears runtime resources. */
+    republish(): void;
+}
+export declare function createCanvasSessionController(world: World): CanvasSessionController;

package/dist/types/packages/core/src/catalog/camera-derived.d.ts

@@ -103,31 +103,11 @@ export declare const WidgetBreakpoint: import("@vibecook/strata-ecs").Component<
     readonly w: import("@vibecook/strata-ecs").FieldSpec<"u16", true>;
     readonly h: import("@vibecook/strata-ecs").FieldSpec<"u16", true>;
 }>;
-/** Session rider on auto-sized widgets (ResizeObserver → queue → ingest; never committed). */
-export declare const MeasuredSize: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
-    readonly w: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
-    readonly h: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
-}>, {
-    readonly w: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
-    readonly h: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
-}>;
-/** Selection outline rect. */
-export declare const SelectionBox: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
-    readonly x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
-    readonly y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
-    readonly w: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
-    readonly h: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
-}>, {
-    readonly x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
-    readonly y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
-    readonly w: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
-    readonly h: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
-}>;
 /** A resize handle's anchor (the one chrome kind behaviors capture). */
 export declare const HandleSpec: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
-    readonly anchor: import("@vibecook/strata-ecs").EnumType<"s" | "w" | "nw" | "n" | "ne" | "e" | "se" | "sw">;
+    readonly anchor: import("@vibecook/strata-ecs").EnumType<"w" | "nw" | "n" | "ne" | "e" | "se" | "s" | "sw">;
 }>, {
-    readonly anchor: import("@vibecook/strata-ecs").EnumType<"s" | "w" | "nw" | "n" | "ne" | "e" | "se" | "sw">;
+    readonly anchor: import("@vibecook/strata-ecs").EnumType<"w" | "nw" | "n" | "ne" | "e" | "se" | "s" | "sw">;
 }>;
 /** A snap guide line along one axis. `from == to` ⇒ full-viewport line (v1's full-canvas alignment look — design-003 §6). */
 export declare const GuideLine: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
@@ -182,23 +162,32 @@ export declare const CursorVisual: import("@vibecook/strata-ecs").Component<impo
 }>;
 /** cursor → pointer or presence peer. */
 export declare const Follows: import("@vibecook/strata-ecs").Relation;
-/** chrome → its source (recognizer, selection). */
-export declare const VisualOf: import("@vibecook/strata-ecs").Relation;
 /** Depth of a nav entry (root = 0). */
 export declare const NavDepth: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
     readonly d: import("@vibecook/strata-ecs").FieldSpec<"u8", true>;
 }>, {
     readonly d: import("@vibecook/strata-ecs").FieldSpec<"u8", true>;
 }>;
-/** Camera stored on a nav entry. */
+/**
+ * Camera stored on a nav entry. `zoom` is f64 (D2b, design-015 §9): the return pose is a
+ * flight's ARRIVAL when one is driving (`enterContainer`'s settled-pose rule), and the arrival
+ * lives in f64 on the flight resource — an f32 cell here rounded it, and the exit then landed
+ * one ulp off the camera the desk had been dressed for.
+ */
 export declare const NavCamera: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
     readonly x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
     readonly y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
-    readonly zoom: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly zoom: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
 }>, {
     readonly x: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
     readonly y: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
-    readonly zoom: import("@vibecook/strata-ecs").FieldSpec<"f32", true>;
+    readonly zoom: import("@vibecook/strata-ecs").FieldSpec<"f64", true>;
+}>;
+/** Tool active in the departed frame, restored when this nav entry is popped. */
+export declare const NavTool: import("@vibecook/strata-ecs").Component<import("@vibecook/strata-ecs").ValueOf<{
+    readonly id: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
+}>, {
+    readonly id: import("@vibecook/strata-ecs").FieldSpec<"string", true>;
 }>;
 /** nav entry → container widget. */
 export declare const NavFrame: import("@vibecook/strata-ecs").Relation;