@ggts-sh/svelte 0.43.0

package/dist/inspection/coordinator.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Inspection coordinator: two-slot memo (transient + pinned), semantic /
+ * presentation fingerprints, and pin rebind across layout/identity epochs.
+ *
+ * Snapshot materialization lives in `./resolver.ts`. This module owns identity
+ * tokens, cache keys, and the mutable coordinator factory only.
+ */
+import type { CandidateFacts, CellValue, RenderModel } from "@ggts-sh/core";
+import type { InteractionSource, PlotInspectionChange } from "../interaction/interaction.js";
+import { type InspectionSnapshotCompleteness, type ResolveInspectionInput } from "./resolver.js";
+export interface CoordinatedInspectionInput<Row extends Record<string, CellValue>, Key extends PropertyKey> extends ResolveInspectionInput<Row, Key> {
+    /** Changes only when source identity/order changes, never for layout-only renders. */
+    readonly identityEpoch: PropertyKey;
+    /** Changes whenever layout/geometry changes. */
+    readonly layoutEpoch: PropertyKey;
+    /** Complete is required for pins, custom content, and public callbacks. */
+    readonly completeness?: InspectionSnapshotCompleteness;
+}
+export interface CoordinatedInspection<Row, Key> {
+    /** Internal seed retained by the chart-local coordinator, never emitted. */
+    readonly seed: CandidateFacts;
+    readonly snapshot: PlotInspectionChange<Row, Key>;
+    readonly semanticFingerprint: string;
+    readonly presentationIdentity: string;
+    readonly semanticChanged: boolean;
+    readonly presentationChanged: boolean;
+}
+/**
+ * Stable emit-dedupe token for inspection clear events.
+ * Non-clear emissions must use the coordinator's `semanticFingerprint`
+ * (type-aware key identity); hosts must not invent a second fingerprint.
+ */
+export declare function clearInspectionFingerprint(source: InteractionSource): string;
+/**
+ * Internal adapter coordinator. It owns exactly one transient and one pinned
+ * immutable snapshot; replacement, release, and invalidation drop references
+ * immediately instead of growing a scene-wide rich-object cache.
+ */
+export declare function createInspectionCoordinator<Row extends Record<string, CellValue>, Key extends PropertyKey>(keyAt: (index: number) => Key | null): {
+    resolve: (input: Omit<CoordinatedInspectionInput<Row, Key>, "keyOf">) => CoordinatedInspection<Row, Key> | null;
+    reconcilePinned: (input: Readonly<{
+        model: RenderModel;
+        identityEpoch: PropertyKey;
+        layoutEpoch: PropertyKey;
+        source?: InteractionSource;
+        completeness?: InspectionSnapshotCompleteness;
+    }>) => CoordinatedInspection<Row, Key> | null;
+    release(slot: "transient" | "pinned"): void;
+    invalidate(): void;
+    readonly memoSize: number;
+};

package/dist/inspection/coordinator.js

@@ -0,0 +1,354 @@
+import { materializeInspection, resolvedTarget, selectTransientMembers, } from "./resolver.js";
+import { compositionGroupTotal } from "./group-total.js";
+/**
+ * Stable emit-dedupe token for inspection clear events.
+ * Non-clear emissions must use the coordinator's `semanticFingerprint`
+ * (type-aware key identity); hosts must not invent a second fingerprint.
+ */
+export function clearInspectionFingerprint(source) {
+    return `clear:${source}`;
+}
+const PRESENTATION_ORDERING_VERSION = 1;
+function axisToken(token) {
+    if (token === null)
+        return "invalid";
+    return `${token.kind}:${String(token.value)}`;
+}
+function cellToken(value) {
+    if (value === null)
+        return "null";
+    if (value instanceof Date)
+        return `date:${value.getTime()}`;
+    if (typeof value === "number")
+        return `number:${Object.is(value, -0) ? 0 : value}`;
+    return `${typeof value}:${String(value)}`;
+}
+/**
+ * Stable cell payload for semantic fingerprints. Insertion order of Object.keys
+ * is used (no O(F log F) sort): same row object is stable; content-equal clones
+ * with different key order may re-emit (safe over-emit, not under-emit).
+ */
+function rowCellPayload(row) {
+    const parts = [];
+    for (const field of Object.keys(row)) {
+        parts.push(`${field}=${cellToken(row[field] ?? null)}`);
+    }
+    return parts.join(",");
+}
+/**
+ * Per-batch role token within one layer's batches of the same geometry kind.
+ * Absolute scene batch indices can shift when unrelated layers change; the
+ * role still distinguishes composite pieces (smooth ribbon/line, boxplot
+ * whisker/median). Built once per model — O(B) prep, O(1) lookup (#1329).
+ */
+function buildBatchRoles(model) {
+    const batches = model.scene.batches;
+    const roles = [];
+    const ordinalByLayerKind = new Map();
+    for (let index = 0; index < batches.length; index++) {
+        const batch = batches[index];
+        const layerKind = `${String(batch.layerIndex)}\0${batch.kind}`;
+        const ordinal = ordinalByLayerKind.get(layerKind) ?? 0;
+        roles.push(`${batch.kind}:${ordinal}`);
+        ordinalByLayerKind.set(layerKind, ordinal + 1);
+    }
+    return roles;
+}
+/** O(1) role for a candidate against a precomputed per-model role table. */
+function candidateBatchRole(model, candidate, roles) {
+    const batch = model.scene.batches[candidate.batchIndex];
+    if (batch === undefined ||
+        batch.layerIndex !== candidate.layerIndex ||
+        batch.kind !== candidate.kind)
+        return `${candidate.kind}:missing`;
+    return roles[candidate.batchIndex] ?? `${candidate.kind}:missing`;
+}
+function exactGroupTotalToken(mode, model, seed) {
+    if (mode !== "exact" && mode !== "xy")
+        return "";
+    return String(compositionGroupTotal(model, seed));
+}
+/**
+ * Internal adapter coordinator. It owns exactly one transient and one pinned
+ * immutable snapshot; replacement, release, and invalidation drop references
+ * immediately instead of growing a scene-wide rich-object cache.
+ */
+export function createInspectionCoordinator(keyAt) {
+    let transient = null;
+    let pinned = null;
+    let lastSemanticFingerprint = null;
+    let lastPresentationIdentity = null;
+    let lastSlot = null;
+    /** Last model whose batch-role table is cached (identity compare). */
+    let batchRoleModel = null;
+    let batchRoles = [];
+    const rolesFor = (model) => {
+        if (batchRoleModel === model)
+            return batchRoles;
+        batchRoles = buildBatchRoles(model);
+        batchRoleModel = model;
+        return batchRoles;
+    };
+    const symbolIds = new Map();
+    const epochIds = new Map();
+    const epochToken = (value) => {
+        if (typeof value !== "symbol")
+            return `${typeof value}:${String(value)}`;
+        let id = epochIds.get(value);
+        if (id === undefined) {
+            id = epochIds.size;
+            epochIds.set(value, id);
+        }
+        return `symbol:${id}`;
+    };
+    const semanticKeyToken = (key, fallback) => {
+        if (key === null)
+            return fallback;
+        if (typeof key === "symbol") {
+            let id = symbolIds.get(key);
+            if (id === undefined) {
+                id = symbolIds.size;
+                symbolIds.set(key, id);
+            }
+            return `symbol:${id}`;
+        }
+        return `${typeof key}:${String(key)}`;
+    };
+    const resolve = (input) => {
+        const target = resolvedTarget(input.model, input.seed, input.mode);
+        if (target === null)
+            return null;
+        const completeness = input.state === "pinned" ? "complete" : (input.completeness ?? "transient");
+        // Pin/complete fingerprints the full group; transient matches materialize's
+        // top-k window so pointer inspect is O(min(M,8)·F), not O(M·F log F) (#1274).
+        const fingerprintMembers = completeness === "complete"
+            ? target.members
+            : selectTransientMembers(target.members, target.group?.focusId ?? input.seed.id, {
+                groupAxis: input.mode === "y" ? "y" : "x",
+            });
+        const semanticMembers = fingerprintMembers.map((candidate) => {
+            const row = candidate.rowIndex === null ? null : input.model.row(candidate.rowIndex);
+            const key = row === null || candidate.rowIndex === null ? null : keyAt(candidate.rowIndex);
+            const fallback = `lineage:${input.model.lineage.keys(candidate.lineage).join(",")}`;
+            const payload = row === null
+                ? `${axisToken(candidate.xToken)},${axisToken(candidate.yToken)}`
+                : rowCellPayload(row);
+            return `${semanticKeyToken(key, fallback)}{${payload}}`;
+        });
+        const focusRow = input.seed.rowIndex === null ? null : input.model.row(input.seed.rowIndex);
+        const focusKey = focusRow === null || input.seed.rowIndex === null ? null : keyAt(input.seed.rowIndex);
+        const focusIdentity = semanticKeyToken(focusKey, `lineage:${input.model.lineage.keys(input.seed.lineage).join(",")}`);
+        const logicalToken = input.mode === "x"
+            ? axisToken(input.seed.xToken)
+            : input.mode === "y"
+                ? axisToken(input.seed.yToken)
+                : `${axisToken(input.seed.xToken)}|${axisToken(input.seed.yToken)}`;
+        const semanticFingerprint = [
+            input.mode,
+            input.seed.panelId,
+            logicalToken,
+            focusIdentity,
+            semanticMembers.join(";"),
+            input.state,
+            exactGroupTotalToken(input.mode, input.model, input.seed),
+        ].join("|");
+        const range = target.group?.range;
+        // Mirror fingerprintMembers: transient pinches presentation id to the same
+        // member window as materialize (layoutEpoch + range already cover the bucket).
+        const presentationMembers = fingerprintMembers;
+        const presentationIdentity = [
+            epochToken(input.layoutEpoch),
+            PRESENTATION_ORDERING_VERSION,
+            range === undefined
+                ? `candidate:${input.seed.id}`
+                : `${range.axis}:${range.start}:${range.end}`,
+            presentationMembers
+                .map((candidate) => `${candidate.id}@${candidate.x},${candidate.y}`)
+                .join(";"),
+        ].join("|");
+        const cacheKey = `${epochToken(input.layoutEpoch)}|${presentationIdentity}|${semanticFingerprint}|${completeness}|${input.source}`;
+        const current = input.state === "pinned" ? pinned : transient;
+        if (current?.key === cacheKey)
+            return current.value;
+        const snapshot = materializeInspection(input, target, completeness, keyAt);
+        const value = Object.freeze({
+            seed: input.seed,
+            snapshot,
+            semanticFingerprint,
+            presentationIdentity,
+            semanticChanged: semanticFingerprint !== lastSemanticFingerprint,
+            presentationChanged: presentationIdentity !== lastPresentationIdentity,
+        });
+        const slot = {
+            key: cacheKey,
+            value,
+            seedId: input.seed.id,
+            seedKey: focusKey,
+            seedRow: input.seed.rowIndex,
+            seedKind: input.seed.kind,
+            seedBatchRole: candidateBatchRole(input.model, input.seed, rolesFor(input.model)),
+            seedPrimitiveIndex: input.seed.primitiveIndex,
+            seedLogicalIdentity: `${axisToken(input.seed.xToken)}|${axisToken(input.seed.yToken)}|${input.model.lineage.keys(input.seed.lineage).join(",")}`,
+            layerIndex: input.seed.layerIndex,
+            identityEpoch: input.identityEpoch,
+            mode: input.mode,
+        };
+        if (input.state === "pinned")
+            pinned = slot;
+        else
+            transient = slot;
+        lastSemanticFingerprint = semanticFingerprint;
+        lastPresentationIdentity = presentationIdentity;
+        lastSlot = input.state === "pinned" ? "pinned" : "transient";
+        return value;
+    };
+    /** Keyless pin match: cheap filters then O(L) logical identity (#229). */
+    const keylessPinMatch = (model, prior, candidate, roles) => {
+        if (candidate.layerIndex !== prior.layerIndex)
+            return false;
+        if (candidate.rowIndex !== prior.seedRow)
+            return false;
+        if (candidate.kind !== prior.seedKind)
+            return false;
+        if (candidate.primitiveIndex !== prior.seedPrimitiveIndex)
+            return false;
+        if (candidateBatchRole(model, candidate, roles) !== prior.seedBatchRole)
+            return false;
+        const logicalIdentity = `${axisToken(candidate.xToken)}|${axisToken(candidate.yToken)}|${model.lineage.keys(candidate.lineage).join(",")}`;
+        return logicalIdentity === prior.seedLogicalIdentity;
+    };
+    /**
+     * Keyed pin match: layer + non-null row whose key equals the pinned key.
+     * Key first — `model.row` allocates a full Record (O(F)). Identity-change
+     * full-scans must not pay that for every candidate in the layer (#1318 /
+     * #1329). Live-row gate stays: key bag can outlive a dropped source index.
+     */
+    const keyedPinMatch = (model, prior, candidate) => {
+        if (candidate.layerIndex !== prior.layerIndex || candidate.rowIndex === null)
+            return false;
+        if (keyAt(candidate.rowIndex) !== prior.seedKey)
+            return false;
+        return model.row(candidate.rowIndex) !== null;
+    };
+    /**
+     * Strict keyed rebind for the seedId fast path: key match plus kind / batch
+     * role / primitive (same filters as multi-match disambiguation). Same-epoch
+     * is not always pure layout — layer-prop swaps can keep the identity token
+     * while changing primitives that reuse an id (Codex #272 P2).
+     */
+    const keyedPinRoleMatch = (model, prior, candidate, roles) => keyedPinMatch(model, prior, candidate) &&
+        candidate.kind === prior.seedKind &&
+        candidate.primitiveIndex === prior.seedPrimitiveIndex &&
+        candidateBatchRole(model, candidate, roles) === prior.seedBatchRole;
+    const preferredPinnedSeed = (model, prior, identityEpoch, roles) => {
+        if (prior.identityEpoch !== identityEpoch)
+            return null;
+        const preferred = model.candidates.candidate(prior.seedId);
+        if (preferred === null)
+            return null;
+        if (prior.seedKey === null)
+            return keylessPinMatch(model, prior, preferred, roles) ? preferred : null;
+        return keyedPinRoleMatch(model, prior, preferred, roles) ? preferred : null;
+    };
+    const uniqueKeylessPinnedSeed = (model, prior, roles) => {
+        const matches = [];
+        for (let id = 0; id < model.candidates.size; id++) {
+            const candidate = model.candidates.candidate(id);
+            if (candidate !== null && keylessPinMatch(model, prior, candidate, roles))
+                matches.push(candidate);
+        }
+        return matches.length === 1 ? matches[0] : null;
+    };
+    const uniqueKeyedPinnedSeed = (model, prior, roles) => {
+        const matches = [];
+        for (let id = 0; id < model.candidates.size; id++) {
+            const candidate = model.candidates.candidate(id);
+            if (candidate !== null && keyedPinMatch(model, prior, candidate))
+                matches.push(candidate);
+        }
+        if (matches.length === 1)
+            return matches[0];
+        if (matches.length < 2)
+            return null;
+        const sourceRows = new Set(matches.map((candidate) => candidate.rowIndex));
+        if (sourceRows.size !== 1)
+            return null;
+        const sameRole = matches.filter((candidate) => candidate.kind === prior.seedKind &&
+            candidateBatchRole(model, candidate, roles) === prior.seedBatchRole &&
+            candidate.primitiveIndex === prior.seedPrimitiveIndex);
+        return sameRole.length === 1 ? sameRole[0] : null;
+    };
+    const clearPinned = () => {
+        pinned = null;
+        if (lastSlot !== "pinned")
+            return;
+        lastSemanticFingerprint = null;
+        lastPresentationIdentity = null;
+        lastSlot = null;
+    };
+    const reconcilePinned = (input) => {
+        const prior = pinned;
+        if (prior === null)
+            return null;
+        const roles = rolesFor(input.model);
+        // Same identityEpoch: O(1) seedId revalidation when id + role still match.
+        // Keyed path requires kind/batch/primitive (not only layer+key) so geom
+        // swaps that reuse seedId cannot pin the wrong primitive. Fall through to
+        // full scan on miss. Identity-change keyed still full-scans for ambiguity;
+        // keyless identity-change clears immediately below.
+        let seed = preferredPinnedSeed(input.model, prior, input.identityEpoch, roles);
+        if (seed === null && prior.seedKey === null) {
+            if (prior.identityEpoch !== input.identityEpoch) {
+                clearPinned();
+                return null;
+            }
+            seed = uniqueKeylessPinnedSeed(input.model, prior, roles);
+        }
+        else {
+            seed ??= uniqueKeyedPinnedSeed(input.model, prior, roles);
+        }
+        if (seed === null) {
+            clearPinned();
+            return null;
+        }
+        return resolve({
+            model: input.model,
+            seed,
+            mode: prior.mode,
+            state: "pinned",
+            source: input.source ?? "programmatic",
+            identityEpoch: input.identityEpoch,
+            layoutEpoch: input.layoutEpoch,
+            completeness: input.completeness ?? "complete",
+        });
+    };
+    return {
+        resolve,
+        reconcilePinned,
+        release(slot) {
+            if (slot === "transient")
+                transient = null;
+            else
+                pinned = null;
+            if (lastSlot === slot) {
+                lastSemanticFingerprint = null;
+                lastPresentationIdentity = null;
+                lastSlot = null;
+            }
+        },
+        invalidate() {
+            transient = null;
+            pinned = null;
+            lastSemanticFingerprint = null;
+            lastPresentationIdentity = null;
+            lastSlot = null;
+            batchRoleModel = null;
+            batchRoles = [];
+            symbolIds.clear();
+            epochIds.clear();
+        },
+        get memoSize() {
+            return Number(transient !== null) + Number(pinned !== null);
+        },
+    };
+}

package/dist/inspection/display-members.d.ts

@@ -0,0 +1 @@
+export { type TooltipAxisFormatters, formatTooltipCell, type TooltipFieldLabs, tooltipFieldLabel, fieldsForDefaultTooltip, defaultTooltipRows, tooltipDisplayPayloadToken, selectHoverDisplayMembers, collapseIdenticalDisplayMembers, } from "@ggts-sh/core/interaction";

package/dist/inspection/display-members.js

@@ -0,0 +1,2 @@
+// Shared pure behavior used by React and Svelte.
+export { formatTooltipCell, tooltipFieldLabel, fieldsForDefaultTooltip, defaultTooltipRows, tooltipDisplayPayloadToken, selectHoverDisplayMembers, collapseIdenticalDisplayMembers, } from "@ggts-sh/core/interaction";

package/dist/inspection/frame.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Pure decision tables for capture-surface inspection *frame* policy:
+ * pointer-move queue payloads and onPointerFrame routing.
+ * InspectionState owns queue mutation and setInspection side effects;
+ * these tables stay pure routing helpers.
+ */
+import type { CandidateFacts, CandidateMatch } from "@ggts-sh/core";
+import type { InteractionSource } from "../interaction/interaction.js";
+import type { InteractionCandidateRef } from "../interaction/reducer.js";
+/** Host inspection lifecycle state used across pure inspection tables. */
+export type InspectionHostState = "none" | "transient" | "pinned";
+/**
+ * Host queue payload for pointer-move / touch-inspect frames and pending pin restore.
+ * `concreteMode` is present only when a nearest match supplied the mode.
+ * Candidate is the sole hit authority — no parallel SceneHit projection (#1038).
+ */
+export type QueuedPointerInspection = {
+    candidate: CandidateFacts | null;
+    source: InteractionSource;
+    concreteMode?: "exact" | "x" | "y" | "xy";
+};
+/**
+ * Build the queued pointer-inspect payload.
+ * Match is a single object: mode and candidate always come from the same nearest hit.
+ */
+export declare function buildQueuedPointerInspection(input: {
+    readonly source: InteractionSource;
+    readonly match: CandidateMatch | null;
+}): QueuedPointerInspection;
+/**
+ * Cohesive queue-inspect frame payload for host `onPointerMove` queue-inspect.
+ *
+ * Owns the single `match === null` branch for hit resolution + reducer
+ * candidate ref (avoids three separate null checks / eager hitTest).
+ * `fallbackCandidate` is evaluated only on the path that needs it.
+ * Candidate `panelId` comes from the facts object (no scene index round-trip).
+ */
+export type QueuedInspectFrameBuild = {
+    readonly queued: QueuedPointerInspection;
+    readonly candidate: InspectionCandidateRef | null;
+};
+export declare function buildQueuedInspectFrame(input: {
+    readonly match: CandidateMatch | null;
+    readonly source: InteractionSource;
+    readonly epoch: number;
+    /** Evaluated only when match is null. */
+    readonly fallbackCandidate: () => CandidateFacts | null;
+}): QueuedInspectFrameBuild;
+export type QueuedInspectFrameInput = {
+    /** True when a snapshotted `queuedPointerInspection` payload exists. */
+    readonly hasPending: boolean;
+    /**
+     * Host: `token === null || reducer.accepts(token)`.
+     * Compute only after confirming a pending payload exists (or short-circuit
+     * so `reducer.accepts` is not called when `hasPending` is false).
+     */
+    readonly tokenAccepted: boolean;
+    /** Current host inspection: null → `"none"`, else `inspection.state`. */
+    readonly currentState: InspectionHostState;
+    /**
+     * Host: `action.candidate !== null && action.candidate.epoch !== model?.runId`
+     * from the reducer frame action (not the queued candidate snapshot).
+     * When the frame action has no candidate, pass false.
+     */
+    readonly candidateEpochMismatch: boolean;
+};
+export type QueuedInspectFrameAction = {
+    readonly type: "none";
+} | {
+    readonly type: "drop";
+} | {
+    readonly type: "stash-pending";
+} | {
+    readonly type: "apply-pending";
+};
+/**
+ * Pure decision for the inspect branch of `onInspectPointerFrame` after
+ * InspectionState has snapshotted and cleared queue fields.
+ *
+ * Priority:
+ *   1. none — !hasPending
+ *   2. drop — !tokenAccepted (stale frame token) → skip reducer dispatch
+ *   3. stash-pending — currentState === "pinned"
+ *   4. drop — candidateEpochMismatch → skip reducer dispatch
+ *   5. apply-pending
+ */
+export declare function resolveQueuedInspectFrameAction(input: QueuedInspectFrameInput): QueuedInspectFrameAction;
+/** Reducer inspect payload candidate — same type as InteractionCandidateRef (#1080). */
+type InspectionCandidateRef = InteractionCandidateRef;
+export {};

package/dist/inspection/frame.js

@@ -0,0 +1,76 @@
+/**
+ * Pure decision tables for capture-surface inspection *frame* policy:
+ * pointer-move queue payloads and onPointerFrame routing.
+ * InspectionState owns queue mutation and setInspection side effects;
+ * these tables stay pure routing helpers.
+ */
+/**
+ * Build the queued pointer-inspect payload.
+ * Match is a single object: mode and candidate always come from the same nearest hit.
+ */
+export function buildQueuedPointerInspection(input) {
+    if (input.match === null) {
+        return { candidate: null, source: input.source };
+    }
+    return {
+        candidate: input.match,
+        source: input.source,
+        concreteMode: input.match.mode,
+    };
+}
+export function buildQueuedInspectFrame(input) {
+    if (input.match === null) {
+        const fallback = input.fallbackCandidate();
+        if (fallback === null)
+            return {
+                queued: { candidate: null, source: input.source },
+                candidate: null,
+            };
+        return {
+            queued: { candidate: fallback, source: input.source },
+            candidate: {
+                epoch: input.epoch,
+                id: fallback.id,
+                panelId: fallback.panelId,
+                x: fallback.x,
+                y: fallback.y,
+            },
+        };
+    }
+    const match = input.match;
+    return {
+        queued: buildQueuedPointerInspection({
+            source: input.source,
+            match,
+        }),
+        candidate: {
+            epoch: input.epoch,
+            id: match.id,
+            panelId: match.panelId,
+            x: match.x,
+            y: match.y,
+        },
+    };
+}
+/**
+ * Pure decision for the inspect branch of `onInspectPointerFrame` after
+ * InspectionState has snapshotted and cleared queue fields.
+ *
+ * Priority:
+ *   1. none — !hasPending
+ *   2. drop — !tokenAccepted (stale frame token) → skip reducer dispatch
+ *   3. stash-pending — currentState === "pinned"
+ *   4. drop — candidateEpochMismatch → skip reducer dispatch
+ *   5. apply-pending
+ */
+export function resolveQueuedInspectFrameAction(input) {
+    if (!input.hasPending)
+        return { type: "none" };
+    if (!input.tokenAccepted)
+        return { type: "drop" };
+    if (input.currentState === "pinned")
+        return { type: "stash-pending" };
+    if (input.candidateEpochMismatch)
+        return { type: "drop" };
+    return { type: "apply-pending" };
+}

package/dist/inspection/group-total.d.ts

@@ -0,0 +1 @@
+export { compositionGroupTotal } from "@ggts-sh/core/interaction";

package/dist/inspection/group-total.js

@@ -0,0 +1,2 @@
+// Shared pure behavior used by React and Svelte.
+export { compositionGroupTotal } from "@ggts-sh/core/interaction";

package/dist/inspection/inspect-guide-axes.d.ts

@@ -0,0 +1,10 @@
+import type { ResolvedInspectMode } from "../interaction/interaction.js";
+export type InspectGuideAxes = {
+    readonly vertical: boolean;
+    readonly horizontal: boolean;
+};
+/**
+ * Which screen-space crosshairs an inspect mode paints.
+ * `coord_flip` swaps x/y guides; exact paints none; xy paints both.
+ */
+export declare function inspectGuideAxes(mode: ResolvedInspectMode, flipped: boolean): InspectGuideAxes;

package/dist/inspection/inspect-guide-axes.js

@@ -0,0 +1,24 @@
+/**
+ * Which screen-space crosshairs an inspect mode paints.
+ * `coord_flip` swaps x/y guides; exact paints none; xy paints both.
+ */
+export function inspectGuideAxes(mode, flipped) {
+    switch (mode) {
+        case "exact":
+            return { vertical: false, horizontal: false };
+        case "xy":
+            return { vertical: true, horizontal: true };
+        case "x":
+            return flipped
+                ? { vertical: false, horizontal: true }
+                : { vertical: true, horizontal: false };
+        case "y":
+            return flipped
+                ? { vertical: true, horizontal: false }
+                : { vertical: false, horizontal: true };
+        default: {
+            const unexpected = mode;
+            throw new TypeError(`unexpected inspect mode ${String(unexpected)}`);
+        }
+    }
+}

package/dist/inspection/inspection-reconcile.svelte.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Scene-run inspection reconcile + coordinator disposal — construction-time
+ * effect registration extracted from inspection-state.svelte.ts for S5
+ * (plan §4).
+ *
+ * registerSceneInspectReconcile is invoked synchronously during
+ * createInspectionState construction so both $effects register during init
+ * (#627). It owns only the reconciledRun cursor. Rune state (inspection,
+ * seed), fingerprints, candidate IDs, and the dismissal latch remain in the
+ * inspection-state lexical owner; this module reads and mutates them only
+ * through the live ports. The plan/apply split stays in teardown.ts (pure) —
+ * this module is the $effect shell: plan + bag wiring.
+ */
+import type { RenderModel } from "@ggts-sh/core";
+import type { InspectionHostState } from "./frame.js";
+import { type SceneInspectReconcileBag } from "./teardown.js";
+/**
+ * Live ports for the scene-run reconcile effect. Everything except `model`/
+ * `inspectEnabled`/`getInspectionState` is applied verbatim as the
+ * `SceneInspectReconcileBag`; `setReconciledRun` is owned here — the run
+ * cursor never leaves this module.
+ */
+export type SceneInspectReconcilePorts = Pick<SceneInspectReconcileBag, "clearInspection" | "setInspectionFromReconcile" | "setActiveCandidateId" | "clearDismissedLatch" | "dispatchSceneInvalidate" | "cancelPointerDiscardPending" | "clearPointerForSceneInvalidate" | "coordinatorInvalidate" | "releaseTransient" | "reconcilePinned" | "emitClearProgrammatic" | "emitSemanticChange"> & {
+    /** Effect dependency: model identity (runId) drives scene-run reconcile. */
+    readonly model: () => RenderModel | null;
+    /** Effect dependency: inspect enablement gates the clear-disabled plan. */
+    readonly inspectEnabled: () => boolean;
+    readonly dataIdentityEpoch: () => PropertyKey;
+    /** Thunk so same-run skip does not subscribe to hover inspection updates. */
+    readonly getInspectionState: () => InspectionHostState;
+};
+/**
+ * Register the coordinator-disposal + scene-run reconcile effects (formerly
+ * host-phased registerInspectionEffects — registered at construction, #627).
+ * Must be called synchronously during createInspectionState construction.
+ */
+export declare function registerSceneInspectReconcile(ports: SceneInspectReconcilePorts): void;