@honua/app-platform 0.1.1-beta.0 → 0.1.4-beta.0

package/scene-workspace/cesium-time.d.ts

@@ -0,0 +1,346 @@
+/**
+ * Application time and rebuild boundaries for the Cesium scene adapter.
+ *
+ * Issue #930 gave the Cesium mount a diff: identity plus configuration
+ * fingerprint decide what is reused and what is rebuilt. What it did not have
+ * was a *time*. `applyCesiumScenePrimitives()` accepted the workspace state —
+ * the object carrying the `timeline` and `realtime` slices — and dropped it.
+ * This module is the missing half:
+ *
+ * - {@link sceneTimelineToCesiumClockPlan} turns the renderer-neutral
+ *   `SceneTimelineState` into the exact set of writes a Cesium `Clock` accepts.
+ *   It is pure and Cesium-free, so a host can inspect (and a test can assert)
+ *   what would be written without loading the optional peer.
+ * - {@link applyCesiumClockPlan} performs those writes against a live clock and
+ *   hands back the snapshot needed to undo them, so time participates in the
+ *   adapter's existing transactional rollback exactly like the terrain provider.
+ * - {@link bindTemporalPlaybackToCesium} gives the renderer-neutral playback
+ *   controller (`createTemporalPlayback`, `@honua/sdk-js/map`) a Cesium sink, so
+ *   the same controller that drives a MapLibre map and `<honua-time-slider>`
+ *   drives a globe.
+ * - {@link SceneRebuildBoundary} names, on the *beta* primitive path, what an
+ *   update had to cross. Before this the vocabulary existed only as a detail
+ *   field on the experimental entity slice's `incremental-update` diagnostic.
+ *
+ * ## Clock ownership
+ *
+ * The adapter binds a clock **only when the host opts in** by putting one on the
+ * scene target ({@link CesiumClockTarget.clock}). A target without a clock is
+ * never given one, and a target that declares `clockOwnership: "host"` is never
+ * written to at all — a host driving `viewer.clock` from Cesium's own Animation
+ * widget, or from a simulation loop, must not have the SDK fighting it. Both
+ * refusals are reported rather than silent, so "the time did not reach the
+ * globe" is always visible in the diagnostic list.
+ *
+ * ## Time is not a rebuild
+ *
+ * Application time lives in the workspace state, never in the scene plan, so it
+ * is outside the fingerprint the mount diffs on. Advancing time therefore
+ * crosses no rebuild boundary: every mounted binding is reused untouched and the
+ * only mutation is on the clock. That property is asserted, not assumed
+ * (`test/cesium-scene-temporal.test.ts`, and against a real `Viewer` in
+ * `test/playwright/cesium-scene-adapter-fixtures.spec.mjs`).
+ *
+ * @beta Part of the beta `@honua/app-platform/scene-workspace` surface: these
+ *   exports are not renamed or removed through 0.1.x, and the boundary and
+ *   diagnostic vocabularies grow additively.
+ * @module
+ */
+import type { ScenePrimitiveDiagnostic, SceneRuntimePrimitiveKind } from "./primitives.js";
+import type { SceneTimelineState } from "./types.js";
+/**
+ * Who owns transport on the bound Cesium clock.
+ *
+ * - `"adapter"` (default): the SDK writes the canonical application time, and
+ *   the transport fields the workspace timeline actually declares.
+ * - `"host"`: the SDK writes nothing. Declare this when Cesium's own Animation /
+ *   Timeline widgets, or a host simulation loop, own `viewer.clock`. The
+ *   adapter still reports what it would have applied, so standing down is
+ *   visible rather than indistinguishable from a missing binding.
+ */
+export type CesiumClockOwnership = "adapter" | "host";
+/**
+ * The minimal slice of Cesium's `Clock` the time binding touches. A real
+ * `viewer.clock` satisfies it; tests pass a plain object.
+ *
+ * Times are `unknown` because they are Cesium `JulianDate` instances, which this
+ * module never constructs itself — it asks the lazily-loaded peer for them.
+ */
+export interface CesiumClockLike {
+    currentTime?: unknown;
+    startTime?: unknown;
+    stopTime?: unknown;
+    multiplier?: number;
+    shouldAnimate?: boolean;
+}
+/**
+ * A scene target that may carry a clock. {@link CesiumSceneRuntimeTarget}
+ * extends this, so anything the adapter accepts can drive time.
+ */
+export interface CesiumClockTarget {
+    /**
+     * Opt-in application-time binding: the live Cesium `Clock` (`viewer.clock`).
+     * Omit it and the adapter never reads or writes a clock — a declared
+     * application time is then reported as `scene-time-clock-unbound` instead of
+     * being silently dropped.
+     */
+    readonly clock?: CesiumClockLike;
+    /** Who owns transport on {@link clock}. Defaults to `"adapter"`. */
+    readonly clockOwnership?: CesiumClockOwnership;
+}
+/**
+ * The Cesium symbols the clock binding needs. Modelled as the minimal slice of
+ * `typeof import("cesium")` so an injected stub satisfies it without a live
+ * `Viewer`.
+ */
+export interface CesiumClockRuntimeModule {
+    readonly JulianDate: {
+        fromIso8601(value: string): unknown;
+    };
+}
+/** Inject the peer, or a lazy loader for it. */
+export type CesiumClockRuntimeLoader = () => Promise<CesiumClockRuntimeModule>;
+/**
+ * The exact writes a {@link SceneTimelineState} implies for a Cesium `Clock`.
+ *
+ * Instants stay ISO-8601 strings here — this plan is computable, comparable, and
+ * loggable without the Cesium peer, which is what keeps time diagnostics
+ * available to a host that has not loaded CesiumJS.
+ */
+export interface CesiumClockPlan {
+    /** Canonical application time → `Clock.currentTime`. */
+    readonly currentTime?: string;
+    /** Timeline extent start → `Clock.startTime`. */
+    readonly startTime?: string;
+    /** Timeline extent end → `Clock.stopTime`. */
+    readonly stopTime?: string;
+    /** Clock rate → `Clock.multiplier` (simulated seconds per real second). */
+    readonly multiplier?: number;
+    /** Transport → `Clock.shouldAnimate`. */
+    readonly shouldAnimate?: boolean;
+    /**
+     * Timeline fields that were declared but could not be interpreted (an
+     * unparseable instant, a non-finite rate, an inverted extent). They are named
+     * rather than dropped: a plan with a non-empty `rejected` list is what raises
+     * `scene-time-invalid`.
+     */
+    readonly rejected: readonly string[];
+}
+/** The clock values a binding displaced, kept so they can be restored exactly. */
+export interface CesiumClockSnapshot {
+    readonly currentTime: unknown;
+    readonly startTime: unknown;
+    readonly stopTime: unknown;
+    readonly multiplier: number | undefined;
+    readonly shouldAnimate: boolean | undefined;
+}
+/** Stable diagnostic codes emitted by the Cesium time binding. */
+export type SceneTimeDiagnosticCode = "scene-time-applied" | "scene-time-host-owned" | "scene-time-clock-unbound" | "scene-time-invalid" | "scene-time-runtime-unavailable";
+/**
+ * Translate a renderer-neutral timeline slice into Cesium clock writes.
+ *
+ * Pure: no Cesium import, no clock, no side effect. Returns `undefined` when the
+ * timeline declares nothing at all, so an empty slice (the default workspace
+ * state) produces no diagnostic and no write.
+ *
+ * `currentTime`, `startTime`, and `endTime` are ISO-8601 in the workspace
+ * contract and are passed through as strings for `JulianDate.fromIso8601`; each
+ * is validated with `Date.parse` first so an unparseable instant is *named*
+ * rather than handed to Cesium. The extent is applied only when both ends parse
+ * and `start < end`, because a half or inverted extent would leave a Cesium
+ * `Timeline` widget describing a range that does not exist.
+ */
+export declare function sceneTimelineToCesiumClockPlan(timeline: SceneTimelineState | undefined): CesiumClockPlan | undefined;
+/** Whether a plan would actually write anything to a clock. */
+export declare function cesiumClockPlanWrites(plan: CesiumClockPlan | undefined): boolean;
+/** Read the clock values a plan is about to displace. */
+export declare function readCesiumClock(clock: CesiumClockLike): CesiumClockSnapshot;
+/** Restore a clock to a snapshot taken by {@link readCesiumClock}. */
+export declare function restoreCesiumClock(clock: CesiumClockLike, snapshot: CesiumClockSnapshot): void;
+/**
+ * Apply a {@link CesiumClockPlan} to a live clock and return what it displaced.
+ *
+ * The extent is written before `currentTime` so a clock whose `clockRange`
+ * clamps to `[startTime, stopTime]` accepts the new instant rather than pinning
+ * it to the previous range's edge.
+ */
+export declare function applyCesiumClockPlan(clock: CesiumClockLike, plan: CesiumClockPlan, runtime: CesiumClockRuntimeModule): CesiumClockSnapshot;
+/** Whether a loaded peer exposes the time symbols the clock binding needs. */
+export declare function isCesiumClockRuntime(runtime: unknown): runtime is CesiumClockRuntimeModule;
+/** The outcome of one time application, ready to fold into an apply result. */
+export interface CesiumSceneTimeApplication {
+    /** `true` when at least one clock field was written. */
+    readonly applied: boolean;
+    /** What the plan asked for, whether or not it was applied. */
+    readonly plan: CesiumClockPlan | undefined;
+    /** Displaced values, present only when something was written. */
+    readonly previous: CesiumClockSnapshot | undefined;
+    readonly diagnostics: readonly ScenePrimitiveDiagnostic[];
+}
+/**
+ * Bind the workspace timeline slice to a scene target's clock.
+ *
+ * Every arm reports itself, so the diagnostic list always answers "did the
+ * application time reach the globe, and if not, why":
+ *
+ * | Situation | Code | Status |
+ * | --- | --- | --- |
+ * | Written to the clock | `scene-time-applied` | supported |
+ * | `clockOwnership: "host"` | `scene-time-host-owned` | supported |
+ * | Time declared, no clock on the target | `scene-time-clock-unbound` | degraded |
+ * | Time declared but uninterpretable | `scene-time-invalid` | degraded |
+ * | Peer has no usable `JulianDate` | `scene-time-runtime-unavailable` | degraded |
+ *
+ * The `rebuildBoundary: "none"` on `scene-time-applied` is load-bearing: it
+ * states, in the same vocabulary the mount uses for plan revisions, that moving
+ * time rebuilt nothing.
+ */
+export declare function applyCesiumSceneTime(target: CesiumClockTarget, timeline: SceneTimelineState | undefined, runtime: unknown): CesiumSceneTimeApplication;
+/**
+ * What an update had to cross to land.
+ *
+ * - `none` — applied in place. The binding's renderer resource was reused
+ *   untouched. Advancing application time is always this.
+ * - `primitive-identity` — the binding is new to this mount (kind + id were not
+ *   previously mounted), so its resource was constructed.
+ * - `primitive-configuration` — the binding's configuration fingerprint changed,
+ *   so its resource was rebuilt. This is the boundary a realtime data delta
+ *   crosses when it revises a binding rather than only its time.
+ * - `plan-membership` — the binding left the plan, so its resource was released.
+ * - `unfingerprintable` — the primitive could not be fingerprinted
+ *   deterministically, so it was rebuilt conservatively rather than assumed
+ *   unchanged.
+ */
+export type SceneRebuildBoundary = "none" | "primitive-identity" | "primitive-configuration" | "plan-membership" | "unfingerprintable";
+/** The boundary vocabulary, in escalation order. */
+export declare const SCENE_REBUILD_BOUNDARIES: readonly SceneRebuildBoundary[];
+/** One binding's outcome across an update. */
+export interface SceneRebuildBoundaryReport {
+    readonly id: string;
+    readonly kind: SceneRuntimePrimitiveKind;
+    readonly boundary: SceneRebuildBoundary;
+    /** `true` when the binding's renderer resource survived the update untouched. */
+    readonly incremental: boolean;
+    readonly reason: string;
+}
+/** Build one boundary report with the vocabulary's own stable reason text. */
+export declare function sceneRebuildBoundaryReport(id: string, kind: SceneRuntimePrimitiveKind, boundary: SceneRebuildBoundary): SceneRebuildBoundaryReport;
+/** A half-open window `[start, end)` in epoch milliseconds. */
+export interface CesiumTemporalPlaybackWindow {
+    readonly start: number;
+    readonly end: number;
+}
+/**
+ * The structural slice of a temporal playback controller this binding drives.
+ *
+ * Declared here rather than imported so `scene-workspace` never pulls the `/map`
+ * entrypoint into its graph — the same structural-typing posture
+ * `<honua-time-slider>` takes with `HonuaTimeSliderPlayback`. A
+ * `createTemporalPlayback()` controller satisfies it exactly.
+ */
+export interface CesiumTemporalPlayback {
+    readonly playing: boolean;
+    /** The window currently applied by the controller. */
+    readonly window: CesiumTemporalPlaybackWindow;
+    /** The full playable extent. */
+    readonly extent: CesiumTemporalPlaybackWindow;
+    /** Current playback rate multiplier, when the controller exposes one. */
+    readonly speed?: number;
+    on(type: "tick", listener: (event: {
+        window: CesiumTemporalPlaybackWindow;
+    }) => void): {
+        remove(): void;
+    };
+    on(type: "play" | "pause" | "end", listener: () => void): {
+        remove(): void;
+    };
+    on(type: "error", listener: (error: unknown) => void): {
+        remove(): void;
+    };
+}
+/**
+ * Which edge of the playback window becomes the clock's instant.
+ *
+ * A playback window is an interval and a Cesium clock is an instant, so the
+ * mapping is `equivalent`, never exact. `"window-start"` (the default) matches
+ * `<honua-time-slider>`'s `aria-valuenow` and the controller's own `scrub()` and
+ * `progress` semantics, so a slider and a globe agree on what time it is.
+ * `"window-end"` binds the window's leading edge instead, which is what a
+ * trailing-window live feed usually means by "now".
+ */
+export type CesiumTemporalPlaybackInstant = "window-start" | "window-end";
+/**
+ * How the binding treats Cesium's own clock animation.
+ *
+ * - `"paused"` (default): `shouldAnimate` is set to `false` for as long as the
+ *   binding is live. The controller is the transport and the SDK is the only
+ *   writer of `currentTime`; letting Cesium animate the same clock would put two
+ *   drivers on it.
+ * - `"mirror"`: `shouldAnimate` follows `playback.playing` and `Clock.multiplier`
+ *   follows `playback.speed`, scaled by whatever multiplier the clock carried at
+ *   bind time. Cesium then interpolates between the controller's frames and the
+ *   controller re-anchors it to canonical time on every tick. Use it when
+ *   entity interpolation should look continuous rather than stepped.
+ */
+export type CesiumTemporalPlaybackTransport = "paused" | "mirror";
+/** Options for {@link bindTemporalPlaybackToCesium}. */
+export interface BindTemporalPlaybackToCesiumOptions {
+    /** Which window edge becomes `Clock.currentTime`. @default "window-start" */
+    readonly instant?: CesiumTemporalPlaybackInstant;
+    /** How Cesium's own clock animation is treated. @default "paused" */
+    readonly transport?: CesiumTemporalPlaybackTransport;
+    /**
+     * Write `Clock.startTime` / `Clock.stopTime` from the controller's extent so a
+     * Cesium `Timeline` widget shows the playable range. @default true
+     */
+    readonly bindExtent?: boolean;
+    /** Apply the controller's current window immediately on bind. @default true */
+    readonly applyImmediately?: boolean;
+    /** Inject the peer or a lazy loader. Omit to use `import("cesium")`. */
+    readonly cesium?: CesiumClockRuntimeModule | CesiumClockRuntimeLoader;
+}
+/** Why a binding stood down instead of driving the clock. */
+export type CesiumTemporalPlaybackRefusal = "clock-unbound" | "host-owned" | "runtime-unavailable";
+/** The handle returned by {@link bindTemporalPlaybackToCesium}. */
+export interface CesiumTemporalPlaybackBinding {
+    /** `false` when the binding stood down; see {@link refusal}. */
+    readonly bound: boolean;
+    /** Present exactly when {@link bound} is `false`. */
+    readonly refusal?: CesiumTemporalPlaybackRefusal;
+    /** How many controller events have been written to the clock. */
+    readonly applications: number;
+    /** The most recent plan written (or, when unbound, the one that was refused). */
+    readonly plan: CesiumClockPlan | undefined;
+    /**
+     * Drop the controller subscriptions and restore the clock exactly as it was at
+     * bind time. Idempotent. A binding that never wrote restores nothing.
+     */
+    dispose(): void;
+}
+/**
+ * Drive a live Cesium clock from a renderer-neutral temporal playback
+ * controller.
+ *
+ * This is the Cesium sink `createTemporalPlayback()` never had: the same
+ * controller instance can hold a MapLibre filter binding, a data-to-map bridge
+ * `where` clause, a `<honua-time-slider>` view, and now a globe, without any of
+ * them knowing about the others.
+ *
+ * Ownership is the target's, not this function's: a target with no clock, or one
+ * that declares `clockOwnership: "host"`, gets an inert binding whose `refusal`
+ * names why. Nothing is written and nothing is thrown — a UI binding must not
+ * explode because the host drives its own clock.
+ *
+ * @example
+ * ```ts doc-test=skip reason="requires a live Cesium Viewer and a mounted source"
+ * const playback = createTemporalPlayback({ handle: mounted, timeField: "observed_at", ... });
+ * const binding = await bindTemporalPlaybackToCesium(
+ *   { camera: viewer.camera, scene: viewer.scene, clock: viewer.clock },
+ *   playback,
+ * );
+ * playback.play();          // the globe's clock now follows the controller
+ * binding.dispose();        // the clock is restored exactly as it was
+ * ```
+ */
+export declare function bindTemporalPlaybackToCesium(target: CesiumClockTarget, playback: CesiumTemporalPlayback, options?: BindTemporalPlaybackToCesiumOptions): Promise<CesiumTemporalPlaybackBinding>;
+//# sourceMappingURL=cesium-time.d.ts.map

package/scene-workspace/cesium-time.d.ts.map

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