@apollohg/react-native-rich-text-editor 2.0.0

package/dist/NativeEditorBoundaryError.d.ts

@@ -0,0 +1,111 @@
+/** The boundary failure codes this package knows about at build time. */
+export declare const NATIVE_EDITOR_BOUNDARY_ERROR_CODES: readonly ["INVALID_RESOURCE_LIMIT", "CONFIG_INVALID", "INPUT_LIMIT_EXCEEDED", "CONFIG_PARSE_FAILED", "DOCUMENT_PARSE_FAILED", "DOCUMENT_INVALID", "DOCUMENT_LIMIT_EXCEEDED", "POSITION_LIMIT_EXCEEDED", "SCHEMA_INVALID", "REQUIRED_ATTRIBUTE_MISSING", "UNKNOWN_MARK", "MAX_LENGTH_EXCEEDED", "MUTATION_REJECTED", "COLLABORATION_DECODE_FAILED", "COLLABORATION_APPLY_FAILED", "SESSION_NOT_FOUND", "IMAGE_POLICY_INVALID", "IMAGE_REQUEST_TIMEOUT"];
+export type KnownNativeEditorBoundaryErrorCode = (typeof NATIVE_EDITOR_BOUNDARY_ERROR_CODES)[number];
+/** Known codes remain suggested while future native codes can cross the boundary losslessly. */
+export type NativeEditorBoundaryErrorCode = KnownNativeEditorBoundaryErrorCode | (string & {});
+/** The subsystems a typed error can come from. Each maps to its own error class. */
+export declare const NATIVE_EDITOR_ERROR_DOMAINS: readonly ["boundary", "document", "operation", "lifecycle", "snapshot", "transport"];
+/**
+ * Which subsystem raised a failure:
+ *
+ * - `boundary` — the value never reached the engine (bad config, oversized input).
+ * - `document` — the document or schema was rejected.
+ * - `operation` — a mutation could not be applied (stale revision, invalid position).
+ * - `lifecycle` — the session was destroyed or is being destroyed.
+ * - `snapshot` — a room snapshot could not be exported or restored.
+ * - `transport` — collaboration transport failure.
+ */
+export type NativeEditorErrorDomain = (typeof NATIVE_EDITOR_ERROR_DOMAINS)[number];
+/** Codes carried by `operation`-domain failures. */
+export declare const NATIVE_EDITOR_OPERATION_ERROR_CODES: readonly ["ENGINE_NOT_READY", "REVISION_MISMATCH", "POSITION_INVALID", "TRANSACTION_INVALID", "OPERATION_INVALID", "OPERATION_LIMIT_EXCEEDED", "OPERATION_RESOURCE_EXHAUSTED", "DOCUMENT_INVALID", "DOCUMENT_LIMIT_EXCEEDED", "ENGINE_INVARIANT_FAILED"];
+/**
+ * A failure record from the native boundary, normalized for JavaScript. It is
+ * carried on every {@link NativeEditorErrorBase}; the numeric fields stay
+ * decimal strings because they span the full Rust `u64` range.
+ */
+export interface NativeEditorError {
+    domain: NativeEditorErrorDomain;
+    code: NativeEditorBoundaryErrorCode;
+    message: string;
+    /** Identity of the request that failed. */
+    requestId: string | null;
+    /** Index of the failing operation within a multi-operation transaction. */
+    operationIndex: string | null;
+    /** The bound that was exceeded, for limit failures. */
+    limit: string | null;
+    /** The value that exceeded it. */
+    actual: string | null;
+    /** Code-specific context, e.g. `expectedRevision`/`actualRevision` for `REVISION_MISMATCH`. */
+    details: Record<string, unknown> | null;
+}
+/**
+ * A value rejected before it reached the engine — an out-of-range resource
+ * limit, an invalid image policy, an oversized input. Thrown synchronously by
+ * the validating helpers in this package.
+ */
+export declare class NativeEditorBoundaryError extends Error {
+    readonly code: NativeEditorBoundaryErrorCode;
+    readonly limit?: number | undefined;
+    readonly actual?: number | undefined;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(code: NativeEditorBoundaryErrorCode, message: string, limit?: number | undefined, actual?: number | undefined, details?: Record<string, unknown> | undefined);
+}
+/**
+ * Turn a raw native error envelope into a {@link NativeEditorBoundaryError},
+ * or null when the value is not one.
+ */
+export declare function parseNativeBoundaryError(value: unknown): NativeEditorBoundaryError | null;
+/** Normalize a raw FFI v2 error record without changing the legacy error parser contract. */
+export declare function normalizeNativeEditorV2Error(value: unknown): NativeEditorError | null;
+/** Codes that mark a failure as permanently non-retryable for this handle. */
+export declare const NATIVE_EDITOR_NON_RETRYABLE_CODES: readonly ["ENGINE_INVARIANT_FAILED", "ENGINE_DESTROYING", "ENGINE_DESTROYED"];
+export declare function isNativeEditorV2NonRetryableCode(code: string): boolean;
+/** Base class for every typed error raised from a normalized FFI v2 error record. */
+export declare class NativeEditorErrorBase extends Error {
+    readonly error: NativeEditorError;
+    readonly domain: NativeEditorErrorDomain;
+    readonly code: NativeEditorBoundaryErrorCode;
+    readonly requestId: string | null;
+    readonly operationIndex: string | null;
+    readonly limit: string | null;
+    readonly actual: string | null;
+    readonly details: Record<string, unknown> | null;
+    constructor(error: NativeEditorError, name: string);
+}
+/** A value the engine refused to admit. */
+export declare class NativeEditorEngineBoundaryError extends NativeEditorErrorBase {
+    constructor(error: NativeEditorError);
+}
+/** The document or schema was rejected. */
+export declare class NativeEditorDocumentError extends NativeEditorErrorBase {
+    constructor(error: NativeEditorError);
+}
+/**
+ * A mutation could not be applied. `REVISION_MISMATCH` is the routine one:
+ * the document moved on, so re-read it and retry against the fresh revision.
+ */
+export declare class NativeEditorOperationError extends NativeEditorErrorBase {
+    constructor(error: NativeEditorError);
+}
+/** The session is not in a state that permits this call. */
+export declare class NativeEditorLifecycleError extends NativeEditorErrorBase {
+    constructor(error: NativeEditorError);
+}
+/** A room snapshot could not be exported or restored. */
+export declare class NativeEditorSnapshotError extends NativeEditorErrorBase {
+    constructor(error: NativeEditorError);
+}
+/** The collaboration transport failed. */
+export declare class NativeEditorTransportError extends NativeEditorErrorBase {
+    constructor(error: NativeEditorError);
+}
+/**
+ * Distinct class for failures that can never succeed on retry for this
+ * handle: ENGINE_INVARIANT_FAILED and the lifecycle-destroyed states
+ * (ENGINE_DESTROYING / ENGINE_DESTROYED).
+ */
+export declare class NativeEditorNonRetryableError extends NativeEditorErrorBase {
+    constructor(error: NativeEditorError);
+}
+/** Map a normalized FFI v2 error record to its typed imperative exception. */
+export declare function nativeEditorV2ErrorToException(error: NativeEditorError): NativeEditorErrorBase;

package/dist/NativeEditorBoundaryError.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeEditorNonRetryableError = exports.NativeEditorTransportError = exports.NativeEditorSnapshotError = exports.NativeEditorLifecycleError = exports.NativeEditorOperationError = exports.NativeEditorDocumentError = exports.NativeEditorEngineBoundaryError = exports.NativeEditorErrorBase = exports.NATIVE_EDITOR_NON_RETRYABLE_CODES = exports.NativeEditorBoundaryError = exports.NATIVE_EDITOR_OPERATION_ERROR_CODES = exports.NATIVE_EDITOR_ERROR_DOMAINS = exports.NATIVE_EDITOR_BOUNDARY_ERROR_CODES = void 0;
+exports.parseNativeBoundaryError = parseNativeBoundaryError;
+exports.normalizeNativeEditorV2Error = normalizeNativeEditorV2Error;
+exports.isNativeEditorV2NonRetryableCode = isNativeEditorV2NonRetryableCode;
+exports.nativeEditorV2ErrorToException = nativeEditorV2ErrorToException;
+const NativeEditorV2Decimal_1 = require("./NativeEditorV2Decimal");
+/** The boundary failure codes this package knows about at build time. */
+exports.NATIVE_EDITOR_BOUNDARY_ERROR_CODES = [
+    'INVALID_RESOURCE_LIMIT',
+    'CONFIG_INVALID',
+    'INPUT_LIMIT_EXCEEDED',
+    'CONFIG_PARSE_FAILED',
+    'DOCUMENT_PARSE_FAILED',
+    'DOCUMENT_INVALID',
+    'DOCUMENT_LIMIT_EXCEEDED',
+    'POSITION_LIMIT_EXCEEDED',
+    'SCHEMA_INVALID',
+    'REQUIRED_ATTRIBUTE_MISSING',
+    'UNKNOWN_MARK',
+    'MAX_LENGTH_EXCEEDED',
+    'MUTATION_REJECTED',
+    'COLLABORATION_DECODE_FAILED',
+    'COLLABORATION_APPLY_FAILED',
+    'SESSION_NOT_FOUND',
+    'IMAGE_POLICY_INVALID',
+    'IMAGE_REQUEST_TIMEOUT',
+];
+/** The subsystems a typed error can come from. Each maps to its own error class. */
+exports.NATIVE_EDITOR_ERROR_DOMAINS = [
+    'boundary',
+    'document',
+    'operation',
+    'lifecycle',
+    'snapshot',
+    'transport',
+];
+/** Codes carried by `operation`-domain failures. */
+exports.NATIVE_EDITOR_OPERATION_ERROR_CODES = [
+    'ENGINE_NOT_READY',
+    'REVISION_MISMATCH',
+    'POSITION_INVALID',
+    'TRANSACTION_INVALID',
+    'OPERATION_INVALID',
+    'OPERATION_LIMIT_EXCEEDED',
+    'OPERATION_RESOURCE_EXHAUSTED',
+    'DOCUMENT_INVALID',
+    'DOCUMENT_LIMIT_EXCEEDED',
+    'ENGINE_INVARIANT_FAILED',
+];
+/**
+ * A value rejected before it reached the engine — an out-of-range resource
+ * limit, an invalid image policy, an oversized input. Thrown synchronously by
+ * the validating helpers in this package.
+ */
+class NativeEditorBoundaryError extends Error {
+    constructor(code, message, limit, actual, details) {
+        super(message);
+        this.code = code;
+        this.limit = limit;
+        this.actual = actual;
+        this.details = details;
+        this.name = 'NativeEditorBoundaryError';
+    }
+}
+exports.NativeEditorBoundaryError = NativeEditorBoundaryError;
+/**
+ * Turn a raw native error envelope into a {@link NativeEditorBoundaryError},
+ * or null when the value is not one.
+ */
+function parseNativeBoundaryError(value) {
+    const envelope = value;
+    const nativeError = envelope?.error;
+    const code = nativeError?.code;
+    if (typeof code !== 'string' || typeof nativeError?.message !== 'string') {
+        return null;
+    }
+    return new NativeEditorBoundaryError(code, nativeError.message, typeof nativeError.limit === 'number' ? nativeError.limit : undefined, typeof nativeError.actual === 'number' ? nativeError.actual : undefined, nativeError.details != null && typeof nativeError.details === 'object'
+        ? nativeError.details
+        : undefined);
+}
+function nullableCanonicalDecimal(value) {
+    if (value == null)
+        return null;
+    return (0, NativeEditorV2Decimal_1.normalizeNativeEditorV2U64)(value) ?? undefined;
+}
+function parseDetails(nativeError) {
+    if (nativeError.details != null) {
+        if (typeof nativeError.details !== 'object' || Array.isArray(nativeError.details)) {
+            return undefined;
+        }
+        return nativeError.details;
+    }
+    if (nativeError.detailsJson == null)
+        return null;
+    if (typeof nativeError.detailsJson !== 'string')
+        return undefined;
+    try {
+        const details = JSON.parse(nativeError.detailsJson);
+        return details != null && typeof details === 'object' && !Array.isArray(details)
+            ? details
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isCanonicalDecimalDetail(value) {
+    return (0, NativeEditorV2Decimal_1.normalizeNativeEditorV2U64)(value) != null;
+}
+/**
+ * Error details are otherwise forward-compatible, but known v2 structures
+ * carry u64 values and must not let JSON.parse silently admit rounded numbers.
+ */
+function hasValidKnownDetails(code, details) {
+    switch (code) {
+        case 'REVISION_MISMATCH':
+            return (details != null &&
+                isCanonicalDecimalDetail(details.expectedRevision) &&
+                isCanonicalDecimalDetail(details.actualRevision));
+        case 'TRANSPORT_STALE_GENERATION':
+            return (details != null &&
+                isCanonicalDecimalDetail(details.presentedGeneration) &&
+                (details.liveGeneration === null ||
+                    isCanonicalDecimalDetail(details.liveGeneration)));
+        default:
+            return true;
+    }
+}
+/** Normalize a raw FFI v2 error record without changing the legacy error parser contract. */
+function normalizeNativeEditorV2Error(value) {
+    const envelope = value;
+    const nativeError = envelope?.error;
+    if (nativeError == null || typeof nativeError !== 'object')
+        return null;
+    const { domain, code, message } = nativeError;
+    if (typeof domain !== 'string' ||
+        !exports.NATIVE_EDITOR_ERROR_DOMAINS.includes(domain) ||
+        typeof code !== 'string' ||
+        typeof message !== 'string') {
+        return null;
+    }
+    const requestId = nullableCanonicalDecimal(nativeError.requestId);
+    const operationIndex = nullableCanonicalDecimal(nativeError.operationIndex);
+    const limit = nullableCanonicalDecimal(nativeError.limit);
+    const actual = nullableCanonicalDecimal(nativeError.actual);
+    const details = parseDetails(nativeError);
+    if (requestId === undefined ||
+        operationIndex === undefined ||
+        limit === undefined ||
+        actual === undefined ||
+        details === undefined ||
+        !hasValidKnownDetails(code, details)) {
+        return null;
+    }
+    return {
+        domain: domain,
+        code,
+        message,
+        requestId,
+        operationIndex,
+        limit,
+        actual,
+        details,
+    };
+}
+// FFI v2 typed imperative error classes (additive; the legacy parsing path
+// above is unchanged). Recoverable engine errors throw the structured
+// per-domain class; ENGINE_INVARIANT_FAILED and lifecycle-destroyed states
+// throw the distinct non-retryable class.
+/** Codes that mark a failure as permanently non-retryable for this handle. */
+exports.NATIVE_EDITOR_NON_RETRYABLE_CODES = [
+    'ENGINE_INVARIANT_FAILED',
+    'ENGINE_DESTROYING',
+    'ENGINE_DESTROYED',
+];
+function isNativeEditorV2NonRetryableCode(code) {
+    return exports.NATIVE_EDITOR_NON_RETRYABLE_CODES.includes(code);
+}
+/** Base class for every typed error raised from a normalized FFI v2 error record. */
+class NativeEditorErrorBase extends Error {
+    constructor(error, name) {
+        super(error.message);
+        this.error = error;
+        this.name = name;
+        this.domain = error.domain;
+        this.code = error.code;
+        this.requestId = error.requestId;
+        this.operationIndex = error.operationIndex;
+        this.limit = error.limit;
+        this.actual = error.actual;
+        this.details = error.details;
+    }
+}
+exports.NativeEditorErrorBase = NativeEditorErrorBase;
+/** A value the engine refused to admit. */
+class NativeEditorEngineBoundaryError extends NativeEditorErrorBase {
+    constructor(error) {
+        super(error, 'NativeEditorEngineBoundaryError');
+    }
+}
+exports.NativeEditorEngineBoundaryError = NativeEditorEngineBoundaryError;
+/** The document or schema was rejected. */
+class NativeEditorDocumentError extends NativeEditorErrorBase {
+    constructor(error) {
+        super(error, 'NativeEditorDocumentError');
+    }
+}
+exports.NativeEditorDocumentError = NativeEditorDocumentError;
+/**
+ * A mutation could not be applied. `REVISION_MISMATCH` is the routine one:
+ * the document moved on, so re-read it and retry against the fresh revision.
+ */
+class NativeEditorOperationError extends NativeEditorErrorBase {
+    constructor(error) {
+        super(error, 'NativeEditorOperationError');
+    }
+}
+exports.NativeEditorOperationError = NativeEditorOperationError;
+/** The session is not in a state that permits this call. */
+class NativeEditorLifecycleError extends NativeEditorErrorBase {
+    constructor(error) {
+        super(error, 'NativeEditorLifecycleError');
+    }
+}
+exports.NativeEditorLifecycleError = NativeEditorLifecycleError;
+/** A room snapshot could not be exported or restored. */
+class NativeEditorSnapshotError extends NativeEditorErrorBase {
+    constructor(error) {
+        super(error, 'NativeEditorSnapshotError');
+    }
+}
+exports.NativeEditorSnapshotError = NativeEditorSnapshotError;
+/** The collaboration transport failed. */
+class NativeEditorTransportError extends NativeEditorErrorBase {
+    constructor(error) {
+        super(error, 'NativeEditorTransportError');
+    }
+}
+exports.NativeEditorTransportError = NativeEditorTransportError;
+/**
+ * Distinct class for failures that can never succeed on retry for this
+ * handle: ENGINE_INVARIANT_FAILED and the lifecycle-destroyed states
+ * (ENGINE_DESTROYING / ENGINE_DESTROYED).
+ */
+class NativeEditorNonRetryableError extends NativeEditorErrorBase {
+    constructor(error) {
+        super(error, 'NativeEditorNonRetryableError');
+    }
+}
+exports.NativeEditorNonRetryableError = NativeEditorNonRetryableError;
+const NATIVE_EDITOR_V2_DOMAIN_ERROR_CLASSES = {
+    boundary: NativeEditorEngineBoundaryError,
+    document: NativeEditorDocumentError,
+    operation: NativeEditorOperationError,
+    lifecycle: NativeEditorLifecycleError,
+    snapshot: NativeEditorSnapshotError,
+    transport: NativeEditorTransportError,
+};
+/** Map a normalized FFI v2 error record to its typed imperative exception. */
+function nativeEditorV2ErrorToException(error) {
+    if (isNativeEditorV2NonRetryableCode(error.code)) {
+        return new NativeEditorNonRetryableError(error);
+    }
+    const ErrorClass = NATIVE_EDITOR_V2_DOMAIN_ERROR_CLASSES[error.domain];
+    return new ErrorClass(error);
+}

package/dist/NativeEditorBridge.d.ts

@@ -0,0 +1,9 @@
+export { type Selection, type NativeEditorLocalAwarenessSelection, type NativeEditorLocalAwarenessIntent, type ListContext, type RenderMarkWithAttrs, type RenderMark, type RenderElement, type RenderBlocksPatch, type ActiveState, type HistoryState, type ReadonlyActiveState, type NativeEditorAtomicRenderSnapshot, type EditorUpdate, type ContentSnapshot, type DocumentJSON, type CollaborationPeer, type CommandBlockedReason, type CommandBlockedInfo, type NativeEditorHistoryMode, type NativeEditorSnapshotMetadata, type NativeEditorRoomSnapshot, type NativeEditorInitialization, type NativeEditorCreateConfig, type NativeEditorInputRequest, type NativeEditorCommandRequest, type NativeEditorLocalApiRequest, type NativeEditorOffsetKind, type NativeEditorPositionAffinity, type NativeEditorPositionEnvelope, type NativeEditorSelectionEnvelope, type NativeEditorSelectionRequest, type NativeEditorReplaceDocumentRequest, } from './NativeEditorTypes';
+export { _resetNativeModuleCache, type NativeEditorModule, type NativeEditorResult, } from './NativeEditorNativeModule';
+export { normalizeNativeEditorV2Result, parseNativeEditorV2JsonValue, normalizeNativeEditorV2Bytes, normalizeNativeEditorV2Unit, normalizeNativeEditorV2DecimalId, requireNativeEditorV2U32, type NativeEditorDocumentState, type NativeEditorTransportState, type NativeEditorRenderState, type NativeEditorDocumentOrigin, type NativeEditorState, normalizeNativeEditorV2StateValue, type NativeEditorMutationOutcome, normalizeNativeEditorV2MutationOutcomeValue, type NativeEditorCommitInfo, normalizeNativeEditorV2CommitValue, normalizeNativeEditorV2ChangedValue, normalizeNativeEditorV2HtmlValue, normalizeNativeEditorV2PeersValue, unwrapNativeEditorV2Result, } from './NativeEditorResultNormalization';
+export { validEditorMentionTheme } from './EditorMentionThemeValidation';
+export { normalizeNativeEditorV2RenderUpdateValue, normalizeNativeEditorV2DocumentJsonValue, normalizeNativeEditorV2ContentSnapshotValue, type NativeEditorSnapshotExport, normalizeNativeEditorV2SnapshotExportValue, normalizeNativeEditorV2CreateValue, } from './NativeEditorRenderNormalization';
+export { type NativeEditorPeerInfo, type NativeCollaborationProtocolFrame, type NativeCollaborationProtocolAdapterAction, type NativeCollaborationProtocolAdapterResult, type NativeCollaborationProtocolAdapterContext, type NativeCollaborationProtocolAdapter, type NativeCollaborationTransportConfig, type NativeCollaborationTransportDiagnostics, type NativeCollaborationTransportStateEvent, type NativeCollaborationTransportErrorEvent, type NativeCollaborationProtocolAdapterEvent, type NativeCollaborationTransportEvent, normalizeNativeCollaborationTransportEvent, } from './NativeEditorCollaborationTransport';
+export { createNativeEditorLocalAwarenessSelection } from './NativeEditorLocalAwareness';
+export { NativeEditorDocumentBridge } from './NativeEditorDocumentBridge';
+export { type NativeEditorDocumentHandle, _getNativeEditorDocumentHandleDescriptor, _assertNativeEditorDocumentHandle, createNativeEditorDocumentHandle, } from './NativeEditorDocumentHandle';

package/dist/NativeEditorBridge.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNativeEditorDocumentHandle = exports._assertNativeEditorDocumentHandle = exports._getNativeEditorDocumentHandleDescriptor = exports.NativeEditorDocumentBridge = exports.createNativeEditorLocalAwarenessSelection = exports.normalizeNativeCollaborationTransportEvent = exports.normalizeNativeEditorV2CreateValue = exports.normalizeNativeEditorV2SnapshotExportValue = exports.normalizeNativeEditorV2ContentSnapshotValue = exports.normalizeNativeEditorV2DocumentJsonValue = exports.normalizeNativeEditorV2RenderUpdateValue = exports.validEditorMentionTheme = exports.unwrapNativeEditorV2Result = exports.normalizeNativeEditorV2PeersValue = exports.normalizeNativeEditorV2HtmlValue = exports.normalizeNativeEditorV2ChangedValue = exports.normalizeNativeEditorV2CommitValue = exports.normalizeNativeEditorV2MutationOutcomeValue = exports.normalizeNativeEditorV2StateValue = exports.requireNativeEditorV2U32 = exports.normalizeNativeEditorV2DecimalId = exports.normalizeNativeEditorV2Unit = exports.normalizeNativeEditorV2Bytes = exports.parseNativeEditorV2JsonValue = exports.normalizeNativeEditorV2Result = exports._resetNativeModuleCache = void 0;
+var NativeEditorNativeModule_1 = require("./NativeEditorNativeModule");
+Object.defineProperty(exports, "_resetNativeModuleCache", { enumerable: true, get: function () { return NativeEditorNativeModule_1._resetNativeModuleCache; } });
+var NativeEditorResultNormalization_1 = require("./NativeEditorResultNormalization");
+Object.defineProperty(exports, "normalizeNativeEditorV2Result", { enumerable: true, get: function () { return NativeEditorResultNormalization_1.normalizeNativeEditorV2Result; } });
+Object.defineProperty(exports, "parseNativeEditorV2JsonValue", { enumerable: true, get: function () { return NativeEditorResultNormalization_1.parseNativeEditorV2JsonValue; } });
+Object.defineProperty(exports, "normalizeNativeEditorV2Bytes", { enumerable: true, get: function () { return NativeEditorResultNormalization_1.normalizeNativeEditorV2Bytes; } });
+Object.defineProperty(exports, "normalizeNativeEditorV2Unit", { enumerable: true, get: function () { return NativeEditorResultNormalization_1.normalizeNativeEditorV2Unit; } });
+Object.defineProperty(exports, "normalizeNativeEditorV2DecimalId", { enumerable: true, get: function () { return NativeEditorResultNormalization_1.normalizeNativeEditorV2DecimalId; } });
+Object.defineProperty(exports, "requireNativeEditorV2U32", { enumerable: true, get: function () { return NativeEditorResultNormalization_1.requireNativeEditorV2U32; } });
+Object.defineProperty(exports, "normalizeNativeEditorV2StateValue", { enumerable: true, get: function () { return NativeEditorResultNormalization_1.normalizeNativeEditorV2StateValue; } });
+Object.defineProperty(exports, "normalizeNativeEditorV2MutationOutcomeValue", { enumerable: true, get: function () { return NativeEditorResultNormalization_1.normalizeNativeEditorV2MutationOutcomeValue; } });
+Object.defineProperty(exports, "normalizeNativeEditorV2CommitValue", { enumerable: true, get: function () { return NativeEditorResultNormalization_1.normalizeNativeEditorV2CommitValue; } });
+Object.defineProperty(exports, "normalizeNativeEditorV2ChangedValue", { enumerable: true, get: function () { return NativeEditorResultNormalization_1.normalizeNativeEditorV2ChangedValue; } });
+Object.defineProperty(exports, "normalizeNativeEditorV2HtmlValue", { enumerable: true, get: function () { return NativeEditorResultNormalization_1.normalizeNativeEditorV2HtmlValue; } });
+Object.defineProperty(exports, "normalizeNativeEditorV2PeersValue", { enumerable: true, get: function () { return NativeEditorResultNormalization_1.normalizeNativeEditorV2PeersValue; } });
+Object.defineProperty(exports, "unwrapNativeEditorV2Result", { enumerable: true, get: function () { return NativeEditorResultNormalization_1.unwrapNativeEditorV2Result; } });
+var EditorMentionThemeValidation_1 = require("./EditorMentionThemeValidation");
+Object.defineProperty(exports, "validEditorMentionTheme", { enumerable: true, get: function () { return EditorMentionThemeValidation_1.validEditorMentionTheme; } });
+var NativeEditorRenderNormalization_1 = require("./NativeEditorRenderNormalization");
+Object.defineProperty(exports, "normalizeNativeEditorV2RenderUpdateValue", { enumerable: true, get: function () { return NativeEditorRenderNormalization_1.normalizeNativeEditorV2RenderUpdateValue; } });
+Object.defineProperty(exports, "normalizeNativeEditorV2DocumentJsonValue", { enumerable: true, get: function () { return NativeEditorRenderNormalization_1.normalizeNativeEditorV2DocumentJsonValue; } });
+Object.defineProperty(exports, "normalizeNativeEditorV2ContentSnapshotValue", { enumerable: true, get: function () { return NativeEditorRenderNormalization_1.normalizeNativeEditorV2ContentSnapshotValue; } });
+Object.defineProperty(exports, "normalizeNativeEditorV2SnapshotExportValue", { enumerable: true, get: function () { return NativeEditorRenderNormalization_1.normalizeNativeEditorV2SnapshotExportValue; } });
+Object.defineProperty(exports, "normalizeNativeEditorV2CreateValue", { enumerable: true, get: function () { return NativeEditorRenderNormalization_1.normalizeNativeEditorV2CreateValue; } });
+var NativeEditorCollaborationTransport_1 = require("./NativeEditorCollaborationTransport");
+Object.defineProperty(exports, "normalizeNativeCollaborationTransportEvent", { enumerable: true, get: function () { return NativeEditorCollaborationTransport_1.normalizeNativeCollaborationTransportEvent; } });
+var NativeEditorLocalAwareness_1 = require("./NativeEditorLocalAwareness");
+Object.defineProperty(exports, "createNativeEditorLocalAwarenessSelection", { enumerable: true, get: function () { return NativeEditorLocalAwareness_1.createNativeEditorLocalAwarenessSelection; } });
+var NativeEditorDocumentBridge_1 = require("./NativeEditorDocumentBridge");
+Object.defineProperty(exports, "NativeEditorDocumentBridge", { enumerable: true, get: function () { return NativeEditorDocumentBridge_1.NativeEditorDocumentBridge; } });
+var NativeEditorDocumentHandle_1 = require("./NativeEditorDocumentHandle");
+Object.defineProperty(exports, "_getNativeEditorDocumentHandleDescriptor", { enumerable: true, get: function () { return NativeEditorDocumentHandle_1._getNativeEditorDocumentHandleDescriptor; } });
+Object.defineProperty(exports, "_assertNativeEditorDocumentHandle", { enumerable: true, get: function () { return NativeEditorDocumentHandle_1._assertNativeEditorDocumentHandle; } });
+Object.defineProperty(exports, "createNativeEditorDocumentHandle", { enumerable: true, get: function () { return NativeEditorDocumentHandle_1.createNativeEditorDocumentHandle; } });

package/dist/NativeEditorCollaborationTransport.d.ts

@@ -0,0 +1,154 @@
+import { NativeEditorErrorBase } from './NativeEditorBoundaryError';
+import { type NativeEditorTransportState, type NativeEditorState } from './NativeEditorResultNormalization';
+/** One peer's awareness record, as Rust currently holds it. */
+export interface NativeEditorPeerInfo {
+    /** Yjs client identity, as a decimal string. */
+    clientId: string;
+    /** Awareness clock, advancing with each of this peer's updates. */
+    clock: number;
+    /** Whether this record describes this device. */
+    isLocal: boolean;
+    /** The peer's published application state, e.g. `{ user, focused }`. */
+    state: Record<string, unknown> | null;
+    /** The peer's caret in engine document positions, or null when it published none. */
+    cursor: {
+        anchor: number;
+        head: number;
+    } | null;
+}
+/** One WebSocket frame exchanged during the protocol adapter's prelude. */
+export type NativeCollaborationProtocolFrame = {
+    type: 'text';
+    data: string;
+} | {
+    type: 'binary';
+    data: Uint8Array;
+};
+/**
+ * What the transport does next after an adapter callback:
+ *
+ * - `continue` — stay in the prelude and await the next frame.
+ * - `ready` — the prelude succeeded; release Yjs traffic.
+ * - `reject` — abandon this attempt.
+ */
+export type NativeCollaborationProtocolAdapterAction = 'continue' | 'ready' | 'reject';
+/** An adapter callback's decision, plus any frames to send before it takes effect. */
+export interface NativeCollaborationProtocolAdapterResult {
+    action: NativeCollaborationProtocolAdapterAction;
+    /** Frames sent on the socket before the action applies. */
+    frames?: readonly NativeCollaborationProtocolFrame[];
+}
+/** Identifies the connection attempt an adapter callback is running for. */
+export interface NativeCollaborationProtocolAdapterContext {
+    /** Identity of this physical connection attempt. */
+    attemptId: string;
+    /** Transport generation, as a decimal string. Advances on each reconfiguration. */
+    generation: string;
+    /** Subprotocol the server selected, if any. */
+    negotiatedProtocol: string | null;
+}
+/**
+ * An RN-owned, attempt-scoped prelude for a native-owned WebSocket.
+ *
+ * Native blocks all Yjs traffic until `onMessage` returns `ready`. Callbacks
+ * run once per native event and can read fresh credentials on every physical
+ * reconnect. Their frames and return values are never persisted by native.
+ */
+export interface NativeCollaborationProtocolAdapter {
+    /** WebSocket subprotocols offered during the physical handshake, in preference order. */
+    protocols: readonly string[];
+    /** Maximum time native permits the adapter to keep a physical socket pending. */
+    timeoutMillis?: number;
+    /** Close codes that park the Rust transport instead of entering automatic retry. */
+    terminalCloseCodes?: readonly number[];
+    /** Runs once when the socket opens — send credentials here. */
+    onOpen(context: NativeCollaborationProtocolAdapterContext): NativeCollaborationProtocolAdapterResult | Promise<NativeCollaborationProtocolAdapterResult>;
+    /** Runs for each frame received before the prelude returns `ready`. */
+    onMessage(context: NativeCollaborationProtocolAdapterContext, frame: NativeCollaborationProtocolFrame): NativeCollaborationProtocolAdapterResult | Promise<NativeCollaborationProtocolAdapterResult>;
+}
+/** Where the native transport connects, and whether it should. */
+export interface NativeCollaborationTransportConfig {
+    /** WebSocket endpoint, `ws:` or `wss:`. Treat it as sensitive — it may carry credentials. */
+    url: string;
+    /** Whether to open the connection now. False configures the endpoint without connecting. */
+    connect: boolean;
+    /** Optional RN-owned prelude that gates the native Yjs transport. */
+    protocolAdapter?: NativeCollaborationProtocolAdapter;
+}
+/** Why the transport woke and what it did — diagnostic only; no contract depends on these. */
+export interface NativeCollaborationTransportDiagnostics {
+    /** What woke the transport, e.g. a received message or an elapsed timer. */
+    wakeReason: string;
+    transportState: NativeEditorTransportState;
+    /** Decimal-string deadline for the next scheduled wake, if one is pending. */
+    nextDeadlineMillis: string | null;
+    /** Whether this wake applied a remote commit. */
+    remoteCommitApplied: boolean;
+    /** Whether the peer list changed. */
+    peersChanged: boolean;
+    /** Whether the local awareness entry was republished. */
+    renewedLocal: boolean;
+    /** Peers dropped for having gone stale. */
+    expiredPeerCount: number;
+}
+/** The transport advanced: new engine state, peers, and diagnostics. */
+export interface NativeCollaborationTransportStateEvent {
+    editorId: string;
+    /** Monotonic decimal-string sequence across all events for this handle. */
+    eventSequence: string;
+    generation: string | null;
+    kind: 'state';
+    state: NativeEditorState;
+    peers: NativeEditorPeerInfo[];
+    diagnostics: NativeCollaborationTransportDiagnostics;
+}
+/** The transport failed. Retryable failures are followed by further state events. */
+export interface NativeCollaborationTransportErrorEvent {
+    editorId: string;
+    eventSequence: string;
+    generation: string | null;
+    kind: 'error';
+    error: NativeEditorErrorBase;
+}
+/** Native is asking the configured protocol adapter to handle a prelude step. */
+export interface NativeCollaborationProtocolAdapterEvent {
+    editorId: string;
+    eventSequence: string;
+    generation: string;
+    kind: 'protocolAdapter';
+    /** Identity of the physical connection attempt. */
+    attemptId: string;
+    /** Identity of this callback invocation; the reply must quote it. */
+    eventId: string;
+    negotiatedProtocol: string | null;
+    /** Which adapter callback this event corresponds to. */
+    phase: 'open' | 'message';
+    /** The received frame, present when `phase` is `'message'`. */
+    frame?: NativeCollaborationProtocolFrame;
+}
+/** Any event emitted to a `NativeEditorDocumentHandle` transport listener. */
+export type NativeCollaborationTransportEvent = NativeCollaborationTransportStateEvent | NativeCollaborationTransportErrorEvent | NativeCollaborationProtocolAdapterEvent;
+export interface NativeCollaborationProtocolAdapterDescriptor {
+    protocols: string[];
+    timeoutMillis?: number;
+    terminalCloseCodes?: number[];
+}
+export interface NativeCollaborationTransportWireConfig {
+    url: string;
+    connect: boolean;
+    protocolAdapter?: NativeCollaborationProtocolAdapterDescriptor;
+}
+export declare const COLLABORATION_PROTOCOL_TOKEN: RegExp;
+export declare const MAX_COLLABORATION_PROTOCOLS = 16;
+export declare const MAX_COLLABORATION_PROTOCOL_BYTES = 128;
+export declare const MAX_COLLABORATION_ADAPTER_TIMEOUT_MILLIS = 60000;
+export declare const MAX_COLLABORATION_ADAPTER_FRAMES = 16;
+export declare const MAX_COLLABORATION_ADAPTER_FRAME_BYTES: number;
+export declare function collaborationProtocolAdapterDescriptor(value: NativeCollaborationProtocolAdapter): NativeCollaborationProtocolAdapterDescriptor;
+export declare function collaborationTransportWireConfig(config: NativeCollaborationTransportConfig): NativeCollaborationTransportWireConfig;
+export declare function serializeCollaborationProtocolAdapterResult(value: NativeCollaborationProtocolAdapterResult): string;
+export declare function normalizeNativeCollaborationTransportDiagnostics(value: unknown): NativeCollaborationTransportDiagnostics | null;
+export declare const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+export declare function encodeNativeCollaborationProtocolBytes(bytes: Uint8Array): string;
+export declare function decodeNativeCollaborationProtocolBytes(value: string): Uint8Array | null;
+export declare function normalizeNativeCollaborationTransportEvent(value: unknown): NativeCollaborationTransportEvent | null;