@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/data/change-tracking.js

@@ -37,6 +37,12 @@ exports.changeRecordSchema = zod_1.z.object({
         .describe("Local apply / sync-visibility time; assigned at insert, incoming values replaced"),
     supersededAt: zod_1.z.number().optional().describe("When this change was superseded; unset if active"),
 });
+/** Five id characters starting at `start`, read as one base-128 number. */
+function idTailNumber(start) {
+    return [0, 1, 2, 3, 4]
+        .map((i) => `${128 ** (4 - i)} * unicode(substr(changeId, ${start + i}, 1))`)
+        .join(" + ");
+}
 const changeTrackingV2TableMetaData = {
     name: "ChangeTrackingV2",
     primaryKeyName: "changeId",
@@ -228,6 +234,89 @@ class ChangeTrackingTable extends orm_1.SQLDataSource {
     `, changeIds);
         return missingChangeIds.map((d) => d.changeId);
     }
+    /**
+     * Count active changes per table, or per table and change-id prefix, with a digest of their ids.
+     * Two devices holding the same active changes get the same results. One scan of the
+     * `(tableName, supersededAt)` index, which holds every change id.
+     *
+     * @param request - Which changes to count and how to group them
+     * @returns One row per table (and prefix) that has any active changes
+     */
+    async countChanges(request) {
+        if (!request ||
+            typeof request.before !== "string" ||
+            !/^[0-9a-z]{1,25}$/i.test(request.before) ||
+            (request.tableName !== undefined &&
+                (typeof request.tableName !== "string" ||
+                    !request.tableName ||
+                    request.tableName.length > 256)) ||
+            (request.prefix !== undefined &&
+                (typeof request.prefix !== "string" || !/^[0-9a-z]{0,25}$/i.test(request.prefix))) ||
+            (request.prefixLength !== undefined &&
+                (!Number.isInteger(request.prefixLength) ||
+                    request.prefixLength < 1 ||
+                    request.prefixLength > 25 ||
+                    !request.tableName ||
+                    request.prefixLength <= (request.prefix?.length ?? 0))) ||
+            (request.afterPrefix !== undefined &&
+                (typeof request.afterPrefix !== "string" ||
+                    !request.tableName ||
+                    !/^[0-9a-z]{1,25}$/i.test(request.afterPrefix))) ||
+            (request.excludedTableNames !== undefined &&
+                (!Array.isArray(request.excludedTableNames) ||
+                    request.excludedTableNames.some((name) => typeof name !== "string" || name.length > 256)))) {
+            throw new Error("Invalid countChanges request");
+        }
+        await this.initTable();
+        const { before, excludedTableNames = [], tableName, prefix, prefixLength, afterPrefix, } = request;
+        const conditions = ["supersededAt IS NULL", "changeId < ?"];
+        const params = [before];
+        // Without one table, list the table names with a seek per name. Without index statistics,
+        // SQLite would otherwise read every row through the (supersededAt, ...) index, which lacks
+        // tableName, instead of scanning the covering one.
+        let tableNames = "";
+        if (tableName !== undefined) {
+            conditions.push("tableName = ?");
+            params.push(tableName);
+        }
+        else {
+            tableNames = `WITH RECURSIVE names(name) AS (
+           SELECT MIN(tableName) FROM "${this.tableName}"
+           UNION ALL
+           SELECT (SELECT MIN(tableName) FROM "${this.tableName}" WHERE tableName > names.name)
+           FROM names WHERE names.name IS NOT NULL
+         )`;
+            conditions.push("tableName IN (SELECT name FROM names)");
+        }
+        if (excludedTableNames.length) {
+            conditions.push(`tableName NOT IN (${excludedTableNames.map(() => "?").join(", ")})`);
+            params.push(...excludedTableNames);
+        }
+        if (prefix) {
+            // Change ids are lowercase base36, so every id with this prefix sorts below `prefix~`.
+            conditions.push("changeId >= ?", "changeId < ?");
+            params.push(prefix, `${prefix}~`);
+        }
+        if (afterPrefix) {
+            conditions.push("changeId > ?");
+            params.push(`${afterPrefix}~`);
+        }
+        const length = prefixLength ?? 0;
+        const prefixColumn = length ? `, substr(changeId, 1, ${length}) AS prefix` : "";
+        const rows = await this.db.all(`${tableNames}
+         SELECT tableName${prefixColumn}, COUNT(*) AS count,
+           CAST(SUM(${idTailNumber(16)}) AS TEXT) || ':' || CAST(SUM(${idTailNumber(21)}) AS TEXT) AS sums
+         FROM "${this.tableName}"
+         WHERE ${conditions.join(" AND ")}
+         GROUP BY tableName${length ? ", prefix" : ""}
+         ORDER BY tableName${length ? ", prefix LIMIT 500" : ""}`, params);
+        return rows.map((row) => ({
+            tableName: row.tableName,
+            ...(length ? { prefix: row.prefix } : {}),
+            count: Number(row.count),
+            sums: String(row.sums),
+        }));
+    }
     /**
      * Mark every still-active change for `recordId` whose `createdAt` is older
      * than `supersededAt`. Used after a root snapshot, delete, or restore.

package/dist/data/orm/types.d.ts

@@ -26,24 +26,33 @@ export interface ITableMetaData {
     versionNumber?: number;
 }
 /**
- * Convert field metadata to the runtime Zod schema the Runtime validates with: table rows and
- * tool arguments.
+ * Convert field metadata to the runtime Zod schema the Runtime validates table rows with.
  *
  * It checks types only: `type`, `isArray`, and `optional`. An object field accepts any object
- * and keeps its keys; nested `fields` and `enumValues` aren't checked, so a row or call from a
- * package built against a newer shape isn't refused. {@link fieldsToShapeSchema} builds the full
- * shape. An optional field refuses `null`: remove empty fields first with
- * {@link withoutEmptyFields}.
+ * and keeps its keys; nested `fields` and `enumValues` aren't checked, so a row from a package
+ * built against a newer shape isn't refused. A tool's arguments are checked with the stricter
+ * {@link fieldsToArgumentsSchema}, and {@link fieldsToShapeSchema} builds the full shape. An
+ * optional field refuses `null`: remove empty fields first with {@link withoutEmptyFields}.
  *
  * @param fields Serializable field definitions.
  * @param codeSchema Optional author schema whose refinements are intersected.
  */
 export declare function fieldsToSchema(fields: IField[], codeSchema?: z.AnyZodObject): z.AnyZodObject;
+/**
+ * Convert a tool's input fields to the Zod schema the Runtime checks its arguments with before
+ * the provider runs. Like {@link fieldsToSchema}, and also: a required field must be present
+ * whatever its type (`any` included), and a field's `enumValues` are enforced. A contract
+ * version's fields don't change once it is stable, so a caller and its provider agree on them.
+ * Nested object `fields` still aren't checked, and keys no field names pass.
+ *
+ * @param fields A tool's input fields.
+ */
+export declare function fieldsToArgumentsSchema(fields: IField[]): z.AnyZodObject;
 /**
  * Convert field metadata to a Zod schema with every shape the IR carries: nested object
  * `fields` and `enumValues`, as well as types. Objects keep keys their `fields` don't list. For
  * describing a tool's arguments to an assistant's model; the Runtime validates with
- * {@link fieldsToSchema}.
+ * {@link fieldsToArgumentsSchema}.
  *
  * @param fields Serializable field definitions.
  */
@@ -72,6 +81,14 @@ export declare function withoutEmptyFields<T>(fields: IField[], value: T): T;
  * @param fields A table definition's fields.
  */
 export declare function comparableTableFields(fields: IField[]): Partial<IField>[];
+/**
+ * The scalar values an enum, a native enum, a literal, or a union of them allows; undefined for
+ * anything else.
+ *
+ * @internal
+ * @param schema A field's Zod schema, unwrapped to its value type.
+ */
+export declare function zodEnumValues(schema: z.ZodTypeAny): (string | number | boolean)[] | undefined;
 /**
  * Convert a Zod object schema to serializable field metadata.
  *

package/dist/data/orm/types.js

@@ -1,39 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fieldsToSchema = fieldsToSchema;
+exports.fieldsToArgumentsSchema = fieldsToArgumentsSchema;
 exports.fieldsToShapeSchema = fieldsToShapeSchema;
 exports.withoutEmptyFields = withoutEmptyFields;
 exports.comparableTableFields = comparableTableFields;
+exports.zodEnumValues = zodEnumValues;
 exports.schemaToFields = schemaToFields;
 const zod_1 = require("zod");
 const field_type_1 = require("../../types/field-type");
 const utils_1 = require("../../utils");
 /**
- * Convert field metadata to the runtime Zod schema the Runtime validates with: table rows and
- * tool arguments.
+ * Convert field metadata to the runtime Zod schema the Runtime validates table rows with.
  *
  * It checks types only: `type`, `isArray`, and `optional`. An object field accepts any object
- * and keeps its keys; nested `fields` and `enumValues` aren't checked, so a row or call from a
- * package built against a newer shape isn't refused. {@link fieldsToShapeSchema} builds the full
- * shape. An optional field refuses `null`: remove empty fields first with
- * {@link withoutEmptyFields}.
+ * and keeps its keys; nested `fields` and `enumValues` aren't checked, so a row from a package
+ * built against a newer shape isn't refused. A tool's arguments are checked with the stricter
+ * {@link fieldsToArgumentsSchema}, and {@link fieldsToShapeSchema} builds the full shape. An
+ * optional field refuses `null`: remove empty fields first with {@link withoutEmptyFields}.
  *
  * @param fields Serializable field definitions.
  * @param codeSchema Optional author schema whose refinements are intersected.
  */
 function fieldsToSchema(fields, codeSchema) {
-    return buildFieldsSchema(fields, false, codeSchema);
+    return buildFieldsSchema(fields, "rows", codeSchema);
+}
+/**
+ * Convert a tool's input fields to the Zod schema the Runtime checks its arguments with before
+ * the provider runs. Like {@link fieldsToSchema}, and also: a required field must be present
+ * whatever its type (`any` included), and a field's `enumValues` are enforced. A contract
+ * version's fields don't change once it is stable, so a caller and its provider agree on them.
+ * Nested object `fields` still aren't checked, and keys no field names pass.
+ *
+ * @param fields A tool's input fields.
+ */
+function fieldsToArgumentsSchema(fields) {
+    return buildFieldsSchema(fields, "arguments");
 }
 /**
  * Convert field metadata to a Zod schema with every shape the IR carries: nested object
  * `fields` and `enumValues`, as well as types. Objects keep keys their `fields` don't list. For
  * describing a tool's arguments to an assistant's model; the Runtime validates with
- * {@link fieldsToSchema}.
+ * {@link fieldsToArgumentsSchema}.
  *
  * @param fields Serializable field definitions.
  */
 function fieldsToShapeSchema(fields) {
-    return buildFieldsSchema(fields, true);
+    return buildFieldsSchema(fields, "shapes");
 }
 function enumSchema(values) {
     if (values.every((value) => typeof value === "string")) {
@@ -44,8 +57,8 @@ function enumSchema(values) {
         ? literals[0]
         : zod_1.z.union(literals);
 }
-function fieldValueSchema(field, shapes, open) {
-    if (shapes && field.enumValues?.length) {
+function fieldValueSchema(field, mode, open) {
+    if (mode !== "rows" && field.enumValues?.length) {
         return enumSchema(field.enumValues);
     }
     switch (field.type) {
@@ -63,7 +76,9 @@ function fieldValueSchema(field, shapes, open) {
         case "Date":
             return zod_1.z.date();
         case "object": {
-            const object = shapes && field.fields ? buildFieldsSchema(field.fields, true) : zod_1.z.object({});
+            const object = mode === "shapes" && field.fields
+                ? buildFieldsSchema(field.fields, "shapes")
+                : zod_1.z.object({});
             // An author schema intersected with this one parses the value itself; two parses of
             // one object can't be merged, so only an open object keeps its keys.
             return open ? object.passthrough() : object;
@@ -72,12 +87,12 @@ function fieldValueSchema(field, shapes, open) {
             return zod_1.z.any();
     }
 }
-function buildFieldsSchema(fields, shapes, codeSchema) {
+function buildFieldsSchema(fields, mode, codeSchema) {
     let argsSchema = zod_1.z.object({});
     for (const field of fields) {
         const { name, description, isArray, defaultValue, optional } = field;
         const shapeField = codeSchema?.shape?.[name];
-        let propertyType = fieldValueSchema(field, shapes, !shapeField);
+        let propertyType = fieldValueSchema(field, mode, !shapeField);
         if (isArray) {
             propertyType = propertyType.array();
         }
@@ -87,6 +102,11 @@ function buildFieldsSchema(fields, shapes, codeSchema) {
         if (defaultValue !== undefined) {
             propertyType = propertyType.default(defaultValue);
         }
+        else if (mode !== "rows" && !optional) {
+            // `z.any()` accepts a missing value; a required argument must be there, and a model
+            // describing it must see it listed as required.
+            propertyType = propertyType.refine((value) => value !== undefined, { message: "Required" });
+        }
         propertyType = propertyType.describe(description ?? "");
         if (shapeField) {
             propertyType = zod_1.z.intersection(propertyType, shapeField);
@@ -189,6 +209,42 @@ function comparableTableFields(fields) {
         return comparable;
     });
 }
+/**
+ * The scalar values an enum, a native enum, a literal, or a union of them allows; undefined for
+ * anything else.
+ *
+ * @internal
+ * @param schema A field's Zod schema, unwrapped to its value type.
+ */
+function zodEnumValues(schema) {
+    const def = schema._def;
+    switch (def.typeName) {
+        case "ZodEnum":
+            return [...def.values];
+        case "ZodNativeEnum": {
+            // A numeric TypeScript enum maps each value back to its name too; skip those keys.
+            const values = def.values;
+            return Object.keys(values)
+                .filter((key) => typeof values[values[key]] !== "number")
+                .map((key) => values[key]);
+        }
+        case "ZodLiteral":
+            return ["string", "number", "boolean"].includes(typeof def.value) ? [def.value] : undefined;
+        case "ZodUnion": {
+            const values = [];
+            for (const option of def.options) {
+                const optionValues = zodEnumValues(option);
+                if (!optionValues) {
+                    return undefined;
+                }
+                values.push(...optionValues);
+            }
+            return values;
+        }
+        default:
+            return undefined;
+    }
+}
 /**
  * Convert a Zod object schema to serializable field metadata.
  *
@@ -199,26 +255,30 @@ function schemaToFields(schema) {
     for (const name of Object.keys(schema.shape)) {
         const field = schema.shape[name];
         let type = field_type_1.FieldType.any;
+        let valueSchema = field;
+        let nullable = false;
+        let enumElements = true;
         let _def = field._def;
         let isArray;
         let brandedFieldType;
         while (true) {
             if (_def.typeName === "ZodArray") {
+                if (isArray)
+                    enumElements = false;
                 isArray = true;
             }
+            if (isArray && (_def.typeName === "ZodOptional" || _def.typeName === "ZodDefault"))
+                enumElements = false;
             if (_def._fieldType) {
                 brandedFieldType = _def._fieldType;
             }
-            if (_def.innerType) {
-                _def = _def.innerType._def;
-                continue;
-            }
-            if (_def.schema) {
-                _def = _def.schema._def;
-                continue;
+            if (_def.typeName === "ZodNullable") {
+                nullable = true;
             }
-            if (_def.type) {
-                _def = _def.type._def;
+            const inner = _def.innerType ?? _def.schema ?? _def.type;
+            if (inner) {
+                valueSchema = inner;
+                _def = inner._def;
                 continue;
             }
             break;
@@ -255,7 +315,20 @@ function schemaToFields(schema) {
         const optional = field._def.typeName === "ZodOptional" || undefined;
         const description = field._def.description;
         const defaultValue = field._def.defaultValue;
-        const newField = { name, type, isArray, optional, description, defaultValue };
+        // The type stays as it was (an enum is `any`) so stable contract shapes don't change. A
+        // nullable enum also allows null, which a list of values can't say. The same is true of
+        // optional/defaulted elements and nested arrays: enumValues describes each immediate element.
+        const values = nullable || !enumElements ? undefined : zodEnumValues(valueSchema);
+        const enumValues = values?.length ? [...new Set(values)] : undefined;
+        const newField = {
+            name,
+            type,
+            isArray,
+            optional,
+            description,
+            defaultValue,
+            enumValues,
+        };
         Object.keys(newField).forEach((k) => {
             // @ts-expect-error
             if (newField[k] === undefined)

package/dist/define/manifest.js

@@ -49,36 +49,6 @@ function literalType(schema) {
         return field_type_1.FieldType.boolean;
     return undefined;
 }
-/** The scalar values an enum, a literal, or a union of them allows; undefined for anything else. */
-function enumValuesOf(schema) {
-    const def = schema._def;
-    switch (def.typeName) {
-        case "ZodEnum":
-            return [...def.values];
-        case "ZodNativeEnum": {
-            // A numeric TypeScript enum maps each value back to its name too; skip those keys.
-            const values = def.values;
-            return Object.keys(values)
-                .filter((key) => typeof values[values[key]] !== "number")
-                .map((key) => values[key]);
-        }
-        case "ZodLiteral":
-            return ["string", "number", "boolean"].includes(typeof def.value) ? [def.value] : undefined;
-        case "ZodUnion": {
-            const values = [];
-            for (const option of def.options) {
-                const optionValues = enumValuesOf(option);
-                if (!optionValues) {
-                    return undefined;
-                }
-                values.push(...optionValues);
-            }
-            return values;
-        }
-        default:
-            return undefined;
-    }
-}
 /**
  * What a field's schema says beyond its type: an object's own fields and the values an enum or
  * literal allows. Walks the wrappers `schemaToFields` walks, into one array's elements, and
@@ -153,7 +123,7 @@ function fieldDetails(schema, shape, input, depth, path, event = false, wholeVal
             ? eventFields(current, depth + 1, path)
             : irFields(current, input, depth + 1, path);
     }
-    const values = enumValuesOf(current);
+    const values = (0, types_1.zodEnumValues)(current);
     if (!emptyElement && values?.length && values.every((value) => (0, isolated_artifact_1.enumValueFits)(value, type))) {
         details.enumValues = [...new Set(values)];
     }
@@ -190,8 +160,10 @@ function irField(schema, schemaField, input, depth, path, wholeValue = false) {
     const generated = (0, generated_field_1.generatedFieldMetadata)(schema);
     if (generated)
         return { name: schemaField.name, ...generated.shape };
-    const literal = schemaField.type === field_type_1.FieldType.any ? literalType(schema) : undefined;
-    const field = literal ? { ...schemaField, type: literal } : schemaField;
+    // The IR records enum values itself (fieldDetails), only where they fit the field's type.
+    const { enumValues: _enumValues, ...plainField } = schemaField;
+    const literal = plainField.type === field_type_1.FieldType.any ? literalType(schema) : undefined;
+    const field = literal ? { ...plainField, type: literal } : plainField;
     const { defaultValue: _default, ...rest } = field;
     const result = typeof _default === "function" ? rest : field;
     const details = fieldDetails(schema, field, input, depth, path, false, wholeValue);
@@ -500,7 +472,7 @@ function eventFields(schema, depth = 1, parent = "") {
         const generated = (0, generated_field_1.generatedFieldMetadata)(schema.shape[field.name]);
         if (generated)
             return { name: field.name, ...generated.shape };
-        const { type: _type, optional: _optional, isArray: _array, defaultValue, ...metadata } = field;
+        const { type: _type, optional: _optional, isArray: _array, defaultValue, enumValues: _enumValues, ...metadata } = field;
         const shape = eventValueShape(schema.shape[field.name]);
         const path = parent ? `${parent}.${field.name}` : field.name;
         return {

package/dist/device/binary-peer-connection-v2.d.ts

@@ -1,15 +1,15 @@
 /**
  * binary-peer-connection-v2.ts
  *
- * Unified binary transport layer that replaces both binary-peer-connection.ts
- * and streamed-socket.ts. Provides two cleanly separated modes:
+ * Binary transport layer under every device connection. Provides two cleanly
+ * separated modes:
  *
  * 1. **RPC mode** (emit/on): request/response interactions with automatic
  *    encoding (txEncode for objects, passthrough for Uint8Array) and transparent
  *    chunking for large payloads.
  *
  * 2. **Stream mode** (sendRawBytes/onRawBytes): continuous byte transfer for
- *    file syncing, database downloads, log streaming, etc. Each sendRawBytes
+ *    file syncing, log streaming, etc. Each sendRawBytes
  *    call = exactly one onRawBytes callback (atomic delivery after reassembly).
  *
  * Both modes share a single sendFrame() function that handles backpressure
@@ -61,19 +61,12 @@ export declare const DEFAULT_BINARY_PEER_RECEIVE_LIMITS: Readonly<BinaryPeerRece
 export interface WrapBinaryPeerOptions {
     /** Protocol identifier used for server address (e.g., 'wrtc' or 'ws') */
     protocol: "wrtc" | "ws";
-    /**
-     * Mark the transport as already secure (encrypted at transport layer).
-     * When true, sets secureLocal and secureRemote to skip the legacy per-message
-     * envelope against a legacy peer. Irrelevant once the frame cipher is armed.
-     * @deprecated Removed with the legacy path.
-     */
-    markTransportSecure?: boolean;
     /** Optional hard limits for untrusted inbound messages. */
     receiveLimits?: Partial<BinaryPeerReceiveLimits>;
 }
 /**
  * Creates an ISocket from a binary peer. This is the core v2 factory function.
- * Replaces both createBinaryPeerSocket (v1) and StreamedSocket.
+ * Used for every device connection.
  */
 export declare function createBinaryPeerSocket(connectionId: string, peer: IBinaryPeer, protocol?: string, receiveLimitOverrides?: Partial<BinaryPeerReceiveLimits>): ISocket;
 /**
@@ -82,10 +75,9 @@ export declare function createBinaryPeerSocket(connectionId: string, peer: IBina
  */
 export declare function wrapBinaryPeer(connectionId: string, peer: IBinaryPeer, localDevice: Device, initiator: boolean, options: WrapBinaryPeerOptions, getTrustLevel?: ITrustLevelFn): Connection;
 /**
- * Wraps a WebRTC peer into a Connection.
- * WebRTC is encrypted at the transport layer (DTLS-SRTP); the frame cipher is
- * armed on top of it by the handshake so no code path depends on transport
- * classification.
+ * Wraps a WebRTC peer into a Connection. WebRTC is encrypted at the transport
+ * layer (DTLS-SRTP); the handshake arms the frame cipher on top of it, as on
+ * every transport.
  */
 export declare function wrapWrtc(connectionId: string, peer: IWebRTCPeer, localDevice: Device, initiator: boolean, getTrustLevel?: ITrustLevelFn, receiveLimits?: Partial<BinaryPeerReceiveLimits>): Connection;
 export {};

package/dist/device/binary-peer-connection-v2.js

@@ -2,15 +2,15 @@
 /**
  * binary-peer-connection-v2.ts
  *
- * Unified binary transport layer that replaces both binary-peer-connection.ts
- * and streamed-socket.ts. Provides two cleanly separated modes:
+ * Binary transport layer under every device connection. Provides two cleanly
+ * separated modes:
  *
  * 1. **RPC mode** (emit/on): request/response interactions with automatic
  *    encoding (txEncode for objects, passthrough for Uint8Array) and transparent
  *    chunking for large payloads.
  *
  * 2. **Stream mode** (sendRawBytes/onRawBytes): continuous byte transfer for
- *    file syncing, database downloads, log streaming, etc. Each sendRawBytes
+ *    file syncing, log streaming, etc. Each sendRawBytes
  *    call = exactly one onRawBytes callback (atomic delivery after reassembly).
  *
  * Both modes share a single sendFrame() function that handles backpressure
@@ -240,7 +240,7 @@ function buildStreamCont(sidBytes, chunkData) {
 }
 /**
  * Creates an ISocket from a binary peer. This is the core v2 factory function.
- * Replaces both createBinaryPeerSocket (v1) and StreamedSocket.
+ * Used for every device connection.
  */
 function createBinaryPeerSocket(connectionId, peer, protocol = "binary", receiveLimitOverrides = {}) {
     const handlers = {};
@@ -265,7 +265,7 @@ function createBinaryPeerSocket(connectionId, peer, protocol = "binary", receive
     let sendSealer = null;
     let receiveOpener = null;
     // Bare sockets (no Connection) deliver plaintext streams; Connection turns
-    // this off and re-enables it only for a verified legacy peer.
+    // this off, so it receives only sealed stream frames.
     let plaintextStreamsAllowed = true;
     // Every inner frame must leave room for the cipher's 17 bytes so a sealed
     // frame never exceeds the transport limit (64 KB SCTP on WebRTC). Reserved
@@ -503,7 +503,7 @@ function createBinaryPeerSocket(connectionId, peer, protocol = "binary", receive
                     else
                         responseMessage.result = result;
                     const encoded = encodeMessage(responseMessage);
-                    sendRPC(encoded, sendOptions);
+                    return sendRPC(encoded, sendOptions);
                 };
                 handler(message.args, callback);
             }
@@ -730,17 +730,8 @@ function createBinaryPeerSocket(connectionId, peer, protocol = "binary", receive
                     break;
                 }
                 default: {
-                    // v1 backwards compatibility: if frame type isn't recognized but looks
-                    // like a v1 PROTOCOL_RPC (0x00) it's already handled above. For true
-                    // legacy format (no discriminator), try to decode as RPC.
-                    // This handles the transition period where v1 peers send raw RPC without
-                    // a frame type byte.
-                    if (bytes.length > receiveLimits.maxRpcMessageBytes) {
-                        closeForProtocolViolation("legacy RPC exceeds the message-size limit");
-                        return;
-                    }
-                    handleIncomingRPC(bytes);
-                    break;
+                    closeForProtocolViolation(`unknown frame type ${frameType}`);
+                    return;
                 }
             }
         }
@@ -762,7 +753,6 @@ function createBinaryPeerSocket(connectionId, peer, protocol = "binary", receive
     const socket = {
         id: connectionId,
         connected: true,
-        handlesOwnEncoding: true,
         transportType,
         stats,
         armFrameCipher,
@@ -811,26 +801,20 @@ function createBinaryPeerSocket(connectionId, peer, protocol = "binary", receive
  * This is the main implementation that handles all binary protocols.
  */
 function wrapBinaryPeer(connectionId, peer, localDevice, initiator, options, getTrustLevel) {
-    const { protocol, markTransportSecure, receiveLimits } = options;
+    const { protocol, receiveLimits } = options;
     const socket = createBinaryPeerSocket(connectionId, peer, protocol, receiveLimits);
     const serverAddress = `${protocol}://${connectionId}`;
     const localServerAddresses = initiator ? undefined : [serverAddress];
     if (process.env.NODE_ENV !== "test") {
         getTrustLevel ??= (0, get_trust_level_fn_1.getTrustLevelFn)(localDevice, serverAddress);
     }
-    const connection = new connection_1.Connection(socket, localDevice, localServerAddresses, getTrustLevel);
-    if (markTransportSecure) {
-        connection.secureLocal = true;
-        connection.secureRemote = true;
-    }
-    return connection;
+    return new connection_1.Connection(socket, localDevice, localServerAddresses, getTrustLevel);
 }
 /**
- * Wraps a WebRTC peer into a Connection.
- * WebRTC is encrypted at the transport layer (DTLS-SRTP); the frame cipher is
- * armed on top of it by the handshake so no code path depends on transport
- * classification.
+ * Wraps a WebRTC peer into a Connection. WebRTC is encrypted at the transport
+ * layer (DTLS-SRTP); the handshake arms the frame cipher on top of it, as on
+ * every transport.
  */
 function wrapWrtc(connectionId, peer, localDevice, initiator, getTrustLevel, receiveLimits) {
-    return wrapBinaryPeer(connectionId, peer, localDevice, initiator, { protocol: "wrtc", markTransportSecure: true, receiveLimits }, getTrustLevel);
+    return wrapBinaryPeer(connectionId, peer, localDevice, initiator, { protocol: "wrtc", receiveLimits }, getTrustLevel);
 }