@derec-alliance/react-native 0.0.4 → 0.0.6

package/lib/types.d.ts

@@ -2,11 +2,12 @@ export interface SecretStore {
     load(secretId: string, channelId: string, kind: 0 | 1 | 2): Promise<Uint8Array | null | undefined>;
     /**
      * Load secrets of the same `kind` for several channels in one call,
-     * scoped to `secretId`. Must return an array with one entry per input
-     * id, in the same order, using `null` (or `undefined`) for channels
-     * with no stored secret of `kind`.
+     * scoped to `secretId`. Must return an array with exactly one entry per
+     * input id, in the same order, using `null` (or `undefined`) for channels
+     * with no stored secret of `kind`. Whether a missing entry is an error is
+     * decided by the library.
      */
-    loadMany(secretId: string, channelIds: string[], kind: 0 | 1 | 2, missingPolicy: "skip" | "fail"): Promise<Array<Uint8Array | null | undefined>>;
+    loadMany(secretId: string, channelIds: string[], kind: 0 | 1 | 2): Promise<Array<Uint8Array | null | undefined>>;
     save(secretId: string, channelId: string, kind: 0 | 1 | 2, value: Uint8Array): Promise<void>;
     remove(secretId: string, channelId: string, kind: 0 | 1 | 2): Promise<void>;
 }
@@ -78,19 +79,11 @@ export declare function channelFilterMatches(filter: HelperFilter | ReplicaFilte
 /**
  * The endpoints a peer-supplied message advertises, in the peer's own order.
  *
- * Yields `supported_transports` when it is non-empty, and otherwise the
- * singular `transport_protocol` — which is how every implementation predating
- * the offer list advertises, and the reason this is a function rather than a
- * field read. Reading `transport_protocol` directly is a bug: its meaning
- * narrowed to "one entry of a list, and possibly absent", so a peer that has
- * moved past it looks unreachable to a reader that was correct before 0.0.3.
- *
  * Reports what was advertised, not what is acceptable — nothing here is
  * validated, and the protocol still applies its own transport policy to
  * whatever it records.
  */
 export declare function advertisedEndpoints(message: {
-    transport_protocol?: TransportProtocol;
     supported_transports?: TransportProtocol[];
 } | null | undefined): TransportProtocol[];
 /**
@@ -172,7 +165,7 @@ export interface ChannelStore {
      * Order explicitly to make succession predictable.
      */
     listReplicas(secretId: string, filter: ReplicaFilter): Promise<Uint8Array | null | undefined>;
-    linkChannel(secretId: string, channelId: string, linkedChannelId: string): Promise<void>;
+    linkChannel(secretId: string, a: string, b: string): Promise<void>;
     linkedChannels(secretId: string, channelId: string): Promise<string[]>;
 }
 export interface Share {
@@ -180,6 +173,17 @@ export interface Share {
     version: number;
     bytes: Uint8Array;
 }
+/**
+ * Share-record persistence.
+ *
+ * Rows are keyed by `(secretId, channelId, version)` where `secretId` is
+ * the partition passed to every method. `Share.secretId` is a different
+ * value: it names the secret the bytes belong to, which on a helper is
+ * the owner's id and routinely differs from the partition this device
+ * stores under. Key on the argument and carry `share.secretId` alongside
+ * as data — keying on it instead puts rows where no `load` looks, since
+ * every read filters on the partition.
+ */
 export interface ShareStore {
     load(secretId: string, channelId: string, versions: number[]): Promise<Share[]>;
     loadMany(secretId: string, channelIds: string[], versions: number[]): Promise<Share[]>;
@@ -197,6 +201,10 @@ export interface UserSecrets {
     version: number;
     secrets: UserSecretEntry[];
     description?: string;
+    /** Decimal `replica_id` of the member that published `version`. Absent
+     *  when none is recorded. Store and return it unchanged: replica members
+     *  compare it to detect a conflicting copy of the same version. */
+    author_replica_id?: string;
 }
 /**
  * Persistence for the user-facing secret contents, keyed by `secretId`.
@@ -234,6 +242,16 @@ export interface StateStore {
     remove(secretId: string, keyJson: Uint8Array): Promise<boolean>;
     loadAll(secretId: string, kind: 0 | 1 | 2 | 3 | 4): Promise<Uint8Array[]>;
 }
+/** A transport protocol, by name. */
+export type TransportProtocolName = "https" | "grpc";
+/**
+ * One endpoint a node serves or a peer advertised, as every app-facing call
+ * and event carries it.
+ */
+export interface Endpoint {
+    uri: string;
+    protocol: TransportProtocolName;
+}
 /**
  * Outbound message delivery.
  *
@@ -278,10 +296,7 @@ export interface Transport {
      * provide — if that is genuinely wanted, say so with
      * {@link singleEndpointTransport} rather than by indexing.
      */
-    send(endpoints: ReadonlyArray<{
-        protocol: string;
-        uri: string;
-    }>, message: Uint8Array): Promise<void>;
+    send(endpoints: ReadonlyArray<Endpoint>, message: Uint8Array): Promise<void>;
 }
 /**
  * Delivers one message to one endpoint.
@@ -297,10 +312,22 @@ export interface Transport {
  * which is the safe reading. Trying an endpoint that would have refused costs
  * a round trip; skipping one that would have worked costs the delivery.
  */
-export type SendOne = (endpoint: {
-    protocol: string;
-    uri: string;
-}, message: Uint8Array) => Promise<void>;
+export type SendOne = (endpoint: Endpoint, message: Uint8Array) => Promise<void>;
+/**
+ * The DeRec protocol version this build speaks — the `protocolVersionMajor` /
+ * `protocolVersionMinor` it writes into every envelope it produces. Not the
+ * package version.
+ */
+export declare function protocol_version(): {
+    major: number;
+    minor: number;
+};
+/**
+ * A fresh, random replica id — never `0`. Generate it once per device,
+ * persist it, and pass the same value to
+ * `DeRecProtocolBuilder.withReplicaId` on every init.
+ */
+export declare function generate_replica_id(): bigint;
 /**
  * Builds a {@link Transport} that tries each endpoint in the order the peer
  * offered it and stops at the first success.
@@ -342,7 +369,7 @@ export declare enum SenderKind {
  *   the scanner must fetch the actual keys over the wire via the `PrePair`
  *   round-trip and verify them against the commitment before pairing.
  * - `NoKeys`: no key material and no commitment. The contact carries only
- *   `channel_id`, `nonce`, and `transport_protocol` — small enough to be
+ *   `channel_id`, `nonce`, and `supported_transports` — small enough to be
  *   hand-typed or dictated. Keys are generated on the fly by the contact
  *   creator when the `PrePairRequest` arrives; the scanner accepts them
  *   without cryptographic verification. Trust rests entirely on the OOB
@@ -382,19 +409,31 @@ export declare enum FlowKind {
      *  string so ids above 2^53 survive JS number handling. */
     UnpairReplica = 8
 }
+/** Result status carried in every protocol response (`result.proto`). Passed
+ *  to `reject()` to say why an inbound request was refused. */
+export declare enum StatusEnum {
+    Ok = 0,
+    Partial = 1,
+    Fail = 2,
+    SizeLimitExceeded = 3,
+    TooFrequent = 4,
+    UnknownSecretId = 5,
+    UnknownShareVersion = 6,
+    DecryptionFailed = 7,
+    VerificationFailed = 8,
+    FormatError = 9,
+    Rejected = 10,
+    IncompatibleParameterRange = 11,
+    UnsupportedTransportProtocol = 12,
+    VersionConflict = 13,
+    ReplicaIdConflict = 14,
+    RequestToClose = 99
+}
 export type UnpairAck = "required" | "not_required";
 export interface ContactMessage {
     channel_id: bigint;
     /** `ContactMode` numeric value (0 = INLINE_KEYS, 1 = HASHED_KEYS, 2 = NO_KEYS). */
     contact_mode: number;
-    /**
-     * @deprecated Reading this field directly is incorrect: its meaning narrowed
-     * to "one entry of a list, and possibly absent", so a peer advertising only
-     * `supported_transports` looks unreachable to a reader that was correct
-     * before 0.0.3. Call {@link advertisedEndpoints}, which resolves both
-     * spellings. Removed at 0.0.5.
-     */
-    transport_protocol?: TransportProtocol;
     nonce: bigint;
     /** Present only when `contact_mode === ContactMode.InlineKeys`. */
     mlkem_encapsulation_key?: Uint8Array;
@@ -404,8 +443,7 @@ export interface ContactMessage {
     contact_binding_hash?: Uint8Array;
     timestamp?: Timestamp;
     /** Every transport endpoint the creator of this contact can be reached
-     *  on, in its own preference order. Empty means "only
-     *  `transport_protocol` is offered". */
+     *  on, in its own preference order. */
     supported_transports: TransportProtocol[];
 }
 export interface UserSecret {
@@ -444,23 +482,11 @@ export interface UpdateChannelInfoParams {
     /** New communication-info map. `null`/absent leaves the peer's stored
      *  map untouched; pass an empty object to clear it. */
     communication_info?: Record<string, string>;
-    /**
-     * New transport endpoint. Absent leaves it untouched.
-     *
-     * @deprecated Use `own_transports`, which carries every endpoint this node
-     * now serves; its first entry also fills this field for peers predating the
-     * list. Removed at 0.0.5.
-     */
-    transport_protocol?: {
-        uri: string;
-        protocol: number;
-    };
     /**
      * Every endpoint this node now serves, in its own preference order.
-     * Omitted leaves the target(s)' stored set untouched. Takes precedence
-     * over `transport_protocol`, whose first entry it also fills.
+     * Omitted leaves the target(s)' stored set untouched.
      */
-    own_transports?: TransportProtocol[];
+    own_transports?: Endpoint[];
 }
 /**
  * How long the protocol waits on each thing that can keep it waiting. Every
@@ -513,11 +539,30 @@ export type DeRecEvent = {
     channel_id: string;
     action: Uint8Array;
     action_kind: PendingActionKind;
+    /** Correlation token of the inbound request, decimal-encoded. */
+    trace_id: string;
+    /** Pairing only. */
     peer_communication_info?: Record<string, string>;
+    /** `sender_kind` of the inbound pair request (Pairing only). */
     sender_kind?: SenderKind;
+    /** Share version (StoreShare / VerifyShare / GetShare). */
     version?: number;
+    /** Description of the secret version (StoreShare only). */
     share_description?: string;
+    /** Secret identifier, decimal-encoded (StoreShare / VerifyShare /
+     *  GetShare). On GetShare, with `version`, names the requested share. */
     share_secret_id?: string;
+    /** Length in bytes of the share the helper would store (StoreShare
+     *  only) — what a size or quota decision is made on. */
+    share_size?: number;
+    /** The peer's memo (Unpair only). */
+    unpair_memo?: string;
+    /** Communication info the peer replaces its stored map with
+     *  (UpdateChannelInfo only). Absent: unchanged. Empty: cleared. */
+    updated_communication_info?: Record<string, string>;
+    /** Endpoints the peer is moving to (UpdateChannelInfo only). Absent:
+     *  unchanged. */
+    updated_transports?: Endpoint[];
 } | {
     type: "ShareStored";
     channel_id: string;
@@ -530,7 +575,7 @@ export type DeRecEvent = {
     type: "ShareRejected";
     channel_id: string;
     version: number;
-    status: number;
+    status: StatusEnum;
     memo: string;
 }
 /** A publishing round finished — every targeted helper confirmed,
@@ -563,7 +608,7 @@ export type DeRecEvent = {
     replica_id: string;
     secret_id: string;
     version: number;
-    status: number;
+    status: StatusEnum;
     memo: string;
 }
 /** A secret sync could not be delivered to a member at all — distinct from
@@ -649,12 +694,9 @@ export type DeRecEvent = {
         helpers: Array<{
             channel_id: string;
             /** Every endpoint this peer advertised, in the order it offered them. */
-            transports: Array<{
-                uri: string;
-                protocol: number;
-            }>;
+            transports: Endpoint[];
             shared_key: Uint8Array;
-            communication_info: Record<string, string>;
+            communication_info?: Record<string, string>;
         }>;
         secrets: Array<{
             id: Uint8Array;
@@ -674,12 +716,9 @@ export type DeRecEvent = {
             members: Array<{
                 replica_id: string;
                 /** Every endpoint this peer advertised, in the order it offered them. */
-                transports: Array<{
-                    uri: string;
-                    protocol: number;
-                }>;
+                transports: Endpoint[];
                 role: "Source" | "Destination";
-                communication_info: Record<string, string>;
+                communication_info?: Record<string, string>;
             }>;
             shared_key: Uint8Array;
         };
@@ -690,7 +729,7 @@ export type DeRecEvent = {
 } | {
     type: "UnpairRejected";
     channel_id: string;
-    status: number;
+    status: StatusEnum;
     memo: string;
 }
 /** Contact creator answered the scanner's `PrePairRequest` with a
@@ -699,7 +738,7 @@ export type DeRecEvent = {
  | {
     type: "PrePairRejected";
     channel_id: string;
-    status: number;
+    status: StatusEnum;
     memo: string;
 }
 /** Fires alongside `PairingCompleted` on replica-mode pair handshakes.
@@ -718,25 +757,28 @@ export type DeRecEvent = {
 /** A `ReplicaSource` peer pushed a secret sync on a
  *  `ReplicaDestination` channel. The library decoded the
  *  `ReplicaSecretPayload`; the app installs `secret.secrets` and
- *  optionally uses `shares` for recovery. `from_replica_id` and the
- *  `replica_id` fields inside `secret` are `u64` as **decimal**
- *  strings. */
+ *  optionally uses `shares` for recovery. `from_replica_id`,
+ *  `author_replica_id` and the `replica_id` fields inside `secret` are
+ *  `u64` as **decimal** strings.
+ *
+ *  `from_replica_id` is the member this copy came from: the publisher on
+ *  a push, the serving member on a catch-up. `author_replica_id` is the
+ *  member that published `version`, or `null` when the serving member's
+ *  snapshot records none. */
  | {
     type: "ReplicaSecretReceived";
     channel_id: string;
     from_replica_id: string;
+    author_replica_id: string | null;
     secret_id: string;
     version: number;
     secret: {
         helpers: Array<{
             channel_id: string;
             /** Every endpoint this peer advertised, in the order it offered them. */
-            transports: Array<{
-                uri: string;
-                protocol: number;
-            }>;
+            transports: Endpoint[];
             shared_key: Uint8Array;
-            communication_info: Record<string, string>;
+            communication_info?: Record<string, string>;
         }>;
         secrets: Array<{
             id: Uint8Array;
@@ -754,12 +796,9 @@ export type DeRecEvent = {
             members: Array<{
                 replica_id: string;
                 /** Every endpoint this peer advertised, in the order it offered them. */
-                transports: Array<{
-                    uri: string;
-                    protocol: number;
-                }>;
+                transports: Endpoint[];
                 role: "Source" | "Destination";
-                communication_info: Record<string, string>;
+                communication_info?: Record<string, string>;
             }>;
             shared_key: Uint8Array;
         };
@@ -782,18 +821,16 @@ export type DeRecEvent = {
     type: "ReplicaSecretInstalled";
     channel_id: string;
     from_replica_id: string;
+    author_replica_id: string | null;
     secret_id: string;
     version: number;
     secret: {
         helpers: Array<{
             channel_id: string;
             /** Every endpoint this peer advertised, in the order it offered them. */
-            transports: Array<{
-                uri: string;
-                protocol: number;
-            }>;
+            transports: Endpoint[];
             shared_key: Uint8Array;
-            communication_info: Record<string, string>;
+            communication_info?: Record<string, string>;
         }>;
         secrets: Array<{
             id: Uint8Array;
@@ -811,12 +848,9 @@ export type DeRecEvent = {
             members: Array<{
                 replica_id: string;
                 /** Every endpoint this peer advertised, in the order it offered them. */
-                transports: Array<{
-                    uri: string;
-                    protocol: number;
-                }>;
+                transports: Endpoint[];
                 role: "Source" | "Destination";
-                communication_info: Record<string, string>;
+                communication_info?: Record<string, string>;
             }>;
             shared_key: Uint8Array;
         };
@@ -826,6 +860,56 @@ export type DeRecEvent = {
         committed_share: Uint8Array;
     }>;
 }
+/** A member offered a different copy of the version this device holds.
+ *  Nothing was written: this device keeps its own copy and refuses the
+ *  incoming one with `VERSION_CONFLICT`, so the publisher sees
+ *  `ReplicaSyncRejected`. Both copies are complete states — the held one
+ *  is in the local stores, the incoming one is `secret`. Resolve by
+ *  publishing the chosen state with `start(FlowKind.ProtectSecret)`; the
+ *  next version supersedes both on every member and helper.
+ *
+ *  `held_author_replica_id` / `incoming_author_replica_id` are the
+ *  decimal `replica_id` of each copy's publisher, or `null` when that
+ *  copy records none. */
+ | {
+    type: "ReplicaVersionConflict";
+    channel_id: string;
+    from_replica_id: string;
+    secret_id: string;
+    version: number;
+    held_author_replica_id: string | null;
+    incoming_author_replica_id: string | null;
+    secret: {
+        helpers: Array<{
+            channel_id: string;
+            /** Every endpoint this peer advertised, in the order it offered them. */
+            transports: Endpoint[];
+            shared_key: Uint8Array;
+            communication_info?: Record<string, string>;
+        }>;
+        secrets: Array<{
+            id: Uint8Array;
+            name: string;
+            data: Uint8Array;
+        }>;
+        /** The same shape as `SecretRecovered.secret.replicas`. */
+        replicas?: {
+            /** The one channel every member is addressed on. */
+            channel_id: string;
+            /** Every member of the group, including the writer. Exactly one
+             *  carries `role: "Source"` — that member is where the secret
+             *  originated, which is why no separate owner field is needed. */
+            members: Array<{
+                replica_id: string;
+                /** Every endpoint this peer advertised, in the order it offered them. */
+                transports: Endpoint[];
+                role: "Source" | "Destination";
+                communication_info?: Record<string, string>;
+            }>;
+            shared_key: Uint8Array;
+        };
+    };
+}
 /** Peer's ack of a secret sync we sent. `status` is the `StatusEnum`
  *  integer (0 = Ok), `memo` is the peer's explanation. */
  | {
@@ -834,7 +918,7 @@ export type DeRecEvent = {
     from_replica_id: string;
     secret_id: string;
     version: number;
-    status: number;
+    status: StatusEnum;
     memo: string;
 }
 /** A peer announced an updated `communication_info` map and/or
@@ -851,7 +935,7 @@ export type DeRecEvent = {
  | {
     type: "ChannelInfoUpdateRejected";
     channel_id: string;
-    status: number;
+    status: StatusEnum;
     memo: string;
 }
 /** Emitted by `process()` in place of `ActionRequired` when the
@@ -868,6 +952,38 @@ export type DeRecEvent = {
 } | {
     type: "NoOp";
 }
+/** An inbound message was dropped untouched: no store was written and
+ *  nothing was sent back. `reason` says why.
+ *
+ *  `"PendingVerification"` means the peer sent something before this
+ *  device confirmed the channel's fingerprint — typically a replica source
+ *  pushing its first copy while this destination still shows the code.
+ *  Confirming does not replay it: after `verifyFingerprint` succeeds, a
+ *  replica destination calls `start(FlowKind.ReplicaDiscovery)` to pull
+ *  the copy itself. `"Expired"` means the message was older than the
+ *  inbound timeout. `trace_id` matches the peer's `*Started` event for
+ *  the same round (`"0"` when the sender set none). */
+ | {
+    type: "MessageIgnored";
+    channel_id: string;
+    reason: IgnoreReason;
+    trace_id: string;
+}
+/** Returned by `restore`: a roster entry got no channel, so this device
+ *  cannot reach that peer. Every other entry and the user-secret snapshot
+ *  were restored; `reason` says why this one was not. `"NoTransports"`
+ *  means the recovered roster names no endpoint for it.
+ *
+ *  For a helper, `channel_id` is its channel and `replica_id` is absent.
+ *  For a replica group member, `channel_id` is the group's channel and
+ *  `replica_id` names the member. The peer itself is untouched — a helper
+ *  still holds its share — and pairing with it again makes it reachable. */
+ | {
+    type: "PeerNotRestored";
+    channel_id: string;
+    replica_id?: string;
+    reason: NotRestoredReason;
+}
 /** A pairing handshake was dispatched successfully. `kind` is the
  *  local party's role — same value the subsequent `PairingCompleted`
  *  will carry. Emitted by `start(Pairing)`. */
@@ -978,8 +1094,8 @@ export type DeRecEvent = {
  *   inbound shares. The protocol enforces no size, quota or rate limit
  *   of its own, and `maxShareSize` is checked for range overlap at
  *   pairing time only, never against an actual share. While this is
- *   `false`, `ActionRequired` carries the decoded request, so the
- *   application can inspect the share and call `reject()` with
+ *   `false`, `ActionRequired` carries `share_size`, so the application
+ *   can compare it to its quota and call `reject()` with
  *   `StatusEnum.SizeLimitExceeded`. Setting it `true` removes that
  *   opportunity entirely: every share from every paired Owner is stored
  *   unconditionally, at whatever size it arrives. Keep off in any
@@ -1055,6 +1171,12 @@ export interface CommunicationInfoKeyValue {
 export interface CommunicationInfo {
     communication_info_entries: CommunicationInfoKeyValue[];
 }
+/** Why a `MessageIgnored` event dropped a message. Matches the Rust
+ *  `IgnoreReason` discriminants one-for-one. */
+export type IgnoreReason = "PendingVerification" | "Expired";
+/** Why a `PeerNotRestored` event left a roster entry without a channel.
+ *  Matches the Rust `NotRestoredReason` discriminants one-for-one. */
+export type NotRestoredReason = "NoTransports";
 /**
  * The label vocabulary for `ActionRequired.action_kind` and
  * `AutoAccepted.action_kind` — one value per pending-action kind the
@@ -1081,17 +1203,9 @@ export interface PairRequestMessage {
     nonce: bigint;
     communication_info?: CommunicationInfo;
     parameter_range?: ParameterRange;
-    /**
-     * @deprecated Reading this field directly is incorrect: its meaning narrowed
-     * to "one entry of a list, and possibly absent", so a peer advertising only
-     * `supported_transports` looks unreachable to a reader that was correct
-     * before 0.0.3. Call {@link advertisedEndpoints}, which resolves both
-     * spellings. Removed at 0.0.5.
-     */
-    transport_protocol?: TransportProtocol;
     timestamp?: Timestamp;
     /** Every transport endpoint the initiator can be reached on, in its own
-     *  preference order. Empty means "only `transport_protocol` is offered". */
+     *  preference order. */
     supported_transports: TransportProtocol[];
 }
 export interface PairResponseMessage {
@@ -1111,21 +1225,12 @@ export interface PairResponseMessage {
 }
 export interface PrePairRequestMessage {
     nonce: bigint;
-    /**
-     * @deprecated Reading this field directly is incorrect: its meaning narrowed
-     * to "one entry of a list, and possibly absent", so a peer advertising only
-     * `supported_transports` looks unreachable to a reader that was correct
-     * before 0.0.3. Call {@link advertisedEndpoints}, which resolves both
-     * spellings. Removed at 0.0.5.
-     */
-    transport_protocol?: TransportProtocol;
     timestamp?: Timestamp;
     /**
      * Every endpoint the sender can be reached on for the PrePair reply, in
-     * its own preference order. At least one of this and `transport_protocol`
-     * must be present.
+     * its own preference order.
      */
-    supported_transports?: TransportProtocol[];
+    supported_transports: TransportProtocol[];
 }
 export interface PrePairResponseMessage {
     result?: DeRecResult;
@@ -1281,6 +1386,12 @@ export interface PairingProcessResult {
 export interface ProducePrePairResult {
     envelope: Uint8Array;
 }
+export interface ProducePrePairNoKeysResult {
+    envelope: Uint8Array;
+    /** Secret key material generated for this pairing. The caller MUST persist
+     * it: the `PairRequest` that follows is encrypted to it. */
+    secret_key_material: Uint8Array;
+}
 export interface PrePairRequestExtractResult {
     request: PrePairRequestMessage;
 }

package/lib/types.js

@@ -2,11 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright (c) 2026 DeRec Alliance. All rights reserved.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowKind = exports.ContactMode = exports.SenderKind = void 0;
+exports.StatusEnum = exports.FlowKind = exports.ContactMode = exports.SenderKind = void 0;
 exports.channelFilterMatches = channelFilterMatches;
 exports.advertisedEndpoints = advertisedEndpoints;
+exports.protocol_version = protocol_version;
+exports.generate_replica_id = generate_replica_id;
 exports.sequentialFailover = sequentialFailover;
 exports.singleEndpointTransport = singleEndpointTransport;
+const native_1 = require("./native");
 /**
  * Whether a channel or member with these attributes survives `filter`.
  *
@@ -37,13 +40,6 @@ function channelFilterMatches(filter, id, status, role) {
 /**
  * The endpoints a peer-supplied message advertises, in the peer's own order.
  *
- * Yields `supported_transports` when it is non-empty, and otherwise the
- * singular `transport_protocol` — which is how every implementation predating
- * the offer list advertises, and the reason this is a function rather than a
- * field read. Reading `transport_protocol` directly is a bug: its meaning
- * narrowed to "one entry of a list, and possibly absent", so a peer that has
- * moved past it looks unreachable to a reader that was correct before 0.0.3.
- *
  * Reports what was advertised, not what is acceptable — nothing here is
  * validated, and the protocol still applies its own transport policy to
  * whatever it records.
@@ -51,10 +47,23 @@ function channelFilterMatches(filter, id, status, role) {
 function advertisedEndpoints(message) {
     if (!message)
         return [];
-    const offers = message.supported_transports ?? [];
-    if (offers.length > 0)
-        return offers;
-    return message.transport_protocol ? [message.transport_protocol] : [];
+    return message.supported_transports ?? [];
+}
+/**
+ * The DeRec protocol version this build speaks — the `protocolVersionMajor` /
+ * `protocolVersionMinor` it writes into every envelope it produces. Not the
+ * package version.
+ */
+function protocol_version() {
+    return (0, native_1.getNative)().version();
+}
+/**
+ * A fresh, random replica id — never `0`. Generate it once per device,
+ * persist it, and pass the same value to
+ * `DeRecProtocolBuilder.withReplicaId` on every init.
+ */
+function generate_replica_id() {
+    return (0, native_1.getNative)().generate_replica_id();
 }
 /**
  * Builds a {@link Transport} that tries each endpoint in the order the peer
@@ -126,7 +135,7 @@ var SenderKind;
  *   the scanner must fetch the actual keys over the wire via the `PrePair`
  *   round-trip and verify them against the commitment before pairing.
  * - `NoKeys`: no key material and no commitment. The contact carries only
- *   `channel_id`, `nonce`, and `transport_protocol` — small enough to be
+ *   `channel_id`, `nonce`, and `supported_transports` — small enough to be
  *   hand-typed or dictated. Keys are generated on the fly by the contact
  *   creator when the `PrePairRequest` arrives; the scanner accepts them
  *   without cryptographic verification. Trust rests entirely on the OOB
@@ -168,3 +177,24 @@ var FlowKind;
      *  string so ids above 2^53 survive JS number handling. */
     FlowKind[FlowKind["UnpairReplica"] = 8] = "UnpairReplica";
 })(FlowKind || (exports.FlowKind = FlowKind = {}));
+/** Result status carried in every protocol response (`result.proto`). Passed
+ *  to `reject()` to say why an inbound request was refused. */
+var StatusEnum;
+(function (StatusEnum) {
+    StatusEnum[StatusEnum["Ok"] = 0] = "Ok";
+    StatusEnum[StatusEnum["Partial"] = 1] = "Partial";
+    StatusEnum[StatusEnum["Fail"] = 2] = "Fail";
+    StatusEnum[StatusEnum["SizeLimitExceeded"] = 3] = "SizeLimitExceeded";
+    StatusEnum[StatusEnum["TooFrequent"] = 4] = "TooFrequent";
+    StatusEnum[StatusEnum["UnknownSecretId"] = 5] = "UnknownSecretId";
+    StatusEnum[StatusEnum["UnknownShareVersion"] = 6] = "UnknownShareVersion";
+    StatusEnum[StatusEnum["DecryptionFailed"] = 7] = "DecryptionFailed";
+    StatusEnum[StatusEnum["VerificationFailed"] = 8] = "VerificationFailed";
+    StatusEnum[StatusEnum["FormatError"] = 9] = "FormatError";
+    StatusEnum[StatusEnum["Rejected"] = 10] = "Rejected";
+    StatusEnum[StatusEnum["IncompatibleParameterRange"] = 11] = "IncompatibleParameterRange";
+    StatusEnum[StatusEnum["UnsupportedTransportProtocol"] = 12] = "UnsupportedTransportProtocol";
+    StatusEnum[StatusEnum["VersionConflict"] = 13] = "VersionConflict";
+    StatusEnum[StatusEnum["ReplicaIdConflict"] = 14] = "ReplicaIdConflict";
+    StatusEnum[StatusEnum["RequestToClose"] = 99] = "RequestToClose";
+})(StatusEnum || (exports.StatusEnum = StatusEnum = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@derec-alliance/react-native",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "React Native bindings for derec-library, the Rust SDK for the DeRec protocol.",
   "license": "Apache-2.0",
   "repository": {