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

package/realtime/honua-server.js

@@ -88,9 +88,32 @@ export function decodeHonuaServerRealtimeEvent(payload) {
         throw new HonuaRealtimeResumeError("invalid-event", "honua-server streaming payload must be a JSON object.");
     }
     const envelope = payload;
-    // Status / heartbeat / error envelopes already use the SDK vocabulary.
-    if (typeof envelope.type === "string" && envelope.type !== "change" && envelope.type !== "feature-change") {
-        return decodeRealtimeServerSentEvent(payload);
+    // A current-server change discriminator always wins over generic `type`.
+    // Otherwise a malformed/colliding payload could masquerade as status or
+    // error and bypass the stricter operation/after-image validation below.
+    const currentServerChange = envelope.operation !== undefined;
+    // Snapshot / status / heartbeat / error envelopes already use the SDK
+    // vocabulary. Their `cursor`, however, is honua-server's global event-store
+    // position: a JSON number on the batched `snapshot` baseline frame, where the
+    // SDK's resume gate requires the string form it checkpoints. Normalizing it
+    // here — the one place that already owns honua-server's wire dialect — keeps
+    // a batched baseline from failing closed as a checkpoint conflict.
+    if (!currentServerChange &&
+        typeof envelope.type === "string" &&
+        envelope.type !== "change" &&
+        envelope.type !== "feature-change") {
+        const framed = withNormalizedNumericCursor(payload);
+        if (envelope.type === "status" && (payload.status === "connected" || payload.status === "subscribed")) {
+            return decodeRealtimeServerSentEvent({ ...framed, status: "live" });
+        }
+        return decodeRealtimeServerSentEvent(framed);
+    }
+    const serviceId = optionalNonEmptyText(envelope.serviceId, "serviceId");
+    optionalNonEmptyText(envelope.sourceId, "sourceId");
+    const cursor = normalizeCursor(envelope.cursor);
+    const sequence = optionalSequence(envelope.sequence);
+    if (currentServerChange && serviceId === undefined) {
+        throw new HonuaRealtimeResumeError("invalid-event", "honua-server current feature-change envelope is missing serviceId.");
     }
     const changes = collectChanges(envelope);
     if (changes.length === 0) {
@@ -98,8 +121,8 @@ export function decodeHonuaServerRealtimeEvent(payload) {
     }
     const base = {
         eventId: envelope.eventId,
-        sequence: envelope.sequence,
-        cursor: envelope.cursor,
+        sequence,
+        cursor,
         watermark: envelope.watermark,
         timestamp: envelope.timestamp,
         deltaToken: envelope.deltaToken,
@@ -110,19 +133,18 @@ export function decodeHonuaServerRealtimeEvent(payload) {
         if (!isRecord(change)) {
             throw new HonuaRealtimeResumeError("invalid-event", "honua-server feature change must be an object.");
         }
-        if (change.featureId === undefined) {
-            throw new HonuaRealtimeResumeError("invalid-event", "honua-server feature change is missing featureId.");
-        }
-        if (change.op === "delete") {
-            deletes.push({ id: change.featureId, version: change.version, updatedAt: change.updatedAt });
+        const operation = featureChangeOperation(change.op);
+        const featureId = featureIdValue(change.featureId);
+        if (operation === "delete") {
+            deletes.push({ id: featureId, version: change.version, updatedAt: change.updatedAt });
             continue;
         }
         if (change.feature === undefined) {
-            throw new HonuaRealtimeResumeError("invalid-event", `honua-server ${change.op} change is missing feature payload.`);
+            throw new HonuaRealtimeResumeError("invalid-event", `honua-server ${operation} change is missing feature payload.`);
         }
         upserts.push({
-            id: change.featureId,
-            sourceId: envelope.serviceId,
+            id: featureId,
+            sourceId: serviceId,
             feature: change.feature,
             version: change.version,
             updatedAt: change.updatedAt,
@@ -132,7 +154,7 @@ export function decodeHonuaServerRealtimeEvent(payload) {
         type: "delta",
         ...base,
         ...(upserts.length ? { upserts } : {}),
-        ...(deletes.length ? { deletes: deletes.map((entry) => ({ ...entry, sourceId: envelope.serviceId })) } : {}),
+        ...(deletes.length ? { deletes: deletes.map((entry) => ({ ...entry, sourceId: serviceId })) } : {}),
     };
 }
 /**
@@ -173,6 +195,19 @@ function resolveStreamingUrl(baseUrl) {
     return `${trimTrailingSlashes(baseUrl)}${HONUA_SERVER_STREAMING_FEATURES_PATH}`;
 }
 function collectChanges(envelope) {
+    if (envelope.operation !== undefined) {
+        const operation = currentServerOperation(envelope.operation);
+        const featureId = envelope.featureId === "" || envelope.featureId === undefined ? envelope.objectId : envelope.featureId;
+        return [
+            {
+                op: operation,
+                featureId,
+                feature: operation === "delete" ? undefined : projectCurrentServerFeature(envelope, featureId),
+                version: envelope.version,
+                updatedAt: envelope.updatedAt ?? envelope.timestamp,
+            },
+        ];
+    }
     if (Array.isArray(envelope.changes))
         return envelope.changes;
     if (envelope.op !== undefined) {
@@ -188,6 +223,80 @@ function collectChanges(envelope) {
     }
     return [];
 }
+function projectCurrentServerFeature(envelope, featureId) {
+    if (!Object.hasOwn(envelope, "geometry") || envelope.geometry === undefined) {
+        throw new HonuaRealtimeResumeError("invalid-event", "honua-server insert/update change is missing a complete geometry after-image.");
+    }
+    if (!isAttributeRecord(envelope.attributes)) {
+        throw new HonuaRealtimeResumeError("invalid-event", "honua-server insert/update change is missing a complete attributes after-image.");
+    }
+    return {
+        type: "Feature",
+        ...(featureId === undefined ? {} : { id: featureId }),
+        geometry: envelope.geometry,
+        properties: envelope.attributes,
+    };
+}
+/**
+ * Render a numeric `cursor` in its string form, leaving every other payload
+ * untouched. A malformed numeric cursor is deliberately left as-is so the
+ * resume gate still reports it, rather than being converted into a decode
+ * failure that would hide which contract was actually violated.
+ */
+function withNormalizedNumericCursor(payload) {
+    const cursor = payload.cursor;
+    if (typeof cursor !== "number")
+        return payload;
+    if (!Number.isSafeInteger(cursor) || cursor < 0)
+        return payload;
+    return { ...payload, cursor: String(cursor) };
+}
+function normalizeCursor(cursor) {
+    if (cursor === undefined)
+        return undefined;
+    if (typeof cursor === "number") {
+        if (Number.isSafeInteger(cursor) && cursor >= 0)
+            return String(cursor);
+    }
+    else if (typeof cursor === "string" && cursor.length > 0) {
+        return cursor;
+    }
+    throw new HonuaRealtimeResumeError("invalid-event", "honua-server feature-change cursor must be a non-empty string or non-negative safe integer.");
+}
+function optionalSequence(sequence) {
+    if (sequence === undefined)
+        return undefined;
+    if (typeof sequence === "number" && Number.isSafeInteger(sequence) && sequence >= 0)
+        return sequence;
+    throw new HonuaRealtimeResumeError("invalid-event", "honua-server feature-change sequence must be a non-negative safe integer.");
+}
+function optionalNonEmptyText(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === "string" && value.length > 0)
+        return value;
+    throw new HonuaRealtimeResumeError("invalid-event", `honua-server feature-change ${field} must be a non-empty string.`);
+}
+function featureIdValue(value) {
+    if (typeof value === "string" && value.length > 0)
+        return value;
+    if (typeof value === "number" && Number.isSafeInteger(value))
+        return value;
+    throw new HonuaRealtimeResumeError("invalid-event", "honua-server feature change featureId must be a non-empty string or safe integer.");
+}
+function featureChangeOperation(value) {
+    if (value === "insert" || value === "update" || value === "delete" || value === "snapshot")
+        return value;
+    throw new HonuaRealtimeResumeError("invalid-event", "honua-server feature change operation must be insert, update, delete, or snapshot.");
+}
+function currentServerOperation(value) {
+    if (value === "insert" || value === "update" || value === "delete")
+        return value;
+    throw new HonuaRealtimeResumeError("invalid-event", "honua-server current feature-change operation must be insert, update, or delete.");
+}
+function isAttributeRecord(value) {
+    return isRecord(value) && !Array.isArray(value);
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }

package/realtime/index.d.ts

@@ -20,6 +20,8 @@ export { createRealtimeFeatureStore } from "./store.js";
 export type { RealtimeFeatureStore } from "./store.js";
 export { REALTIME_DURABLE_CHECKPOINT_VERSION, HonuaRealtimeResumeError, createResumableRealtimeSubscription, evaluateRealtimeCheckpoint, } from "./resumable.js";
 export type { CreateResumableRealtimeSubscriptionOptions, RealtimeCheckpointCompatibility, RealtimeCheckpointCompatibilityCode, RealtimeCheckpointStore, RealtimeDurableCheckpointV1, RealtimeExternalResnapshotReason, RealtimeResumeContextV1, RealtimeSequencedEvent, ResumableRealtimeDelivery, ResumableRealtimeDeliveryStatus, ResumableRealtimePhase, ResumableRealtimeReasonCode, ResumableRealtimeState, ResumableRealtimeSubscription, } from "./resumable.js";
+export { createIndexedDbCheckpointStorage, createIndexedDbRealtimeCheckpointStore, createMemoryCheckpointStorage, createMemoryRealtimeCheckpointStore, createRealtimeCheckpointStore, DEFAULT_REALTIME_CHECKPOINT_MAX_AGE_MS, DEFAULT_REALTIME_CHECKPOINT_MAX_RECORDS, HONUA_REALTIME_CHECKPOINT_STORE_FORMAT, MAX_REALTIME_CHECKPOINT_MAX_AGE_MS, MAX_REALTIME_CHECKPOINT_RECORDS, realtimeAuthorizationScopeDigest, realtimeCheckpointScopeKey, } from "./checkpoint-store.js";
+export type { IndexedDbRealtimeCheckpointStoreOptions, RealtimeCheckpointRecordStorage, RealtimeCheckpointRecordV1, RealtimeCheckpointStoreDiagnosticV1, RealtimeCheckpointStoreHandle, RealtimeCheckpointStoreOptions, RealtimeCheckpointStoreReason, RealtimeStoredResumePosition, } from "./checkpoint-store.js";
 export { assertRealtimePlanIdentity, deriveRealtimeContractAuthority, realtimePlanFingerprint, redactRealtimeCheckpoint, serializeRealtimeCheckpoint, serializeRedactedRealtimeCheckpoint, } from "./contract.js";
 export type { DeriveRealtimeContractAuthorityOptions, RealtimeContractAuthority, RealtimeContractAuthorityState, RedactedRealtimeCheckpointV1, RedactedRealtimeResumePosition, RedactedResumePosition, } from "./contract.js";
 export { createRealtimeWebSocketTransport } from "./websocket.js";
@@ -29,6 +31,8 @@ export type { OdataDeltaEntity, OdataDeltaInitialQuery, OdataDeltaPollTelemetry,
 export { computeReconnectDelayMs, createResumableRealtimeTransport, createResumableServerSentEventsTransport, createResumableWebSocketTransport, } from "./resumable-transport.js";
 export type { RealtimeReconnectPolicy, RealtimeResumableTransportOptions, RealtimeResumableTransportTelemetry, } from "./resumable-transport.js";
 export { filterRealtimeSelection, reconcileRealtimeSelection } from "./exploration.js";
+export { HonuaRealtimeReconciliationError, createRealtimeReconciledCache, createRealtimeReconciler, diffRealtimeFeatureState, realtimeReconciliationVersion, reconcileRealtimeKeyedState, reconcileRealtimeViewport, } from "./reconciliation.js";
+export type { RealtimeKeyedStateReconciliation, RealtimeReconciledCache, RealtimeReconciledCacheSnapshot, RealtimeReconciler, RealtimeReconcilerOptions, RealtimeReconciliationChange, RealtimeReconciliationChangeKind, RealtimeReconciliationDiff, RealtimeReconciliationErrorCode, RealtimeReconciliationInvalidation, RealtimeReconciliationInvalidationReason, RealtimeReconciliationMode, RealtimeReconciliationRebuildReason, RealtimeReconciliationResetReasonCode, RealtimeReconciliationResult, RealtimeReconciliationTrigger, RealtimeReconciliationVersion, RealtimeViewportReconciliation, } from "./reconciliation.js";
 export { selectRealtimeDetail, selectRealtimeFeatureRecordMap, selectRealtimeFeatureRecords, selectRealtimeFeatureTombstones, selectRealtimeFeatures, } from "./projections.js";
 export type { RealtimeDetailSelectorOptions, RealtimeDetailState, RealtimeFeatureRecordSelectorOptions, RealtimeFeatureReference, } from "./projections.js";
 export type { RealtimeConnectionStatus, RealtimeDeleteEvent, RealtimeDeletePatch, RealtimeDeltaEvent, RealtimeErrorEvent, RealtimeFeatureEvent, RealtimeFeatureEventBase, RealtimeFeatureObserver, RealtimeFeaturePatch, RealtimeFeatureRecord, RealtimeFeatureState, RealtimeFeatureTombstone, RealtimeFeatureTransport, RealtimeHeartbeatEvent, RealtimeReducerOptions, RealtimeResumeCheckpoint, RealtimeResumeMode, RealtimeSnapshotEvent, RealtimeStateListener, RealtimeStatusEvent, RealtimeStalenessOptions, RealtimeSubscriptionIdentity, RealtimeSubscriptionHandle, RealtimeSubscriptionMode, RealtimeSubscriptionRequest, RealtimeTransportCapabilities, RealtimeTransportKind, RealtimeUpsertEvent, } from "./types.js";

package/realtime/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/realtime/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/realtime/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EACL,uCAAuC,EACvC,6BAA6B,EAC7B,4BAA4B,GAC7B,MAAM,UAAU,CAAC;AAClB,YAAY,EACV,6BAA6B,EAC7B,oCAAoC,EACpC,wCAAwC,GACzC,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,qCAAqC,EACrC,8BAA8B,EAC9B,gCAAgC,EAChC,yBAAyB,EACzB,oCAAoC,GACrC,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,4CAA4C,EAC5C,wBAAwB,EACxB,gCAAgC,GACjC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,yBAAyB,EACzB,0BAA0B,EAC1B,0BAA0B,EAC1B,kBAAkB,EAClB,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AACxD,YAAY,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EACL,mCAAmC,EACnC,wBAAwB,EACxB,mCAAmC,EACnC,0BAA0B,GAC3B,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,0CAA0C,EAC1C,+BAA+B,EAC/B,mCAAmC,EACnC,uBAAuB,EACvB,2BAA2B,EAC3B,gCAAgC,EAChC,uBAAuB,EACvB,sBAAsB,EACtB,yBAAyB,EACzB,+BAA+B,EAC/B,sBAAsB,EACtB,2BAA2B,EAC3B,sBAAsB,EACtB,6BAA6B,GAC9B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,gCAAgC,EAChC,sCAAsC,EACtC,6BAA6B,EAC7B,mCAAmC,EACnC,6BAA6B,EAC7B,sCAAsC,EACtC,uCAAuC,EACvC,sCAAsC,EACtC,kCAAkC,EAClC,+BAA+B,EAC/B,gCAAgC,EAChC,0BAA0B,GAC3B,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,uCAAuC,EACvC,+BAA+B,EAC/B,0BAA0B,EAC1B,mCAAmC,EACnC,6BAA6B,EAC7B,8BAA8B,EAC9B,6BAA6B,EAC7B,4BAA4B,GAC7B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,0BAA0B,EAC1B,+BAA+B,EAC/B,uBAAuB,EACvB,wBAAwB,EACxB,2BAA2B,EAC3B,mCAAmC,GACpC,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,sCAAsC,EACtC,yBAAyB,EACzB,8BAA8B,EAC9B,4BAA4B,EAC5B,8BAA8B,EAC9B,sBAAsB,GACvB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,gCAAgC,EAAE,MAAM,gBAAgB,CAAC;AAClE,YAAY,EACV,iBAAiB,EACjB,2BAA2B,EAC3B,wBAAwB,EACxB,iCAAiC,GAClC,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,YAAY,EACV,gBAAgB,EAChB,sBAAsB,EACtB,uBAAuB,EACvB,0BAA0B,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,uBAAuB,EACvB,gCAAgC,EAChC,wCAAwC,EACxC,iCAAiC,GAClC,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACV,uBAAuB,EACvB,iCAAiC,EACjC,mCAAmC,GACpC,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,MAAM,kBAAkB,CAAC;AACvF,OAAO,EACL,gCAAgC,EAChC,6BAA6B,EAC7B,wBAAwB,EACxB,wBAAwB,EACxB,6BAA6B,EAC7B,2BAA2B,EAC3B,yBAAyB,GAC1B,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,gCAAgC,EAChC,uBAAuB,EACvB,+BAA+B,EAC/B,kBAAkB,EAClB,yBAAyB,EACzB,4BAA4B,EAC5B,gCAAgC,EAChC,0BAA0B,EAC1B,+BAA+B,EAC/B,kCAAkC,EAClC,wCAAwC,EACxC,0BAA0B,EAC1B,mCAAmC,EACnC,qCAAqC,EACrC,4BAA4B,EAC5B,6BAA6B,EAC7B,6BAA6B,EAC7B,8BAA8B,GAC/B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,oBAAoB,EACpB,8BAA8B,EAC9B,4BAA4B,EAC5B,+BAA+B,EAC/B,sBAAsB,GACvB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,6BAA6B,EAC7B,mBAAmB,EACnB,oCAAoC,EACpC,wBAAwB,GACzB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,wBAAwB,EACxB,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,wBAAwB,EACxB,wBAAwB,EACxB,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,kBAAkB,EAClB,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACnB,wBAAwB,EACxB,4BAA4B,EAC5B,0BAA0B,EAC1B,wBAAwB,EACxB,2BAA2B,EAC3B,6BAA6B,EAC7B,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,YAAY,CAAC"}

package/realtime/index.js

@@ -16,9 +16,11 @@ export { createHonuaServerRealtimeSubscription, decodeHonuaServerRealtimeEvent,
 export { emptyRealtimeFeatureState, reconcileRealtimeStaleness, reduceRealtimeFeatureState, realtimeFeatureKey, realtimeResumeCheckpoint, realtimeSubscriptionKey, } from "./reducer.js";
 export { createRealtimeFeatureStore } from "./store.js";
 export { REALTIME_DURABLE_CHECKPOINT_VERSION, HonuaRealtimeResumeError, createResumableRealtimeSubscription, evaluateRealtimeCheckpoint, } from "./resumable.js";
+export { createIndexedDbCheckpointStorage, createIndexedDbRealtimeCheckpointStore, createMemoryCheckpointStorage, createMemoryRealtimeCheckpointStore, createRealtimeCheckpointStore, DEFAULT_REALTIME_CHECKPOINT_MAX_AGE_MS, DEFAULT_REALTIME_CHECKPOINT_MAX_RECORDS, HONUA_REALTIME_CHECKPOINT_STORE_FORMAT, MAX_REALTIME_CHECKPOINT_MAX_AGE_MS, MAX_REALTIME_CHECKPOINT_RECORDS, realtimeAuthorizationScopeDigest, realtimeCheckpointScopeKey, } from "./checkpoint-store.js";
 export { assertRealtimePlanIdentity, deriveRealtimeContractAuthority, realtimePlanFingerprint, redactRealtimeCheckpoint, serializeRealtimeCheckpoint, serializeRedactedRealtimeCheckpoint, } from "./contract.js";
 export { createRealtimeWebSocketTransport } from "./websocket.js";
 export { createOdataDeltaTransport } from "./odata-delta.js";
 export { computeReconnectDelayMs, createResumableRealtimeTransport, createResumableServerSentEventsTransport, createResumableWebSocketTransport, } from "./resumable-transport.js";
 export { filterRealtimeSelection, reconcileRealtimeSelection } from "./exploration.js";
+export { HonuaRealtimeReconciliationError, createRealtimeReconciledCache, createRealtimeReconciler, diffRealtimeFeatureState, realtimeReconciliationVersion, reconcileRealtimeKeyedState, reconcileRealtimeViewport, } from "./reconciliation.js";
 export { selectRealtimeDetail, selectRealtimeFeatureRecordMap, selectRealtimeFeatureRecords, selectRealtimeFeatureTombstones, selectRealtimeFeatures, } from "./projections.js";

package/realtime/reconciliation.d.ts

@@ -0,0 +1,245 @@
+/**
+ * Renderer-neutral reconciliation of accepted realtime deltas (issue #559).
+ *
+ * `reducer.ts` already folds `snapshot`/`upsert`/`delete`/`delta` events into
+ * one authoritative `RealtimeFeatureState` (`records`/`tombstones`, keyed by
+ * {@link realtimeFeatureKey}) — that state is the accepted realtime store this
+ * module builds on. This module adds the piece #556/#557 deliberately left
+ * open: turning a `(previous, next, trigger)` state transition into an
+ * explicit, identity-stable **patch** (create/update/delete) or **rebuild**
+ * (replacement snapshot, schema change, or policy-driven queue overflow)
+ * decision, plus the derived-state reconciliation that keeps caches,
+ * selection, filters, and viewport deterministic across it:
+ *
+ * - {@link diffRealtimeFeatureState} — pure REQ-001 identity/patch-rebuild
+ *   classification for one event or explicit reset trigger.
+ * - {@link createRealtimeReconciler} — stateful REQ-004 policy: bounds the
+ *   pending-patch queue and switches `mode` to `"rebuild"` once a single
+ *   event or the accumulated queue crosses an explicit threshold, so a
+ *   renderer never has to apply an unbounded patch backlog.
+ * - {@link realtimeReconciliationVersion} — the resume-position fields a
+ *   derived cache should record so it can state exactly which cursor/sequence
+ *   it reflects (the accepted store in `store.ts`/`reducer.ts` remains the
+ *   sole authority; nothing here re-derives truth from a cache).
+ * - {@link createRealtimeReconciledCache} — a REQ-002 generic, renderer-neutral
+ *   feature cache driven by reconciliation results; adapt its snapshot into a
+ *   `Result<T>`-shaped or `HonuaQueryCache`-backed cache as needed.
+ * - {@link reconcileRealtimeKeyedState} / {@link reconcileRealtimeViewport} —
+ *   REQ-003 deterministic preservation of any identity-keyed UI state
+ *   (selection, an active client-side filter's matched-feature set) and of an
+ *   opaque viewport value, both with a structured invalidation reason instead
+ *   of a silent reset.
+ *
+ * `@honua/sdk-js/map`'s `realtime-reconciliation-adapter.ts` is the only
+ * place a `RealtimeReconciliationResult` is projected onto MapLibre
+ * (`setFeatureState` for `"patch"`, a caller-supplied rebuild callback for
+ * `"rebuild"`) — this module never imports `maplibre-gl` and has no
+ * renderer-specific dependency (REQ-005). deck.gl/Cesium adapters and the
+ * transport implementations that feed `previous`/`next` state are out of
+ * scope for #559.
+ *
+ * @module
+ */
+import type { FeatureId, SourceId } from "../contract/types.js";
+import { type HonuaErrorOptions, HonuaSdkError } from "../core/error-envelope.js";
+import type { RealtimeFeatureEvent, RealtimeFeatureRecord, RealtimeFeatureState, RealtimeFeatureTombstone } from "./types.js";
+/** Error codes raised by the reconciliation core (and, by reuse, its MapLibre adapter). @experimental */
+export type RealtimeReconciliationErrorCode = "disposed" | "invalid-option";
+/** A stable, machine-readable reconciliation failure. @experimental */
+export declare class HonuaRealtimeReconciliationError extends HonuaSdkError {
+    readonly code: RealtimeReconciliationErrorCode;
+    readonly detail?: Readonly<Record<string, unknown>> | undefined;
+    constructor(code: RealtimeReconciliationErrorCode, message: string, detail?: Readonly<Record<string, unknown>> | undefined, options?: HonuaErrorOptions);
+}
+/** Identity-level change classification. @experimental */
+export type RealtimeReconciliationChangeKind = "create" | "update" | "delete";
+/** One identity-stable change, keyed exactly like the accepted store ({@link realtimeFeatureKey}). @experimental */
+export interface RealtimeReconciliationChange<TFeature = unknown> {
+    readonly kind: RealtimeReconciliationChangeKind;
+    readonly key: string;
+    readonly id: FeatureId;
+    readonly sourceId?: SourceId;
+    /** Present for `"create"`/`"update"`; the accepted store's record (carries `cursor`/`sequence`/`receivedAt`). */
+    readonly record?: RealtimeFeatureRecord<TFeature>;
+    /** Present for `"delete"`; the accepted store's tombstone, when the reducer still retains it. */
+    readonly tombstone?: RealtimeFeatureTombstone;
+}
+/** Why a reconciliation declared a full reset instead of an incremental patch. @experimental */
+export type RealtimeReconciliationResetReasonCode = "replacement-snapshot" | "schema-changed" | "source-changed" | "authorization-scope-changed" | "manual";
+/**
+ * What drove one `(previous, next)` transition: an accepted `RealtimeFeatureEvent`
+ * (the common case — `snapshot`/`upsert`/`delete`/`delta`/`heartbeat`/`status`/`error`),
+ * or an explicit reset the caller derived from outside the event stream (a
+ * `schema-version-changed` / `source-version-changed` / `authorization-scope-changed`
+ * checkpoint incompatibility from `resumable.ts`'s `evaluateRealtimeCheckpoint`, or a
+ * caller-initiated manual reset). @experimental
+ */
+export type RealtimeReconciliationTrigger<TFeature = unknown> = {
+    readonly kind: "event";
+    readonly event: RealtimeFeatureEvent<TFeature>;
+} | {
+    readonly kind: "reset";
+    readonly reason: RealtimeReconciliationResetReasonCode;
+    readonly detail?: string;
+};
+/** Pure REQ-001 output: the identity changes for one transition, and whether it was a reset. @experimental */
+export interface RealtimeReconciliationDiff<TFeature = unknown> {
+    readonly changes: readonly RealtimeReconciliationChange<TFeature>[];
+    readonly reset: boolean;
+    readonly resetReason?: RealtimeReconciliationResetReasonCode;
+    readonly resetDetail?: string;
+}
+/**
+ * Classify one `(previous, next)` accepted-store transition into identity-stable
+ * create/update/delete changes, or an explicit reset (replacement snapshot,
+ * schema change, source-version change, authorization-scope change, or a
+ * caller-initiated manual reset). Pure and side-effect free — `next` must
+ * already be the reducer's output for `trigger` (`reduceRealtimeFeatureState`
+ * when `trigger.kind === "event"`); this function never re-derives store state.
+ *
+ * @experimental
+ */
+export declare function diffRealtimeFeatureState<TFeature>(previous: RealtimeFeatureState<TFeature>, next: RealtimeFeatureState<TFeature>, trigger: RealtimeReconciliationTrigger<TFeature>): RealtimeReconciliationDiff<TFeature>;
+/** The resume-position fields a derived cache should record alongside its data. @experimental */
+export interface RealtimeReconciliationVersion {
+    readonly cursor?: string;
+    readonly watermark?: string;
+    readonly timestamp?: string;
+    readonly sequence?: number;
+    readonly deltaToken?: string;
+}
+/** Project the accepted store's current resume position — what a derived cache built from `state` reflects. @experimental */
+export declare function realtimeReconciliationVersion<TFeature>(state: RealtimeFeatureState<TFeature>): RealtimeReconciliationVersion;
+/** `"patch"` applies `changes` incrementally; `"rebuild"` requires a full re-materialization. @experimental */
+export type RealtimeReconciliationMode = "patch" | "rebuild";
+/** Why {@link RealtimeReconciliationResult.mode} is `"rebuild"` even when `reset` is `false`. @experimental */
+export type RealtimeReconciliationRebuildReason = "reset" | "event-exceeds-patch-bound" | "queue-threshold-exceeded";
+/** Result of one {@link RealtimeReconciler.reconcile} call. @experimental */
+export interface RealtimeReconciliationResult<TFeature = unknown> {
+    readonly mode: RealtimeReconciliationMode;
+    readonly rebuildReason?: RealtimeReconciliationRebuildReason;
+    /**
+     * For `"patch"`, the transition's incremental changes. For `"rebuild"`,
+     * always the full accepted store as `"create"` changes (plus the triggering
+     * event's `"delete"` changes on a non-reset rebuild), so a derived cache can
+     * re-materialize wholesale from the result alone without dropping live
+     * features that were not part of the triggering event.
+     */
+    readonly changes: readonly RealtimeReconciliationChange<TFeature>[];
+    readonly version: RealtimeReconciliationVersion;
+    readonly reset: boolean;
+    readonly resetReason?: RealtimeReconciliationResetReasonCode;
+    /** Patches accumulated since the last rebuild, including this result. Always `0` immediately after a rebuild. @experimental */
+    readonly pendingPatchCount: number;
+}
+/** Options for {@link createRealtimeReconciler}. @experimental */
+export interface RealtimeReconcilerOptions {
+    /** A single event/trigger producing more identity changes than this forces an immediate rebuild. @default 500 */
+    readonly maxChangesPerEvent?: number;
+    /** Cumulative pending patches (since the last rebuild) that force the next reconciliation to rebuild. @default 2000 */
+    readonly rebuildThreshold?: number;
+}
+/** Stateful REQ-004 policy wrapper around {@link diffRealtimeFeatureState}. @experimental */
+export interface RealtimeReconciler<TFeature = unknown> {
+    readonly disposed: boolean;
+    /** Patches accumulated since the last rebuild. */
+    readonly pendingPatchCount: number;
+    /**
+     * Reconcile one accepted transition. Throws {@link HonuaRealtimeReconciliationError}
+     * (`"disposed"`) once {@link RealtimeReconciler.dispose} has been called —
+     * a disposed reconciler must never hand a caller another patch.
+     */
+    reconcile(previous: RealtimeFeatureState<TFeature>, next: RealtimeFeatureState<TFeature>, trigger: RealtimeReconciliationTrigger<TFeature>): RealtimeReconciliationResult<TFeature>;
+    /** Stop accepting reconciliations. Idempotent. */
+    dispose(): void;
+}
+/**
+ * Create a bounded, renderer-neutral reconciliation policy: identity changes
+ * classify through {@link diffRealtimeFeatureState}; a single oversized event,
+ * or an accumulated pending-patch count over `rebuildThreshold`, switches
+ * `mode` to `"rebuild"` by explicit policy rather than growing an unbounded
+ * patch queue.
+ *
+ * @experimental
+ */
+export declare function createRealtimeReconciler<TFeature = unknown>(options?: RealtimeReconcilerOptions): RealtimeReconciler<TFeature>;
+/** Snapshot returned by {@link RealtimeReconciledCache.snapshot} / `.apply`. @experimental */
+export interface RealtimeReconciledCacheSnapshot<TFeature = unknown> {
+    /** Insertion-ordered (creation order; unaffected by updates) live features. */
+    readonly features: readonly TFeature[];
+    /** The cursor/sequence this snapshot reflects — see {@link realtimeReconciliationVersion}. */
+    readonly version: RealtimeReconciliationVersion;
+}
+/** A renderer-neutral, identity-keyed feature cache kept in sync by reconciliation results. @experimental */
+export interface RealtimeReconciledCache<TFeature = unknown> {
+    readonly disposed: boolean;
+    snapshot(): RealtimeReconciledCacheSnapshot<TFeature>;
+    /**
+     * Apply one {@link RealtimeReconciliationResult}: `"rebuild"` replaces the
+     * cache wholesale (creates only — the caller's rebuild path already
+     * re-materializes from the authoritative store); `"patch"` applies each
+     * change in place. Throws {@link HonuaRealtimeReconciliationError}
+     * (`"disposed"`) once disposed.
+     */
+    apply(result: RealtimeReconciliationResult<TFeature>): RealtimeReconciledCacheSnapshot<TFeature>;
+    /** Discard cached data. Idempotent. */
+    dispose(): void;
+}
+/**
+ * Create a generic, renderer-neutral cache of live features keyed exactly
+ * like the accepted realtime store. Adapt {@link RealtimeReconciledCache.snapshot}
+ * into a `Result<T>`-shaped or `HonuaQueryCache`-backed cache entry as needed —
+ * this module intentionally does not import either.
+ *
+ * @experimental
+ */
+export declare function createRealtimeReconciledCache<TFeature = unknown>(): RealtimeReconciledCache<TFeature>;
+/** Why an identity-keyed entry (selection, active filter membership) was invalidated instead of preserved. @experimental */
+export type RealtimeReconciliationInvalidationReason = "feature-deleted" | "reset" | "schema-changed";
+/** One structured invalidation of a previously identity-keyed entry. @experimental */
+export interface RealtimeReconciliationInvalidation {
+    readonly key: string;
+    readonly reason: RealtimeReconciliationInvalidationReason;
+}
+/** Result of {@link reconcileRealtimeKeyedState}. @experimental */
+export interface RealtimeKeyedStateReconciliation {
+    readonly next: ReadonlySet<string>;
+    readonly invalidations: readonly RealtimeReconciliationInvalidation[];
+}
+/**
+ * Deterministically preserve or invalidate an identity-keyed set of feature
+ * keys (a selection, or the matched-key set of an active client-side filter)
+ * across one reconciliation result:
+ *
+ * - `result.reset` (replacement snapshot, schema/source/scope change, or
+ *   manual reset): every key is invalidated with reason `"reset"` (or
+ *   `"schema-changed"` when that was the reset reason) and `next` is empty —
+ *   a rebuild replaces identity wholesale, so no prior key is safe to assume
+ *   still exists.
+ * - Otherwise: a key backed by a feature the delta deleted is invalidated
+ *   with reason `"feature-deleted"`; every other key is preserved unchanged.
+ *
+ * Reused for both selection and filter membership — both are "a set of
+ * feature keys that must stay valid or be explicitly dropped."
+ *
+ * @experimental
+ */
+export declare function reconcileRealtimeKeyedState(keys: ReadonlySet<string>, result: Pick<RealtimeReconciliationResult<unknown>, "changes" | "reset" | "resetReason">): RealtimeKeyedStateReconciliation;
+/** Result of {@link reconcileRealtimeViewport}. @experimental */
+export interface RealtimeViewportReconciliation<TViewport> {
+    /** Always the input `viewport`; this module never mutates or resets camera state itself. */
+    readonly viewport: TViewport;
+    readonly invalidated: boolean;
+    readonly reason?: RealtimeReconciliationInvalidationReason;
+}
+/**
+ * Preserve an opaque viewport value across a reconciliation result. The
+ * viewport itself is always passed through unchanged (this module never
+ * moves a camera); `invalidated` is `true` only on `result.reset`, so a
+ * caller can decide whether to refit bounds — deterministic, and never a
+ * silent no-op on a schema/replacement-snapshot reset.
+ *
+ * @experimental
+ */
+export declare function reconcileRealtimeViewport<TViewport>(viewport: TViewport, result: Pick<RealtimeReconciliationResult<unknown>, "reset" | "resetReason">): RealtimeViewportReconciliation<TViewport>;
+//# sourceMappingURL=reconciliation.d.ts.map

package/realtime/reconciliation.d.ts.map

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