@undefineds.co/xpod 0.4.18 → 0.4.20

package/dist/edge/reachability/ManagedClientFetch.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSignaledManagedClientFetch = createSignaledManagedClientFetch;
 exports.createManagedClientFetch = createManagedClientFetch;
 const CanonicalFetch_1 = require("./CanonicalFetch");
-const RouteValidation_1 = require("./RouteValidation");
 const P2PDataPlane_1 = require("./P2PDataPlane");
 const P2PSignalingClient_1 = require("./P2PSignalingClient");
 const TcpP2PSignalingSession_1 = require("./TcpP2PSignalingSession");
@@ -35,10 +34,8 @@ async function createSignaledManagedClientFetch(options) {
 }
 async function createManagedClientFetch(options) {
     const errors = [];
-    const now = (options.now ?? (() => new Date()))();
-    for (const route of candidateRoutes(options.routeSet, now, errors)) {
+    for (const route of candidateRoutes(options.routeSet)) {
         if (!await routeProbeSucceeds(route, options)) {
-            errors.push(`Route ${route.id} failed its reachability probe`);
             continue;
         }
         if (route.kind === 'p2p') {
@@ -63,24 +60,11 @@ async function createManagedClientFetch(options) {
     }
     throw new Error(`No managed client route could be opened${errors.length > 0 ? `: ${errors.join('; ')}` : ''}`);
 }
-/**
- * Routes worth dialling, decided locally before any probe. Skipped routes are named in
- * `skipped` so a failed selection says why instead of just failing.
- */
-function candidateRoutes(routeSet, now, skipped) {
-    const candidates = [];
-    for (const route of routeSet.routes) {
-        if (route.health === 'unreachable') {
-            continue;
-        }
-        const reason = (0, RouteValidation_1.routeUnusableReason)(route, { now, remoteClient: true });
-        if (reason) {
-            skipped.push(`Route ${route.id} skipped: ${reason}`);
-            continue;
-        }
-        candidates.push(route);
-    }
-    return candidates.sort((left, right) => left.priority - right.priority || left.id.localeCompare(right.id));
+function candidateRoutes(routeSet) {
+    return routeSet.routes
+        .filter((route) => route.health !== 'unreachable')
+        .slice()
+        .sort((left, right) => left.priority - right.priority || left.id.localeCompare(right.id));
 }
 async function routeProbeSucceeds(route, options) {
     const controller = new AbortController();
@@ -101,10 +85,14 @@ async function defaultManagedProbe(route, signal, fetchImpl) {
     if (route.kind === 'p2p') {
         return route.health !== 'unreachable';
     }
-    if (!(0, RouteValidation_1.isHttpTarget)(route.targetUrl)) {
+    if (!route.targetUrl.startsWith('http://') && !route.targetUrl.startsWith('https://')) {
         return route.health === 'healthy';
     }
-    return await (0, RouteValidation_1.probeSolidWellKnown)(route.targetUrl, signal, fetchImpl);
+    const response = await (fetchImpl ?? fetch)(new URL('/.well-known/solid', route.targetUrl), {
+        method: 'HEAD',
+        signal,
+    });
+    return response.status < 500;
 }
 function managedResult(route, fetch, transport) {
     return {

package/dist/edge/reachability/ManagedClientFetch.jsonld

@@ -29,10 +29,6 @@
         {
           "@id": "undefineds:dist/edge/reachability/ManagedClientFetch.jsonld#ManagedClientFetchOptions__member_p2p",
           "memberFieldName": "p2p"
-        },
-        {
-          "@id": "undefineds:dist/edge/reachability/ManagedClientFetch.jsonld#ManagedClientFetchOptions__member_now",
-          "memberFieldName": "now"
         }
       ],
       "constructorArguments": []

package/dist/edge/reachability/ManagedRouteSelector.d.ts

@@ -3,7 +3,5 @@ export interface ChooseAccessRouteOptions {
     managedClient: boolean;
     timeoutMs?: number;
     probe?: (route: AccessRoute, signal: AbortSignal) => Promise<boolean> | boolean;
-    /** Injectable clock: expired access points must be rejected against a known time in tests. */
-    now?: () => Date;
 }
 export declare function chooseAccessRoute(routeSet: RouteSet, options: ChooseAccessRouteOptions): Promise<AccessRoute | null>;

package/dist/edge/reachability/ManagedRouteSelector.js

@@ -1,15 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.chooseAccessRoute = chooseAccessRoute;
-const RouteValidation_1 = require("./RouteValidation");
 async function chooseAccessRoute(routeSet, options) {
-    const now = (options.now ?? (() => new Date()))();
     const candidates = routeSet.routes
         .filter((route) => route.health !== 'unreachable')
         .filter((route) => options.managedClient || !route.requiresManagedClient)
-        // Expired and loopback-only access points are dropped before any probe: the node
-        // advertises its own list, so validating it is the client's job (N06).
-        .filter((route) => (0, RouteValidation_1.routeUnusableReason)(route, { now, remoteClient: options.managedClient }) === undefined)
         .slice()
         .sort((left, right) => left.priority - right.priority || left.id.localeCompare(right.id));
     if (candidates.length === 0) {
@@ -35,10 +30,21 @@ async function probeWithTimeout(route, probe, timeoutMs) {
         clearTimeout(timeout);
     }
 }
+/**
+ * Same rule as the client transport's probe (`@undefineds.co/solid-sdk/access-route`):
+ * a route answers when its host completed the HTTP exchange without failing. A
+ * host that returns 404/405/501 for `/.well-known/solid` does not implement that
+ * optional discovery path and is still serving the route; only a failing host
+ * (5xx, closed socket) reports no route.
+ */
 async function defaultProbe(route, signal) {
-    if (!(0, RouteValidation_1.isHttpTarget)(route.targetUrl)) {
+    if (!route.targetUrl.startsWith('http://') && !route.targetUrl.startsWith('https://')) {
         return route.health === 'healthy';
     }
-    return await (0, RouteValidation_1.probeSolidWellKnown)(route.targetUrl, signal);
+    const response = await fetch(new URL('/.well-known/solid', route.targetUrl), {
+        method: 'HEAD',
+        signal,
+    });
+    return response.status < 500;
 }
 //# sourceMappingURL=ManagedRouteSelector.js.map

package/dist/edge/reachability/ManagedRouteSelector.jsonld

@@ -21,10 +21,6 @@
         {
           "@id": "undefineds:dist/edge/reachability/ManagedRouteSelector.jsonld#ChooseAccessRouteOptions__member_probe",
           "memberFieldName": "probe"
-        },
-        {
-          "@id": "undefineds:dist/edge/reachability/ManagedRouteSelector.jsonld#ChooseAccessRouteOptions__member_now",
-          "memberFieldName": "now"
         }
       ],
       "constructorArguments": []

package/dist/edge/reachability/P2PDataPlane.d.ts

@@ -1,36 +1,5 @@
 import type { AccessRoute } from './types';
 export declare const XPOD_P2P_HTTP_PROTOCOL: "xpod-p2p-http/1";
-/**
- * Resource ceilings for the P2P data plane (audit N17).
- *
- * The data plane is a byte pipe between two processes, so every unbounded quantity on it is a
- * denial-of-service waiting to happen: a single line that never ends, a body that never stops,
- * or a peer that opens more requests than the other side can serve. The numbers are deliberately
- * generous for Pod traffic and small enough to fail fast.
- */
-export declare const P2P_DATA_PLANE_LIMITS: {
-    /** Largest single wire line (one JSON envelope, base64 included). */
-    readonly maxFrameBytes: number;
-    /** Largest request or response body carried inside frames. */
-    readonly maxBodyBytes: number;
-    /** In-flight requests allowed per transport and per socket. */
-    readonly maxConcurrentRequests: 16;
-    /** Chunk size used when a response body is streamed. */
-    readonly chunkBytes: number;
-};
-export type P2PDataPlaneLimit = keyof typeof P2P_DATA_PLANE_LIMITS;
-/** Exceeding a ceiling is its own error so callers can answer 413/429 instead of a generic 502. */
-export declare class P2PDataPlaneLimitError extends Error {
-    readonly limit: P2PDataPlaneLimit;
-    constructor(message: string, limit: P2PDataPlaneLimit);
-}
-/** The caller aborted: the request may still be running on the peer until the cancel lands. */
-export declare class P2PDataPlaneAbortError extends Error {
-    constructor(message?: string);
-}
-/** Header a client sets to say it can consume chunked (streamed) response bodies. */
-export declare const XPOD_P2P_ACCEPT_HEADER: "x-xpod-p2p-accept";
-export declare const XPOD_P2P_ACCEPT_CHUNKED: "chunked";
 export type P2PHttpProtocol = typeof XPOD_P2P_HTTP_PROTOCOL;
 export type P2PHttpHeaderList = [string, string][];
 export interface P2PHttpRequestFrame {
@@ -48,53 +17,21 @@ export interface P2PHttpResponseFrame {
     statusText?: string;
     headers?: P2PHttpHeaderList;
     bodyBase64?: string;
-    /**
-     * Set when the head (status/headers) was delivered before the body finished: `bodyBase64` is
-     * then absent, every chunk follows through the transport's chunk callback, and the end of the
-     * body arrives with the transport's end callback.
-     */
-    streamed?: boolean;
-    /** Present instead of `bodyBase64` when the requester accepts a streamed body. */
-    bodyStream?: ReadableStream<Uint8Array>;
-}
-export interface P2PDataPlaneRequestOptions {
-    /** Aborting removes the pending request and tells the peer to stop working on it. */
-    signal?: AbortSignal;
-    /** Receives every body chunk of a streamed response, in order. */
-    onChunk?: (chunk: Uint8Array) => void;
-    /** Called once the body of a streamed response is complete. */
-    onEnd?: () => void;
-    /** Called when a streamed body fails after its head was already delivered. */
-    onError?: (error: Error) => void;
 }
 export interface P2PDataPlaneTransport {
-    /**
-     * True when the transport understands chunk/end envelopes. A transport that does not must
-     * never be sent a streaming request: it would drop the body and answer an empty 200.
-     */
-    readonly supportsStreaming?: boolean;
-    request(frame: P2PHttpRequestFrame, options?: P2PDataPlaneRequestOptions): Promise<P2PHttpResponseFrame>;
-}
-export interface P2PDataPlaneLimitsOptions {
-    maxFrameBytes?: number;
-    maxBodyBytes?: number;
-    maxConcurrentRequests?: number;
+    request(frame: P2PHttpRequestFrame): Promise<P2PHttpResponseFrame>;
 }
-export interface P2PDataPlaneFetchOptions extends P2PDataPlaneLimitsOptions {
+export interface P2PDataPlaneFetchOptions {
     route: AccessRoute;
     transport: P2PDataPlaneTransport;
 }
-export interface P2PDataPlaneHandlerOptions extends P2PDataPlaneLimitsOptions {
+export interface P2PDataPlaneHandlerOptions {
     targetBaseUrl: string | URL;
     fetchImpl?: typeof fetch;
 }
 export interface P2PDataPlaneHandler {
-    handleRequest(frame: P2PHttpRequestFrame, options?: {
-        signal?: AbortSignal;
-    }): Promise<P2PHttpResponseFrame>;
+    handleRequest(frame: P2PHttpRequestFrame): Promise<P2PHttpResponseFrame>;
 }
 export type P2PDataPlaneFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 export declare function createP2PDataPlaneFetch(options: P2PDataPlaneFetchOptions): P2PDataPlaneFetch;
 export declare function createP2PDataPlaneHandler(options: P2PDataPlaneHandlerOptions): P2PDataPlaneHandler;
-/** Decoded size of a base64 payload without allocating the buffer. */
-export declare function base64ByteLength(value: string): number;

package/dist/edge/reachability/P2PDataPlane.js

@@ -1,124 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.XPOD_P2P_ACCEPT_CHUNKED = exports.XPOD_P2P_ACCEPT_HEADER = exports.P2PDataPlaneAbortError = exports.P2PDataPlaneLimitError = exports.P2P_DATA_PLANE_LIMITS = exports.XPOD_P2P_HTTP_PROTOCOL = void 0;
+exports.XPOD_P2P_HTTP_PROTOCOL = void 0;
 exports.createP2PDataPlaneFetch = createP2PDataPlaneFetch;
 exports.createP2PDataPlaneHandler = createP2PDataPlaneHandler;
-exports.base64ByteLength = base64ByteLength;
 exports.XPOD_P2P_HTTP_PROTOCOL = 'xpod-p2p-http/1';
-/**
- * Resource ceilings for the P2P data plane (audit N17).
- *
- * The data plane is a byte pipe between two processes, so every unbounded quantity on it is a
- * denial-of-service waiting to happen: a single line that never ends, a body that never stops,
- * or a peer that opens more requests than the other side can serve. The numbers are deliberately
- * generous for Pod traffic and small enough to fail fast.
- */
-exports.P2P_DATA_PLANE_LIMITS = {
-    /** Largest single wire line (one JSON envelope, base64 included). */
-    maxFrameBytes: 8 * 1024 * 1024,
-    /** Largest request or response body carried inside frames. */
-    maxBodyBytes: 4 * 1024 * 1024,
-    /** In-flight requests allowed per transport and per socket. */
-    maxConcurrentRequests: 16,
-    /** Chunk size used when a response body is streamed. */
-    chunkBytes: 256 * 1024,
-};
-/** Exceeding a ceiling is its own error so callers can answer 413/429 instead of a generic 502. */
-class P2PDataPlaneLimitError extends Error {
-    constructor(message, limit) {
-        super(message);
-        this.limit = limit;
-        this.name = 'P2PDataPlaneLimitError';
-    }
-}
-exports.P2PDataPlaneLimitError = P2PDataPlaneLimitError;
-/** The caller aborted: the request may still be running on the peer until the cancel lands. */
-class P2PDataPlaneAbortError extends Error {
-    constructor(message = 'P2P data plane request was aborted') {
-        super(message);
-        this.name = 'P2PDataPlaneAbortError';
-    }
-}
-exports.P2PDataPlaneAbortError = P2PDataPlaneAbortError;
-/** Header a client sets to say it can consume chunked (streamed) response bodies. */
-exports.XPOD_P2P_ACCEPT_HEADER = 'x-xpod-p2p-accept';
-exports.XPOD_P2P_ACCEPT_CHUNKED = 'chunked';
 function createP2PDataPlaneFetch(options) {
     if (options.route.kind !== 'p2p') {
         throw new Error(`P2P data plane requires a p2p route, got ${options.route.kind}`);
     }
     const canonicalOrigin = new URL(options.route.canonicalUrl).origin;
-    const maxBodyBytes = options.maxBodyBytes ?? exports.P2P_DATA_PLANE_LIMITS.maxBodyBytes;
     return async (input, init) => {
         const request = new Request(input, init);
         const canonicalUrl = new URL(request.url);
         if (canonicalUrl.origin !== canonicalOrigin) {
             throw new Error(`Request ${canonicalUrl.toString()} is outside canonical origin ${canonicalOrigin}`);
         }
-        const bodyBase64 = await bodyToBase64(request, maxBodyBytes);
-        const headers = headersToList(request.headers);
-        // Only a transport that can carry chunk envelopes may ask for a streamed body. An older
-        // peer ignores the header and answers with one frame, which this side still accepts.
-        if (options.transport.supportsStreaming
-            && !headers.some(([key]) => key.toLowerCase() === exports.XPOD_P2P_ACCEPT_HEADER)) {
-            headers.push([exports.XPOD_P2P_ACCEPT_HEADER, exports.XPOD_P2P_ACCEPT_CHUNKED]);
-        }
         const frame = {
             protocol: exports.XPOD_P2P_HTTP_PROTOCOL,
             method: request.method,
             url: canonicalUrl.toString(),
-            headers,
-            bodyBase64,
+            headers: headersToList(request.headers),
+            bodyBase64: await bodyToBase64(request),
         };
-        const signal = init?.signal ?? request.signal;
-        let streamController;
-        const streamedBody = new ReadableStream({
-            start(controller) {
-                streamController = controller;
-            },
-            cancel() {
-                // The consumer stopped reading: the request must not keep the peer working.
-                streamController = undefined;
-            },
-        });
-        let responseFrame;
-        try {
-            responseFrame = await options.transport.request(frame, {
-                ...(signal ? { signal } : {}),
-                onChunk: (chunk) => {
-                    streamController?.enqueue(chunk);
-                },
-                onEnd: () => {
-                    streamController?.close();
-                    streamController = undefined;
-                },
-                onError: (error) => {
-                    streamController?.error(error);
-                    streamController = undefined;
-                },
-            });
-        }
-        catch (error) {
-            // Nothing will read the stream prepared above, and an aborted request must surface as an
-            // abort rather than as a transport error (fetch semantics).
-            await streamedBody.cancel().catch(() => undefined);
-            if (signal?.aborted) {
-                throw new DOMException('The operation was aborted.', 'AbortError');
-            }
-            throw error;
-        }
-        validateResponseFrame(responseFrame, maxBodyBytes);
-        if (responseFrame.streamed) {
-            // Hand the stream over even when it already completed: the consumer still has to read
-            // the chunks that were enqueued before the end envelope arrived.
-            return new Response(streamedBody, {
-                status: responseFrame.status,
-                statusText: responseFrame.statusText,
-                headers: new Headers(responseFrame.headers),
-            });
-        }
-        await streamedBody.cancel().catch(() => undefined);
-        return new Response(base64ToBody(responseFrame.bodyBase64, maxBodyBytes), {
+        const responseFrame = await options.transport.request(frame);
+        validateResponseFrame(responseFrame);
+        return new Response(base64ToBody(responseFrame.bodyBase64), {
             status: responseFrame.status,
             statusText: responseFrame.statusText,
             headers: new Headers(responseFrame.headers),
@@ -128,10 +34,9 @@ function createP2PDataPlaneFetch(options) {
 function createP2PDataPlaneHandler(options) {
     const targetBaseUrl = new URL(options.targetBaseUrl.toString());
     const fetchImpl = options.fetchImpl ?? fetch;
-    const maxBodyBytes = options.maxBodyBytes ?? exports.P2P_DATA_PLANE_LIMITS.maxBodyBytes;
     return {
-        async handleRequest(frame, requestOptions) {
-            validateRequestFrame(frame, maxBodyBytes);
+        async handleRequest(frame) {
+            validateRequestFrame(frame);
             const canonicalUrl = new URL(frame.url);
             const targetUrl = rewriteTargetUrl(targetBaseUrl, canonicalUrl);
             const headers = new Headers(frame.headers);
@@ -142,35 +47,20 @@ function createP2PDataPlaneHandler(options) {
             const response = await fetchImpl(targetUrl, {
                 method: frame.method,
                 headers,
-                body: methodCanHaveBody(frame.method) ? base64ToBody(frame.bodyBase64, maxBodyBytes) : undefined,
-                // Cancellation has to reach the upstream request, otherwise a cancelled client leaves
-                // the node fetching a body nobody will read (audit N17).
-                ...(requestOptions?.signal ? { signal: requestOptions.signal } : {}),
+                body: methodCanHaveBody(frame.method) ? base64ToBody(frame.bodyBase64) : undefined,
             });
-            const wantsStream = (frame.headers ?? [])
-                .some(([key, value]) => key.toLowerCase() === exports.XPOD_P2P_ACCEPT_HEADER && value === exports.XPOD_P2P_ACCEPT_CHUNKED);
-            if (wantsStream && response.body) {
-                return {
-                    protocol: exports.XPOD_P2P_HTTP_PROTOCOL,
-                    requestId: frame.requestId,
-                    status: response.status,
-                    statusText: response.statusText,
-                    headers: headersToList(response.headers),
-                    bodyStream: response.body,
-                };
-            }
             return {
                 protocol: exports.XPOD_P2P_HTTP_PROTOCOL,
                 requestId: frame.requestId,
                 status: response.status,
                 statusText: response.statusText,
                 headers: headersToList(response.headers),
-                bodyBase64: await responseToBase64(response, maxBodyBytes),
+                bodyBase64: await responseToBase64(response),
             };
         },
     };
 }
-function validateRequestFrame(frame, maxBodyBytes) {
+function validateRequestFrame(frame) {
     if (frame.protocol !== exports.XPOD_P2P_HTTP_PROTOCOL) {
         throw new Error(`Unsupported P2P HTTP protocol: ${String(frame.protocol)}`);
     }
@@ -183,30 +73,14 @@ function validateRequestFrame(frame, maxBodyBytes) {
     catch {
         throw new Error('P2P HTTP request URL must be absolute');
     }
-    // The client is expected to refuse oversized bodies itself; this is the side that must not
-    // trust it (audit N17).
-    if (frame.bodyBase64 !== undefined && base64ByteLength(frame.bodyBase64) > maxBodyBytes) {
-        throw new P2PDataPlaneLimitError(`P2P HTTP request body exceeds ${maxBodyBytes} bytes`, 'maxBodyBytes');
-    }
 }
-function validateResponseFrame(frame, maxBodyBytes) {
+function validateResponseFrame(frame) {
     if (frame.protocol !== exports.XPOD_P2P_HTTP_PROTOCOL) {
         throw new Error(`Unsupported P2P HTTP protocol: ${String(frame.protocol)}`);
     }
     if (!Number.isInteger(frame.status) || frame.status < 100 || frame.status > 599) {
         throw new Error(`Invalid P2P HTTP response status: ${String(frame.status)}`);
     }
-    if (frame.bodyBase64 !== undefined && base64ByteLength(frame.bodyBase64) > maxBodyBytes) {
-        throw new P2PDataPlaneLimitError(`P2P HTTP response body exceeds ${maxBodyBytes} bytes`, 'maxBodyBytes');
-    }
-}
-/** Decoded size of a base64 payload without allocating the buffer. */
-function base64ByteLength(value) {
-    if (value.length === 0) {
-        return 0;
-    }
-    const padding = value.endsWith('==') ? 2 : value.endsWith('=') ? 1 : 0;
-    return Math.floor((value.length * 3) / 4) - padding;
 }
 function rewriteTargetUrl(targetBase, canonicalUrl) {
     const basePath = targetBase.pathname.endsWith('/')
@@ -260,42 +134,27 @@ function methodCanHaveBody(method) {
     const normalized = method.toUpperCase();
     return normalized !== 'GET' && normalized !== 'HEAD';
 }
-async function bodyToBase64(request, maxBodyBytes) {
+async function bodyToBase64(request) {
     if (!methodCanHaveBody(request.method)) {
         return undefined;
     }
-    const declared = request.headers.get('content-length');
-    if (declared !== null && Number(declared) > maxBodyBytes) {
-        // Refuse before reading: buffering an oversized upload just to reject it is the failure
-        // mode this limit exists to prevent.
-        throw new P2PDataPlaneLimitError(`P2P HTTP request body exceeds ${maxBodyBytes} bytes`, 'maxBodyBytes');
-    }
     const body = await request.arrayBuffer();
-    if (body.byteLength > maxBodyBytes) {
-        throw new P2PDataPlaneLimitError(`P2P HTTP request body exceeds ${maxBodyBytes} bytes`, 'maxBodyBytes');
-    }
     if (body.byteLength === 0) {
         return undefined;
     }
     return Buffer.from(body).toString('base64');
 }
-async function responseToBase64(response, maxBodyBytes) {
+async function responseToBase64(response) {
     const body = await response.arrayBuffer();
-    if (body.byteLength > maxBodyBytes) {
-        throw new P2PDataPlaneLimitError(`P2P HTTP response body exceeds ${maxBodyBytes} bytes`, 'maxBodyBytes');
-    }
     if (body.byteLength === 0) {
         return undefined;
     }
     return Buffer.from(body).toString('base64');
 }
-function base64ToBody(value, maxBodyBytes) {
+function base64ToBody(value) {
     if (!value) {
         return undefined;
     }
-    if (base64ByteLength(value) > maxBodyBytes) {
-        throw new P2PDataPlaneLimitError(`P2P HTTP body exceeds ${maxBodyBytes} bytes`, 'maxBodyBytes');
-    }
     return Buffer.from(value, 'base64');
 }
 //# sourceMappingURL=P2PDataPlane.js.map

package/dist/edge/reachability/P2PDataPlane.jsonld

@@ -66,39 +66,6 @@
         {
           "@id": "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PHttpResponseFrame__member_bodyBase64",
           "memberFieldName": "bodyBase64"
-        },
-        {
-          "@id": "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PHttpResponseFrame__member_streamed",
-          "memberFieldName": "streamed"
-        },
-        {
-          "@id": "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PHttpResponseFrame__member_bodyStream",
-          "memberFieldName": "bodyStream"
-        }
-      ],
-      "constructorArguments": []
-    },
-    {
-      "@id": "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneRequestOptions",
-      "@type": "AbstractClass",
-      "requireElement": "P2PDataPlaneRequestOptions",
-      "parameters": [],
-      "memberFields": [
-        {
-          "@id": "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneRequestOptions__member_signal",
-          "memberFieldName": "signal"
-        },
-        {
-          "@id": "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneRequestOptions__member_onChunk",
-          "memberFieldName": "onChunk"
-        },
-        {
-          "@id": "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneRequestOptions__member_onEnd",
-          "memberFieldName": "onEnd"
-        },
-        {
-          "@id": "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneRequestOptions__member_onError",
-          "memberFieldName": "onError"
         }
       ],
       "constructorArguments": []
@@ -109,10 +76,6 @@
       "requireElement": "P2PDataPlaneTransport",
       "parameters": [],
       "memberFields": [
-        {
-          "@id": "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneTransport__member_supportsStreaming",
-          "memberFieldName": "supportsStreaming"
-        },
         {
           "@id": "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneTransport__member_request",
           "memberFieldName": "request"
@@ -120,34 +83,10 @@
       ],
       "constructorArguments": []
     },
-    {
-      "@id": "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneLimitsOptions",
-      "@type": "AbstractClass",
-      "requireElement": "P2PDataPlaneLimitsOptions",
-      "parameters": [],
-      "memberFields": [
-        {
-          "@id": "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneLimitsOptions__member_maxFrameBytes",
-          "memberFieldName": "maxFrameBytes"
-        },
-        {
-          "@id": "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneLimitsOptions__member_maxBodyBytes",
-          "memberFieldName": "maxBodyBytes"
-        },
-        {
-          "@id": "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneLimitsOptions__member_maxConcurrentRequests",
-          "memberFieldName": "maxConcurrentRequests"
-        }
-      ],
-      "constructorArguments": []
-    },
     {
       "@id": "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneFetchOptions",
       "@type": "AbstractClass",
       "requireElement": "P2PDataPlaneFetchOptions",
-      "extends": [
-        "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneLimitsOptions"
-      ],
       "parameters": [],
       "memberFields": [
         {
@@ -165,9 +104,6 @@
       "@id": "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneHandlerOptions",
       "@type": "AbstractClass",
       "requireElement": "P2PDataPlaneHandlerOptions",
-      "extends": [
-        "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneLimitsOptions"
-      ],
       "parameters": [],
       "memberFields": [
         {

package/dist/edge/reachability/P2PSignalingClient.d.ts

@@ -9,8 +9,6 @@ export interface CreateP2PSessionInput {
     clientId: string;
     capabilities?: string[];
     candidates?: P2PTransportCandidate[];
-    /** Per-session data plane secret; required for raw TCP sessions (audit N03). */
-    dataPlaneSecret?: string;
 }
 export interface P2PSignalingClient {
     createP2PSession(request: CreateP2PSessionInput): Promise<P2PSession>;

package/dist/edge/reachability/P2PSignalingClient.js

@@ -26,7 +26,6 @@ class HttpP2PSignalingClient {
                 clientId: request.clientId,
                 capabilities: request.capabilities ?? [],
                 candidates: request.candidates ?? [],
-                ...(request.dataPlaneSecret ? { dataPlaneSecret: request.dataPlaneSecret } : {}),
             },
         });
     }

package/dist/edge/reachability/P2PSignalingClient.jsonld

@@ -46,10 +46,6 @@
         {
           "@id": "undefineds:dist/edge/reachability/P2PSignalingClient.jsonld#CreateP2PSessionInput__member_candidates",
           "memberFieldName": "candidates"
-        },
-        {
-          "@id": "undefineds:dist/edge/reachability/P2PSignalingClient.jsonld#CreateP2PSessionInput__member_dataPlaneSecret",
-          "memberFieldName": "dataPlaneSecret"
         }
       ],
       "constructorArguments": []

package/dist/edge/reachability/ReachabilitySessionService.d.ts

@@ -29,37 +29,18 @@ export declare class ReachabilitySessionService {
     listP2PSessions(nodeId: string): Promise<P2PSessionList>;
     addP2PCandidates(nodeId: string, sessionId: string, request: P2PCandidateUpdateRequest): Promise<P2PSession>;
     createRelaySession(nodeId: string, request: RelaySessionRequest): Promise<RelaySession>;
-    /**
-     * Apply a metadata mutation without losing concurrent writes.
-     *
-     * Every reachability write lives inside the node's `metadata` blob, so the old
-     * read-modify-write pattern dropped whatever landed in between (audit N07). `mutate` is
-     * re-run against freshly read metadata on each attempt, which also re-runs the validations
-     * (session limits, expiry) against the state it is actually writing to.
-     */
-    private mutateNodeMetadata;
-    /**
-     * Fail closed for the raw TCP data plane: a session that announces that capability must carry
-     * a data-plane secret, otherwise the peer would be invited to speak in the clear (audit N03).
-     */
-    private resolveDataPlaneSecret;
     private loadNodeRouteSource;
     private readActiveP2PSessions;
     private p2pSessionLimits;
     private resolveP2PSessionLimits;
     private appendSession;
-    private readP2PSession;
     private loadP2PSession;
     private assertP2PSessionActive;
     private isP2PSessionActive;
     private normalizeP2PCandidates;
 }
-export declare class InvalidP2PSessionRequestError extends Error {
-}
 export declare class InvalidRelaySessionRequestError extends Error {
 }
-export declare class NodeMetadataConflictError extends Error {
-}
 export declare class NodeRouteSourceNotFoundError extends Error {
 }
 export declare class P2PActiveSessionLimitExceededError extends Error {