@modernrelay/orbit-core 0.2.0 → 0.13.5

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-import { G as GraphSnapshot, A as AcceptedGraph, R as ResolvedGroup, a as GraphDiagnostic, b as GraphNode, c as AcceptedEdge, N as NodeId, M as MetaEdge, S as SceneFold, d as GroupSpec, e as GroupBySpec, f as SceneGroups, g as RenderScene, h as SceneLinkRef, i as ScenePointRef, j as Accessor, k as RevisionAwareService, l as RequestContext, m as SearchResult, V as ViewportState, n as SelectionState, o as SubgraphSpec, J as JsonValue, E as EngineFactory, p as ExpansionService, P as PathService, q as GraphTheme, r as GraphStoreState, L as LabelPlacement, s as GraphHostUpdate, B as BeginIngestOptions, I as IngestSession, t as GraphEventName, u as GraphEventMap, v as GraphListenerControl, w as EdgeId, x as ResolvedCluster, y as PathOptions, z as PathResult, C as SearchActivation, D as CrossfilterSession, T as TimelinePlayback, F as Scale, H as MetricName, K as Revisions, O as AccessibilityConfig, Q as ThemeInput, U as LabelConfig, W as IngestBatch, X as RevisionDimension, Y as FilterSpec, Z as FilterExpr, _ as DimensionSpec, $ as BrushState, a0 as DimensionSummary, a1 as DomainPolicy, a2 as EngineBufferChannel, a3 as GraphEngine, a4 as EngineCommit, a5 as EngineCapabilities, a6 as MetricColumn } from './index-BPjuELfY.js';
-export { a7 as AppendReceipt, a8 as CategoryBin, a9 as ClusterSpec, aa as DIAGNOSTIC_SAMPLE_CAP, ab as DiagnosticCode, ac as DiagnosticSeverity, ad as DimensionKind, ae as ErrorPhase, af as ExpansionBatch, ag as ExpansionResponse, ah as FilterMode, ai as FilterValue, aj as GraphEdge, ak as GraphError, al as GraphOperationError, am as HistogramBin, an as IngestCommitReceipt, ao as IngestSessionState, ap as InstanceStatus, aq as LayoutKind, ar as NodeEventPayload, as as OrbitOperationError, at as ResourceAdmissionReport, au as SearchUnavailableReason, av as SimulationConfig, aw as graphErrorToError, ax as isFatalGraphError, ay as resourceLimitFatal } from './index-BPjuELfY.js';
-export { C as ClusterDerivation, D as DEFAULT_CLUSTER_CENTER_RADIUS, a as DEFAULT_LAYOUT_SEED, c as clusterCentroids, d as deriveClusters, g as generateClusterCenters, r as resolveClusterCenters } from './clusters-ExqnvobT.js';
+import { f as GraphSnapshot, A as AcceptedGraph, R as ResolvedGroup, d as GraphDiagnostic, e as GraphNode, g as AcceptedEdge, N as NodeId, M as MetaEdge, S as SceneFold, h as GroupSpec, i as GroupBySpec, j as SceneGroups, k as RenderScene, l as SceneLinkRef, m as ScenePointRef, n as Accessor, o as RevisionAwareService, p as RequestContext, q as SearchResult, V as ViewportState, r as SelectionState, s as SubgraphSpec, J as JsonValue, t as EngineFactory, u as ExpansionService, P as PathService, v as ScaleLimits, w as GraphTheme, x as GraphStoreState, L as LabelPlacement, y as GraphHostUpdate, B as BeginIngestOptions, I as IngestSession, z as GraphEventName, C as GraphEventMap, D as GraphListenerControl, H as EdgeId, K as GraphPerfSnapshot, O as ResolvedCluster, Q as PathOptions, T as PathResult, U as SearchActivation, W as CrossfilterSession, X as TimelinePlayback, Y as Scale, Z as MetricName, _ as Revisions, $ as AccessibilityConfig, a0 as ThemeInput, a1 as LabelConfig, a2 as IngestBatch, a3 as RevisionDimension, a4 as FilterSpec, a5 as FilterExpr, a6 as DimensionSpec, a7 as BrushState, a8 as DimensionSummary, a9 as DomainPolicy, aa as EngineBufferChannel, G as GraphEngine, a as EngineCommit, E as EngineCapabilities, ab as MetricColumn, ac as ColumnarGraphSnapshot, ad as GraphSnapshotInput } from './index-CFZMson3.js';
+export { ae as AppendReceipt, af as CategoryBin, ag as ClusterSpec, ah as Column, ai as ColumnChange, aj as DIAGNOSTIC_SAMPLE_CAP, ak as DegradeEvent, al as DegradeStep, am as DiagnosticCode, an as DiagnosticSeverity, ao as DimensionKind, ap as ErrorPhase, aq as ExpansionBatch, ar as ExpansionResponse, as as FilterMode, at as FilterValue, au as GraphEdge, av as GraphError, aw as GraphOperationError, ax as HistogramBin, ay as IngestCommitReceipt, az as IngestSessionState, aA as InstanceStatus, aB as LayoutKind, aC as NodeEventPayload, aD as OrbitOperationError, aE as ResourceAdmissionReport, aF as ResourceDegradeStep, aG as SearchUnavailableReason, aH as SimulationConfig, aI as StringColumn, aJ as graphErrorToError, aK as isFatalGraphError, aL as resourceLimitFatal } from './index-CFZMson3.js';
+import { b as WorkerFactoryOption } from './lane-CHHLuxgq.js';
+export { C as ClusterDerivation, D as DEFAULT_CLUSTER_CENTER_RADIUS, d as DEFAULT_LAYOUT_SEED, E as EncodedStringTable, R as RequestClass, e as WorkerEntity, a as WorkerEnvelope, W as WorkerTransport, f as clusterCentroids, g as collectTransfers, h as decodeStringTable, i as deriveClusters, j as encodeStringTable, k as generateClusterCenters, l as judgeEpoch, m as resolveClusterCenters } from './lane-CHHLuxgq.js';
 import { StoreApi } from 'zustand/vanilla';
 
 /**
@@ -794,12 +795,33 @@ interface CreateGraphInstanceOptions<N = Record<string, unknown>, E = Record<str
     history?: boolean | {
         limit?: number;
     };
+    /**
+     * §17/§6.1 degradation-ladder thresholds (S13-T08). CONSTRUCTION-ONLY
+     * (D7): read once; invalid fields fall back to the spec defaults with ONE
+     * config warning diagnostic. A runtime change requires a keyed remount.
+     */
+    limits?: Partial<ScaleLimits>;
     /**
      * §8 image-atlas resolver seam (S10): owns authenticated fetch/caching for
      * one `nodeImage` ref. Default: plain `fetch(ref)` for public URLs.
      * Injectable for tests and authenticated hosts.
      */
     imageResolver?: ImageResolver;
+    /**
+     * §6.1/§17 execution mode (ADR-006 D1; CONSTRUCTION-ONLY, D7). Current
+     * worker cargo: columnar ACCEPTANCE (validate + dedupe + link resolution
+     * off-thread; §7.5-style async admission). 'main' (default) keeps every
+     * columnar ingest synchronous; 'auto' and 'worker' route columnar data
+     * through the worker lane when it boots — an unavailable lane degrades
+     * to 'main' with one `worker-unavailable` info diagnostic under 'auto'
+     * and an ERROR diagnostic under 'worker' (which never silently falls
+     * back on channel work, but acceptance has no worker-REQUIRED semantics
+     * yet — channel projection cargo is the registered follow-up).
+     */
+    execution?: 'auto' | 'main' | 'worker';
+    /** ADR-006 D5 worker construction tri-option (URL / factory / inline
+     * default). Testing seam: `transport` on the lane via this factory. */
+    workerFactory?: WorkerFactoryOption;
 }
 /**
  * `expandNode` outcome (§9.2/§16.3):
@@ -911,6 +933,17 @@ interface GraphInstance<N = Record<string, unknown>, E = Record<string, unknown>
         highlightNeighbors?: boolean;
         hops?: 1;
     }): readonly NodeId[];
+    /**
+     * §13 emphasis ring WITHOUT the camera: ring `id` (null clears). The light
+     * op keyboard navigation needs — arrowing a list must not fly the camera on
+     * every keystroke (`focusNode` stays ring + zoom + neighbors). Unknown ids
+     * are a silent no-op (a stale row racing a model swap is data, not an
+     * error); `emphasisRing: false` suppresses it entirely. The target is
+     * STICKY: it survives structural commits and context recovery until it is
+     * cleared, its id departs the model, or pointer hover supersedes it
+     * (emphasis belongs to the latest action — the §16.2 rule).
+     */
+    emphasizeNode(id: NodeId | null): void;
     /**
      * §14/§15 typed context-menu channel, opened from a DOM presenter. Label
      * divs are `pointerEvents: 'auto'` by design (click-to-focus), so a
@@ -958,6 +991,37 @@ interface GraphInstance<N = Record<string, unknown>, E = Record<string, unknown>
     /** Fallback-route click resolution: emits 'edgeClick' when a link is within
      * tolerance. No-op (null) on the native route. */
     sampleEdgeClick(screen: readonly [number, number]): AcceptedEdge<E> | null;
+    /**
+     * @internal §15/§17 shared hit-test/overlay cadence: the count of engine
+     * onFrame ticks this session. THE one clock every sampling route throttles
+     * against (node hover and link picking share it by construction — there is
+     * no second cadence timer anywhere; the S13-T06 lint rule enforces it).
+     * The S13 ladder's defer-link-picking arms/disarms against this counter;
+     * §17 telemetry reads it for idle-wakeup accounting.
+     */
+    getFrameCadence(): number;
+    /**
+     * @internal F10-02 op counters (live object — snapshot before comparing):
+     * the perf-gate-delta suite proves the brush fast path does O(Δ) work —
+     * zero full recomposes/refreshes/cascades across a scrub. §17 telemetry
+     * (S13-T07) will fold these into `lastCommitMs`-adjacent accounting.
+     */
+    getPerfCounters(): Readonly<{
+        brushSlotsTranslated: number;
+        fullBrushRefreshes: number;
+        fullCascades: number;
+        fullNodeRecomposes: number;
+        fullEdgeRecomposes: number;
+    }>;
+    /**
+     * §17 telemetry snapshot (S13-T07): counts, byte estimates, queue depth,
+     * revisions, last-commit phase decomposition, active ladder steps,
+     * execution lane, range availability, and the pressure mirror — never raw
+     * attrs or ids. Synchronous in every lifecycle state (pre-scene fields
+     * read zero/absent). `validate` is folded into `derive` until the
+     * columnar lane splits acceptance from derivation (PR-E).
+     */
+    getPerfSnapshot(): GraphPerfSnapshot;
     hideNodes(ids: readonly NodeId[]): void;
     showNodes(ids: readonly NodeId[]): void;
     showAll(): void;
@@ -1355,6 +1419,22 @@ declare function buildAdjacency(links: Uint32Array, pointCount: number): Adjacen
  * `adj.neighbors` — do not mutate, and do not hold across a rebuild.
  */
 declare function neighborsOf(adj: Adjacency, index: number): Uint32Array;
+/**
+ * CSR INCIDENCE: point → incident EDGE SLOTS (F10-02). The plain Adjacency
+ * stores neighbor points, which cannot drive incident-edge dirtying — the
+ * §9.1 delta cascade needs the edge slots themselves. Same two counting
+ * passes and the same conventions: undirected (each edge listed under both
+ * endpoints), parallel edges repeat, and a self-loop lists its edge slot
+ * twice under its point — consumers' per-edge operations are idempotent, so
+ * the duplicate is harmless and cheaper than a dedupe pass.
+ */
+interface Incidence {
+    /** Length `pointCount + 1`; edges of point `i` live at
+     * `edgeSlots[offsets[i] … offsets[i + 1])`. */
+    readonly offsets: Uint32Array;
+    /** Length `links.length` (each edge appears once per endpoint slot). */
+    readonly edgeSlots: Uint32Array;
+}
 
 /**
  * §13/§15 CPU link-pick fallback: a uniform grid over ALL links in SPACE
@@ -2137,6 +2217,7 @@ declare function canonicalFilterKey(specOrExpr: unknown): string;
  * balanced increments/decrements whenever a clear()/release() leaves zero
  * held memberships.
  */
+
 /** Default muted alpha for dimmed entities (§9.1 'dim' mode). */
 declare const DIM_ALPHA_DEFAULT = 0.15;
 /**
@@ -2149,12 +2230,38 @@ interface MaskSource {
     readonly name: string;
     setNodeFailures(hideIdx: Iterable<number> | null, dimIdx?: Iterable<number> | null): void;
     setEdgeFailures(hideIdx: Iterable<number> | null, dimIdx?: Iterable<number> | null): void;
+    /**
+     * O(Δ) delta form of the HIDE lane (F10-02): adds/removes individual slots
+     * from this source's membership without replaying the full set. Freely
+     * composable with the replace form — a later setNodeFailures re-baselines.
+     * `crossings`, when supplied, receives the slots whose hide counter
+     * crossed zero DURING THIS CALL (callee-cleared first): the incremental
+     * cascade's input, which per-drain `pending` tracking cannot provide.
+     */
+    updateNodeFailures(addHide: ArrayLike<number> | null, removeHide: ArrayLike<number> | null, crossings?: MaskCrossings): void;
+    updateEdgeFailures(addHide: ArrayLike<number> | null, removeHide: ArrayLike<number> | null): void;
     /** Empties all four lane memberships (the source stays usable). */
     clear(): void;
     /** clear() + permanently retires the handle (further set/clear throws;
      * release() itself is idempotent). */
     release(): void;
 }
+/** Per-CALL zero-crossings reported by the delta ops (reused, callee-cleared). */
+interface MaskCrossings {
+    /** Slots whose hide counter went 0 → nonzero in this call. */
+    becameFailing: number[];
+    /** Slots whose hide counter went nonzero → 0 in this call. */
+    becameClear: number[];
+}
+/** §17 O(Δ) operation counters (see resetStats/stats on SoftMask). */
+interface MaskStats {
+    /** Slots visited by delta membership ops (add + remove attempts). */
+    slotsVisited: number;
+    /** Counter zero-crossings applied (both directions, all lanes). */
+    zeroCrossings: number;
+    /** Incident-edge visits performed by the delta cascade. */
+    cascadeEdgesVisited: number;
+}
 /**
  * One drain payload. The four index arrays are REUSED across drains — copy
  * before the next drainDirty() call if you need to keep them.
@@ -2187,6 +2294,8 @@ declare class SoftMask {
     private overflowedFlag;
     /** Total memberships currently held across all sources and lanes. */
     private totalHeld;
+    /** §17 O(Δ) op counters (F10-02 gate instrumentation). */
+    private readonly statsBox;
     constructor(nodeCapacity: number, edgeCapacity: number);
     get nodeCapacity(): number;
     get edgeCapacity(): number;
@@ -2217,12 +2326,29 @@ declare class SoftMask {
      * endpoint (their previous cascade contribution, if any, is removed).
      */
     applyNodeCascadeToEdges(links: Uint32Array): void;
+    /**
+     * O(incident-edges) delta form of the §9.1 cascade (F10-02): for each node
+     * whose HIDE visibility crossed zero, recompute only its incident edges'
+     * cascade state from the CURRENT node counters and apply the delta through
+     * the same internal cascade source the full form uses — the two compose
+     * freely (the full form re-baselines). Edges shared by two crossed nodes
+     * are visited twice; the membership delta is idempotent, so the second
+     * visit is an O(1) no-op. `incidence` must describe the SAME `links`
+     * buffer (edge slot i ↔ links[2i]/[2i+1]).
+     */
+    applyNodeCascadeToEdgesDelta(links: Uint32Array, incidence: Incidence, crossedNodes: readonly number[]): void;
     /**
      * Drains the zero-crossing dirty lists accumulated since the previous
      * drain. Only NET flips are emitted (state compared against the previous
      * drain). The returned index arrays are reused by the next drain.
      */
     drainDirty(): MaskDrain;
+    /** §17 telemetry: estimated bytes of mask storage held (S13-T07):
+     * four counter lanes (+pending trackers) and per-source flag columns. */
+    estimatedBytes(): number;
+    /** §17 O(Δ) op counters (live object — snapshot before comparing). */
+    get stats(): Readonly<MaskStats>;
+    resetStats(): void;
     visibleNodeCount(): number;
     visibleEdgeCount(): number;
     /** Visible iff hideFailures === 0 (out-of-range slots read not-visible). */
@@ -2241,6 +2367,14 @@ declare class SoftMask {
      * membership partially applied; duplicates within `incoming` count once.
      */
     private applyMembership;
+    /**
+     * O(Δ) delta ops on one lane membership (F10-02). Adds and removes are
+     * idempotent per slot (adding a member / removing a non-member is a
+     * no-op); removed slots leave HOLES in `list` (compacted past 50%), so
+     * replace/clear passes must honor the bit0 guard above. `crossings`, when
+     * given, is cleared and then receives this CALL's hide zero-crossings.
+     */
+    private applyMembershipDelta;
     private increment;
     private decrement;
     /** Records the first zero-crossing of a slot per drain period, remembering
@@ -2324,10 +2458,16 @@ interface CrossfilterStats {
     fullSorts: number;
     /** Permutation merges performed by appendRows. */
     permutationMerges: number;
+    /** Incremental filtered-layer bin adjustments (F10-02: O(Δ·D)). */
+    binUpdates: number;
+    /** Full O(rows) filtered-layer recomputes (materialization/oracle only). */
+    filteredRecomputes: number;
 }
 declare class TypedColumnCrossfilter<N = Record<string, unknown>> {
     /** Test instrumentation; see CrossfilterStats. Reset with resetStats(). */
     readonly stats: CrossfilterStats;
+    /** Count of dims whose filtered layer is live-maintained (F10-02). */
+    private liveDims;
     private dims;
     private byKey;
     private specs;
@@ -2344,6 +2484,12 @@ declare class TypedColumnCrossfilter<N = Record<string, unknown>> {
     /** Monotonic from 0; advances exactly once per observable setBrush change. */
     get selectionRevision(): number;
     resetStats(): void;
+    /** §17 telemetry: estimated bytes of typed-column storage held (S13-T07).
+     * Documented components: per-dim value/permutation/bin/code/pass arrays,
+     * the global failure counter, and the external mask. */
+    estimatedBytes(): number;
+    /** F10-02 live-layer bookkeeping — the ONLY writer of `filteredLive`. */
+    private setFilteredLive;
     /**
      * (Re)initialize columns from scratch. Clears all brushes and the external
      * mask (use replaceAll to rebuild while preserving brushes by key). Does not
@@ -2404,6 +2550,22 @@ declare class TypedColumnCrossfilter<N = Record<string, unknown>> {
     private rebinRange;
     private binIndex;
     private flip;
+    /**
+     * F10-02 inline maintenance of LIVE filtered layers, dispatched from the
+     * one place that knows the failCount transition. `boundary` is the
+     * other-failures picture at the interesting side of the flip (after for
+     * shown, before for hidden):
+     *  - 0 → the slot crossed the FULLY-VISIBLE boundary: every other live
+     *    layer counts it (own layers ignore the own-dim brush, so the brushed
+     *    dim's layer is provably unchanged by its own flip);
+     *  - 1 → exactly one OTHER dim still fails the slot: only that dim's
+     *    what-if-I-cleared-mine layer flips;
+     *  - ≥2 → no layer can change.
+     * External-mask-excluded and hygiene-invalid slots contribute nothing
+     * either way and are skipped.
+     */
+    private maintainFiltered;
+    private adjustLayer;
     private walkSorted;
     private walkList;
     private applyRangeTransition;
@@ -2609,6 +2771,11 @@ interface EnginePolicy {
     readonly clusterForce: 'native' | 'inert';
     /** Channels eligible for ranged (partial) uploads; empty = full replaces. */
     readonly rangedChannels: ReadonlySet<EngineBufferChannel>;
+    /** §17 stop-at-rest: 'stops' when the engine declares idleFrames:'stops'.
+     * Observability only (telemetry/harness read it) — an idle-spinning engine
+     * is a documented state, never a degradation entry: nothing was
+     * host-REQUESTED, so there is nothing to warn about. */
+    readonly quiescence: 'stops' | 'free-running';
     /** Exactly one entry per REQUESTED-but-unsupported feature; requested and
      * supported — or simply never requested — contributes nothing. */
     readonly degradations: readonly EnginePolicyDegradation[];
@@ -2766,6 +2933,8 @@ declare class MetricStore<N = Record<string, unknown>> {
     /** Admitted async columns by metric name; NaN encodes null. */
     private readonly columns;
     private degreePasses;
+    /** §17 telemetry: estimated bytes of metric storage held (S13-T07). */
+    estimatedBytes(): number;
     /** Number of combined degree-family compute passes (test observability). */
     get degreeComputePasses(): number;
     /**
@@ -2992,4 +3161,195 @@ declare function escapeXml(text: string): string;
  */
 declare function renderSvg(scene: SvgScene, opts?: RenderSvgOptions): string;
 
-export { ATLAS_MAX_CONCURRENT_DEFAULT, ATLAS_MAX_ENTRIES_DEFAULT, ATLAS_MAX_RETRIES_DEFAULT, AcceptanceQueue, AcceptedEdge, AcceptedGraph, AccessibilityConfig, Accessor, type Adjacency, type AdmitColumnsOptions, type AdmitColumnsResult, type AdmitServiceResultArgs, BASE_PENDING_KEY, BRUSH_HISTORY_COALESCE_MS, BeginIngestOptions, type BrushDelta, BrushState, CATEGORICAL_PALETTE, type CategoricalScale, type CompiledFilter, type CreateGraphInstanceOptions, type CreateRequestContextArgs, CrossfilterSession, type CrossfilterStats, DEFAULT_BIN_COUNT, DIM_ALPHA_DEFAULT, DIVERGING_RANGE_DEFAULT, DimensionSpec, DimensionSummary, type DivergingScale, DomainPolicy, DomainStore, EDGE_PICK_TOLERANCE_PX, EdgeId, type EdgePickRoute, EdgePickingFacade, type EdgePickingFacadeOptions, type EnginePolicy, type EnginePolicyDegradation, type ExpandNodeResult, type ExpansionOverlayRecord, ExpansionService, type FetchLike, type FilterErrorAggregate, FilterExpr, FilterSpec, GRAPH_THEME_DARK, GRAPH_THEME_LIGHT, GraphDiagnostic, GraphEventMap, GraphEventName, GraphHostUpdate, type GraphInstance, GraphListenerControl, GraphNode, type GraphServices, GraphSnapshot, GraphStoreState, GraphTheme, type GraphViewState, type GroupByDerivation, GroupBySpec, type GroupRewrite, GroupSpec, type GroupValidationResult, HISTORY_LIMIT_DEFAULT, type HistoryCommand, type HistoryDepths, HistoryKernel, type HistoryKernelOptions, INGEST_MAX_FLUSH_LATENCY_MS_DEFAULT, INGEST_MAX_PENDING_BYTES_DEFAULT, INGEST_OVERFLOW_FACTOR, type ImageAtlasBatch, ImageAtlasPipeline, type ImageAtlasPipelineOptions, type ImageDecode, type ImageResolver, IngestBatch, IngestSession, JsonValue, LABEL_MAX_VISIBLE_CAP, LABEL_MAX_VISIBLE_DEFAULT, type LabelCandidate, type LabelCandidateResult, type LabelCandidateViewport, LabelConfig, LabelPlacement, type LabelSubscriptions, type LinkPickGridSnapshot, LinkPickIndex, type LinkVisibilityMask, type LocalExpansionBase, type LocalSearchBase, type LocalSearchService, META_EDGE_MAX_WIDTH, type MaskDrain, type MaskSource, type MergeBase, type MergeResult, MetaEdge, type MetaEdgeRecord, MetricColumn, type MetricModelInput, MetricName, MetricStore, NodeId, OVERVIEW_HOT_INTERVAL_MS, OVERVIEW_IDLE_INTERVAL_MS, OVERVIEW_SIZE_DEFAULT, type OverviewBounds, OverviewController, type OverviewControllerOptions, type OverviewRaster, type OverviewScene, PHYSICAL_DEFAULT_LINK_WIDTH, PHYSICAL_DEFAULT_POINT_SIZE, PathOptions, PathResult, PathService, PendingExpansions, type ReconcileResult, Reconciler, type RegisterExpansionResult, RenderScene, type RenderSvgOptions, RequestContext, type RequestContextHandle, type RequestedEngineFeatures, type ResolveDomainArgs, ResolvedCluster, ResolvedGroup, type ResolvedScope, RevisionAwareService, RevisionDimension, type RevisionSnapshot, Revisions, type RowTally, SEARCH_CACHE_LIMIT, SEARCH_LIMIT_DEFAULT, SEARCH_SCAN_CHUNK, SEARCH_SCORE_EXACT_ID, SEARCH_SCORE_ID_PREFIX, SEARCH_SCORE_SUBSTRING, SEARCH_SCORE_TOKEN_START_BONUS, SEQUENTIAL_RANGE_DEFAULT, SUPER_NODE_MAX_SIZE, SVG_MAX_ELEMENTS_DEFAULT, Scale, type ScaleChannelInfo, type ScaleInfoRow, SceneGroups, SceneLinkRef, ScenePointRef, SearchActivation, SearchResult, type SearchService, type SelectLabelCandidatesArgs, SelectionState, type SequentialScale, type SerializableScale, type ServiceCacheKeyArgs, type SessionContribution, type SetViewStateResult, SoftMask, type StageResult, type StagingTallies, type StampedEdge, type StampedNode, SubgraphSpec, type SuperNodeRecord, SvgBudgetError, type SvgScene, type SvgSceneEdge, type SvgSceneLabel, type SvgSceneNode, TIMELINE_STEP_DEFAULT, TIMELINE_TICK_MS_DEFAULT, ThemeInput, TimelinePlayback, TypedColumnCrossfilter, VIEW_STATE_VERSION, type ViewBrushState, type ViewLayoutSpec, type ViewStateVerdict, type ViewStyling, ViewportState, admitServiceResult, assertCapabilityMethodParity, baseFromAccepted, baseFromContribution, buildAcceptedAdjacency, buildAdjacency, canonicalFilterKey, canonicalJson, canonicalScaleKey, cascadeEdges, categoricalIndex, categoricalRows, coerceNumeric, coerceNumericInto, collapseParallelEdges, compileEdgeFilter, compileNodeFilter, computeNumericDomain, createGraphInstance, createLocalExpansionService, createLocalSearchService, createRequestContext, deriveGroupsByKey, divergingColor, escapeXml, estimateBatchBytes, evaluateFilterExpr, groupByDerivedId, groupSceneKey, interpolateColor, medianLinkWidthPx, mergeDiagnostics, mergeModel, metaEdgePublicId, metaEdgeSceneKey, metaEdgeWidthFor, neighborsOf, newContribution, newStagingTallies, nextRequestId, normalizeCommitForCapabilities, parseColor, pointSegmentDistanceSquared, projectColors, projectSizes, renderSvg, resolveEnginePolicy, resolveFilterField, resolveManualGroups, resolveScope, resolveTheme, rewriteGroups, sameDataRef, sameGroupBySpec, sameGroupSpecArrays, sceneGroupsOf, sceneLinkRefAt, scenePointRefAt, selectLabelCandidates, sequentialColor, sequentialSize, serviceCacheKey, sessionCommitDiagnostics, stageBatch, superNodeSizeFor, validateFilterExpr, validateGroupBySpec, validateGroupSpecs, validateSnapshot, validateViewState };
+/**
+ * §5.1 columnar-NATIVE acceptance rules (PR-F wave 1, ADR-006) — the column
+ * -domain twin of validate.ts, built to run INSIDE the worker over typed
+ * columns without materializing a single row object.
+ *
+ * Semantics mirror the object lane EXACTLY (the equivalence oracle pins
+ * rosters AND diagnostics, message strings included):
+ *  - duplicate node ids drop, first occurrence wins ('duplicate-node-id',
+ *    warning) — and edges addressing a dropped duplicate ROW remap to the
+ *    surviving occurrence, because the object lane resolves endpoints by ID
+ *    STRING, which survives.
+ *  - duplicate edge ids drop, first wins ('duplicate-edge-id', warning).
+ *  - self-loops are RETAINED with 'self-loop-retained' (info).
+ *  - invalid-node / invalid-edge / dangling-edge cannot occur here: ids come
+ *    from a structurally validated dictionary column and endpoints are
+ *    in-bounds indices by prior validation (validateColumnarStructure).
+ *
+ * Duplicates hide in TWO encodings: two rows sharing a code, and two
+ * DISTINCT dictionary entries holding equal strings. Both are handled by
+ * canonicalizing the dictionary first (O(dictionary)), then scanning rows
+ * with an integer seen-set (O(rows)) — no per-row string work.
+ *
+ * Worker-safe by construction: pure over typed arrays; no DOM, no instance
+ * state, no Date/random.
+ */
+
+interface ColumnarAcceptance {
+    /** 1 = the ORIGINAL row survives into the accepted roster. */
+    keepNodes: Uint8Array;
+    keepEdges: Uint8Array;
+    acceptedNodeCount: number;
+    acceptedEdgeCount: number;
+    /** ORIGINAL node row → accepted index of its SURVIVING id (a dropped
+     * duplicate row points at the first occurrence's accepted index). */
+    nodeAcceptedIndex: Int32Array;
+    /** Resolved links (2 × acceptedEdgeCount), endpoints in ACCEPTED node
+     * indices, remapped through surviving occurrences. */
+    links: Uint32Array;
+    /** Batched, object-lane-identical diagnostics (codes, counts, capped
+     * samples, message strings). */
+    diagnostics: GraphDiagnostic[];
+}
+/**
+ * Run the acceptance rules over a STRUCTURALLY VALID columnar snapshot
+ * (validateColumnarStructure returned no issues — lengths and bounds are
+ * trusted here).
+ */
+declare function acceptColumnar(snapshot: ColumnarGraphSnapshot<unknown, unknown>): ColumnarAcceptance;
+
+/**
+ * §5 columnar snapshot lane (S13-T01, ADR-006) — structural validation and
+ * the materialization bridge.
+ *
+ * Validation is O(number of columns + rows) and runs BEFORE transfer or
+ * admission. Columnar structural corruption is intentionally not repaired
+ * row by row — offset/index misalignment can reinterpret every later row —
+ * so any structural issue rejects the WHOLE snapshot, the prior scene stays
+ * intact, and nothing throws from a React render (spec §5.1).
+ *
+ * The bridge materializes a VALID columnar snapshot into the object form and
+ * feeds the existing pipeline, so duplicate-id / dangling-edge / self-loop
+ * resolution stays in exactly one place (validate.ts) and the columnar lane
+ * inherits every object-lane rule by construction (ADR-006: T01 lands
+ * behind `execution: 'main'` with zero behavior change). The
+ * zero-materialization path arrives with the worker waves.
+ *
+ * Null semantics: `nulls` is one byte per row, nonzero = null. Null attr
+ * values materialize as `null` (JSON-ish; every numeric/temporal consumer
+ * already coerces). A null or out-of-range id CODE is structural corruption
+ * — ids are identity, not data.
+ */
+
+declare function isColumnarSnapshot<N, E>(input: GraphSnapshotInput<N, E>): input is ColumnarGraphSnapshot<N, E>;
+/** One structural defect. `where` is '<entity>.<column>' or '<entity>.<field>'. */
+interface ColumnarIssue {
+    where: string;
+    problem: 'not-a-string-column' | 'length-mismatch' | 'code-out-of-range' | 'null-id' | 'nulls-length-mismatch' | 'endpoint-out-of-range' | 'endpoint-length-mismatch' | 'bad-length' | 'bad-column-kind';
+    detail: string;
+}
+/**
+ * O(columns + rows) structural validation. Empty array ⇒ structurally sound
+ * (duplicate ids, self-loops, and parallel-edge rules are NOT checked here —
+ * they are shared object-lane semantics applied after materialization).
+ */
+declare function validateColumnarStructure(snapshot: ColumnarGraphSnapshot<unknown, unknown>): ColumnarIssue[];
+/**
+ * Materialize a STRUCTURALLY VALID columnar snapshot into the object form.
+ * Call only after `validateColumnarStructure` returned no issues — this
+ * function trusts lengths and bounds.
+ */
+declare function materializeColumnarSnapshot<N, E>(snapshot: ColumnarGraphSnapshot<N, E>): GraphSnapshot<N, E>;
+/**
+ * Build the AcceptedGraph DIRECTLY from clean columns + the acceptance
+ * verdicts (worker or main produced — same module either way): only kept
+ * rows materialize, `nodeIndex` falls out of the same pass, and
+ * `validateSnapshot`'s O(rows) object scan never runs. The verdicts are
+ * trusted — callers pass an acceptance produced from THIS snapshot.
+ */
+declare function buildAcceptedFromColumnar<N, E>(snapshot: ColumnarGraphSnapshot<N, E>, acceptance: Pick<ColumnarAcceptance, 'keepNodes' | 'keepEdges' | 'acceptedNodeCount' | 'acceptedEdgeCount' | 'diagnostics'>): AcceptedGraph<N, E>;
+/** Every distinct underlying ArrayBuffer reachable from the snapshot's typed
+ * arrays — the detach set for `bufferOwnership: 'transfer'` and the
+ * byteLength witness set for its tests. */
+declare function columnarArrayBuffers(snapshot: ColumnarGraphSnapshot<unknown, unknown>): ArrayBuffer[];
+/**
+ * `bufferOwnership: 'transfer'` — detach every underlying ArrayBuffer.
+ * Called ONLY after validation and admission both succeeded (ADR-006 D4:
+ * reject-before-allocation extends to reject-before-detach). Returns the
+ * number of buffers detached. SharedArrayBuffer-backed views are skipped
+ * (they cannot detach and remain shared by contract).
+ */
+declare function detachColumnarBuffers(snapshot: ColumnarGraphSnapshot<unknown, unknown>): number;
+
+/**
+ * §17 serializable field descriptors (S13-T01, ADR-006 D1) — the worker-lane
+ * accessor forms: `FieldAccessor` + `SerializableTransform` + the `field()`
+ * manual-schema helper. Descriptors are DATA, never code: they cross the
+ * worker boundary by structured clone, compare by canonical structural
+ * value, and unknown transform ops are validation errors (spec: "descriptors
+ * are never evaluated as code").
+ *
+ * This module ships the building blocks and their evaluation semantics; the
+ * styling-accessor unions widen to accept descriptor forms in the wave that
+ * makes projection consume them (accepting a form the projector ignores
+ * would be a silent no-op, worse than absence).
+ *
+ * Path semantics (v1, deliberately flat): a path addresses `attrs[path]`,
+ * with the FilterExpr convention that the literal `'id'` reads the entity
+ * id. No dot traversal — columnar snapshots are flat columns, and the
+ * prepared-data mapping validation rejects a missing column before
+ * projection ever runs.
+ */
+
+/** Branded attr path — `field<A,T>()` is a manual-schema ASSERTION (compile
+ * -time narrowing for codegen/schema packages), not runtime validation. */
+type TypedFieldPath<A, T> = string & {
+    readonly __attrs?: A;
+    readonly __value?: T;
+};
+declare function field<A, T>(path: string): TypedFieldPath<A, T>;
+/** §17 transform whitelist. Closed set — extending it is a spec amendment. */
+type SerializableTransform = {
+    op: 'identity';
+} | {
+    op: 'number';
+} | {
+    op: 'lowercase';
+} | {
+    op: 'date-to-epoch-ms';
+} | {
+    op: 'coalesce';
+    value: JsonValue;
+};
+interface FieldAccessor<A, T> {
+    field: TypedFieldPath<A, T>;
+    transform?: SerializableTransform;
+}
+/** Reasons a candidate failed `validateFieldAccessor` (typed, no throw). */
+type DescriptorIssue = {
+    kind: 'not-an-object';
+} | {
+    kind: 'field-not-a-string';
+} | {
+    kind: 'unknown-transform-op';
+    op: string;
+} | {
+    kind: 'transform-not-an-object';
+} | {
+    kind: 'coalesce-missing-value';
+};
+/**
+ * Structural guard: is this value SHAPED like a FieldAccessor? Deliberately
+ * strict about the transform whitelist (unknown ops are errors, not
+ * passthroughs) and deliberately loose about extra keys (forward-compatible
+ * clone targets). Functions are never descriptors.
+ */
+declare function validateFieldAccessor(value: unknown): DescriptorIssue | null;
+declare function isFieldAccessor(value: unknown): value is FieldAccessor<unknown, unknown>;
+/**
+ * Canonical structural fingerprint (spec: descriptors "compare by canonical
+ * structural value, invalidate only their dependent channel"). Stable across
+ * key order and object identity; usable as a channel-invalidation key on
+ * both sides of the worker boundary.
+ */
+declare function descriptorKey(accessor: FieldAccessor<unknown, unknown>): string;
+/**
+ * Evaluate a descriptor against an entity's `(id, attrs)` — the pure
+ * function both lanes share (ADR-006 D2: byte-exact parity starts with ONE
+ * evaluation implementation, imported by both threads, never duplicated).
+ */
+declare function evaluateFieldAccessor(accessor: FieldAccessor<unknown, unknown>, id: string, attrs: Readonly<Record<string, unknown>> | undefined): unknown;
+
+export { ATLAS_MAX_CONCURRENT_DEFAULT, ATLAS_MAX_ENTRIES_DEFAULT, ATLAS_MAX_RETRIES_DEFAULT, AcceptanceQueue, AcceptedEdge, AcceptedGraph, AccessibilityConfig, Accessor, type Adjacency, type AdmitColumnsOptions, type AdmitColumnsResult, type AdmitServiceResultArgs, BASE_PENDING_KEY, BRUSH_HISTORY_COALESCE_MS, BeginIngestOptions, type BrushDelta, BrushState, CATEGORICAL_PALETTE, type CategoricalScale, type ColumnarAcceptance, ColumnarGraphSnapshot, type ColumnarIssue, type CompiledFilter, type CreateGraphInstanceOptions, type CreateRequestContextArgs, CrossfilterSession, type CrossfilterStats, DEFAULT_BIN_COUNT, DIM_ALPHA_DEFAULT, DIVERGING_RANGE_DEFAULT, type DescriptorIssue, DimensionSpec, DimensionSummary, type DivergingScale, DomainPolicy, DomainStore, EDGE_PICK_TOLERANCE_PX, EdgeId, type EdgePickRoute, EdgePickingFacade, type EdgePickingFacadeOptions, EngineBufferChannel, type EnginePolicy, type EnginePolicyDegradation, type ExpandNodeResult, type ExpansionOverlayRecord, ExpansionService, type FetchLike, type FieldAccessor, type FilterErrorAggregate, FilterExpr, FilterSpec, GRAPH_THEME_DARK, GRAPH_THEME_LIGHT, GraphDiagnostic, GraphEventMap, GraphEventName, GraphHostUpdate, type GraphInstance, GraphListenerControl, GraphNode, GraphPerfSnapshot, type GraphServices, GraphSnapshot, GraphSnapshotInput, GraphStoreState, GraphTheme, type GraphViewState, type GroupByDerivation, GroupBySpec, type GroupRewrite, GroupSpec, type GroupValidationResult, HISTORY_LIMIT_DEFAULT, type HistoryCommand, type HistoryDepths, HistoryKernel, type HistoryKernelOptions, INGEST_MAX_FLUSH_LATENCY_MS_DEFAULT, INGEST_MAX_PENDING_BYTES_DEFAULT, INGEST_OVERFLOW_FACTOR, type ImageAtlasBatch, ImageAtlasPipeline, type ImageAtlasPipelineOptions, type ImageDecode, type ImageResolver, IngestBatch, IngestSession, JsonValue, LABEL_MAX_VISIBLE_CAP, LABEL_MAX_VISIBLE_DEFAULT, type LabelCandidate, type LabelCandidateResult, type LabelCandidateViewport, LabelConfig, LabelPlacement, type LabelSubscriptions, type LinkPickGridSnapshot, LinkPickIndex, type LinkVisibilityMask, type LocalExpansionBase, type LocalSearchBase, type LocalSearchService, META_EDGE_MAX_WIDTH, type MaskDrain, type MaskSource, type MergeBase, type MergeResult, MetaEdge, type MetaEdgeRecord, MetricColumn, type MetricModelInput, MetricName, MetricStore, NodeId, OVERVIEW_HOT_INTERVAL_MS, OVERVIEW_IDLE_INTERVAL_MS, OVERVIEW_SIZE_DEFAULT, type OverviewBounds, OverviewController, type OverviewControllerOptions, type OverviewRaster, type OverviewScene, PHYSICAL_DEFAULT_LINK_WIDTH, PHYSICAL_DEFAULT_POINT_SIZE, PathOptions, PathResult, PathService, PendingExpansions, type ReconcileResult, Reconciler, type RegisterExpansionResult, RenderScene, type RenderSvgOptions, RequestContext, type RequestContextHandle, type RequestedEngineFeatures, type ResolveDomainArgs, ResolvedCluster, ResolvedGroup, type ResolvedScope, RevisionAwareService, RevisionDimension, type RevisionSnapshot, Revisions, type RowTally, SEARCH_CACHE_LIMIT, SEARCH_LIMIT_DEFAULT, SEARCH_SCAN_CHUNK, SEARCH_SCORE_EXACT_ID, SEARCH_SCORE_ID_PREFIX, SEARCH_SCORE_SUBSTRING, SEARCH_SCORE_TOKEN_START_BONUS, SEQUENTIAL_RANGE_DEFAULT, SUPER_NODE_MAX_SIZE, SVG_MAX_ELEMENTS_DEFAULT, Scale, type ScaleChannelInfo, type ScaleInfoRow, ScaleLimits, SceneGroups, SceneLinkRef, ScenePointRef, SearchActivation, SearchResult, type SearchService, type SelectLabelCandidatesArgs, SelectionState, type SequentialScale, type SerializableScale, type SerializableTransform, type ServiceCacheKeyArgs, type SessionContribution, type SetViewStateResult, SoftMask, type StageResult, type StagingTallies, type StampedEdge, type StampedNode, SubgraphSpec, type SuperNodeRecord, SvgBudgetError, type SvgScene, type SvgSceneEdge, type SvgSceneLabel, type SvgSceneNode, TIMELINE_STEP_DEFAULT, TIMELINE_TICK_MS_DEFAULT, ThemeInput, TimelinePlayback, TypedColumnCrossfilter, type TypedFieldPath, VIEW_STATE_VERSION, type ViewBrushState, type ViewLayoutSpec, type ViewStateVerdict, type ViewStyling, ViewportState, WorkerFactoryOption, acceptColumnar, admitServiceResult, assertCapabilityMethodParity, baseFromAccepted, baseFromContribution, buildAcceptedAdjacency, buildAcceptedFromColumnar, buildAdjacency, canonicalFilterKey, canonicalJson, canonicalScaleKey, cascadeEdges, categoricalIndex, categoricalRows, coerceNumeric, coerceNumericInto, collapseParallelEdges, columnarArrayBuffers, compileEdgeFilter, compileNodeFilter, computeNumericDomain, createGraphInstance, createLocalExpansionService, createLocalSearchService, createRequestContext, deriveGroupsByKey, descriptorKey, detachColumnarBuffers, divergingColor, escapeXml, estimateBatchBytes, evaluateFieldAccessor, evaluateFilterExpr, field, groupByDerivedId, groupSceneKey, interpolateColor, isColumnarSnapshot, isFieldAccessor, materializeColumnarSnapshot, medianLinkWidthPx, mergeDiagnostics, mergeModel, metaEdgePublicId, metaEdgeSceneKey, metaEdgeWidthFor, neighborsOf, newContribution, newStagingTallies, nextRequestId, normalizeCommitForCapabilities, parseColor, pointSegmentDistanceSquared, projectColors, projectSizes, renderSvg, resolveEnginePolicy, resolveFilterField, resolveManualGroups, resolveScope, resolveTheme, rewriteGroups, sameDataRef, sameGroupBySpec, sameGroupSpecArrays, sceneGroupsOf, sceneLinkRefAt, scenePointRefAt, selectLabelCandidates, sequentialColor, sequentialSize, serviceCacheKey, sessionCommitDiagnostics, stageBatch, superNodeSizeFor, validateColumnarStructure, validateFieldAccessor, validateFilterExpr, validateGroupBySpec, validateGroupSpecs, validateSnapshot, validateViewState };