@undefineds.co/xpod 0.4.14 → 0.4.16

package/dist/edge/reachability/TcpP2PDataPlaneTransport.jsonld

@@ -4,10 +4,43 @@
   ],
   "@id": "npmd:@undefineds.co/xpod",
   "components": [
+    {
+      "@id": "undefineds:dist/edge/reachability/TcpP2PDataPlaneTransport.jsonld#P2PDataPlaneSecurityOptions",
+      "@type": "AbstractClass",
+      "requireElement": "P2PDataPlaneSecurityOptions",
+      "comment": "Data plane authentication (audit N03).  Both endpoints must configure the same per-session secret; it is only ever transported over the authenticated signaling API. Each side announces itself with a nonce, derives direction-separated keys, and then seals every frame. A peer without the secret cannot make the other side accept a frame, and a frame cannot be replayed into another session or direction.",
+      "parameters": [],
+      "memberFields": [
+        {
+          "@id": "undefineds:dist/edge/reachability/TcpP2PDataPlaneTransport.jsonld#P2PDataPlaneSecurityOptions__member_role",
+          "memberFieldName": "role"
+        },
+        {
+          "@id": "undefineds:dist/edge/reachability/TcpP2PDataPlaneTransport.jsonld#P2PDataPlaneSecurityOptions__member_sessionId",
+          "memberFieldName": "sessionId"
+        },
+        {
+          "@id": "undefineds:dist/edge/reachability/TcpP2PDataPlaneTransport.jsonld#P2PDataPlaneSecurityOptions__member_secret",
+          "memberFieldName": "secret"
+        },
+        {
+          "@id": "undefineds:dist/edge/reachability/TcpP2PDataPlaneTransport.jsonld#P2PDataPlaneSecurityOptions__member_resolveSessionSecret",
+          "memberFieldName": "resolveSessionSecret"
+        },
+        {
+          "@id": "undefineds:dist/edge/reachability/TcpP2PDataPlaneTransport.jsonld#P2PDataPlaneSecurityOptions__member_handshakeTimeoutMs",
+          "memberFieldName": "handshakeTimeoutMs"
+        }
+      ],
+      "constructorArguments": []
+    },
     {
       "@id": "undefineds:dist/edge/reachability/TcpP2PDataPlaneTransport.jsonld#TcpP2PDataPlaneTransportOptions",
       "@type": "AbstractClass",
       "requireElement": "TcpP2PDataPlaneTransportOptions",
+      "extends": [
+        "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneLimitsOptions"
+      ],
       "parameters": [],
       "memberFields": [
         {
@@ -29,6 +62,10 @@
         {
           "@id": "undefineds:dist/edge/reachability/TcpP2PDataPlaneTransport.jsonld#TcpP2PDataPlaneTransportOptions__member_randomId",
           "memberFieldName": "randomId"
+        },
+        {
+          "@id": "undefineds:dist/edge/reachability/TcpP2PDataPlaneTransport.jsonld#TcpP2PDataPlaneTransportOptions__member_secure",
+          "memberFieldName": "secure"
         }
       ],
       "constructorArguments": []
@@ -53,6 +90,9 @@
       "@id": "undefineds:dist/edge/reachability/TcpP2PDataPlaneTransport.jsonld#TcpP2PDataPlaneServerOptions",
       "@type": "AbstractClass",
       "requireElement": "TcpP2PDataPlaneServerOptions",
+      "extends": [
+        "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneLimitsOptions"
+      ],
       "parameters": [],
       "memberFields": [
         {
@@ -62,6 +102,10 @@
         {
           "@id": "undefineds:dist/edge/reachability/TcpP2PDataPlaneTransport.jsonld#TcpP2PDataPlaneServerOptions__member_host",
           "memberFieldName": "host"
+        },
+        {
+          "@id": "undefineds:dist/edge/reachability/TcpP2PDataPlaneTransport.jsonld#TcpP2PDataPlaneServerOptions__member_secure",
+          "memberFieldName": "secure"
         }
       ],
       "constructorArguments": []
@@ -91,6 +135,9 @@
       "@id": "undefineds:dist/edge/reachability/TcpP2PDataPlaneTransport.jsonld#TcpP2PDataPlaneSocketOptions",
       "@type": "AbstractClass",
       "requireElement": "TcpP2PDataPlaneSocketOptions",
+      "extends": [
+        "undefineds:dist/edge/reachability/P2PDataPlane.jsonld#P2PDataPlaneLimitsOptions"
+      ],
       "parameters": [],
       "memberFields": [
         {
@@ -100,6 +147,10 @@
         {
           "@id": "undefineds:dist/edge/reachability/TcpP2PDataPlaneTransport.jsonld#TcpP2PDataPlaneSocketOptions__member_handler",
           "memberFieldName": "handler"
+        },
+        {
+          "@id": "undefineds:dist/edge/reachability/TcpP2PDataPlaneTransport.jsonld#TcpP2PDataPlaneSocketOptions__member_secure",
+          "memberFieldName": "secure"
         }
       ],
       "constructorArguments": []

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

@@ -2,6 +2,7 @@ import { type Socket } from 'node:net';
 import type { AccessRoute, P2PCandidateRole, P2PSession, P2PTransportCandidate } from './types';
 import type { P2PSignalingClient } from './P2PSignalingClient';
 import type { P2PDataPlaneHandler } from './P2PDataPlane';
+import type { P2PDataPlaneSecurityOptions } from './TcpP2PDataPlaneTransport';
 import { type TcpP2PDataPlaneSocketHandle, type TcpP2PDataPlaneTransport, type TcpHolePunchPlan, type TcpHolePunchPlanOptions } from './TcpP2PDataPlaneTransport';
 export declare const RAW_TCP_HOLE_PUNCH_TRANSPORT: "raw-tcp-hole-punch";
 export declare const RAW_TCP_HOLE_PUNCH_CAPABILITY: "tcp-punch";
@@ -19,6 +20,8 @@ export interface CreateRawTcpHolePunchCandidatesOptions {
 export interface SignaledRawTcpP2PSessionOptions {
     signaling: P2PSignalingClient;
     clientId: string;
+    /** Overrides the generated per-session data plane secret (tests only). */
+    dataPlaneSecret?: string;
     host?: string;
     address?: string;
     capabilities?: string[];
@@ -33,6 +36,8 @@ export interface SignaledRawTcpP2PSession {
     plan: TcpHolePunchPlan;
     localCandidates: P2PTransportCandidate[];
     rawTcpRoute?: AccessRoute;
+    /** Secret both peers use to seal the data plane (audit N03). */
+    dataPlaneSecret: string;
 }
 export interface AnswerPendingRawTcpP2PSessionsOnceOptions {
     signaling: P2PSignalingClient;
@@ -53,6 +58,8 @@ export interface WaitForRawTcpRemoteCandidatesOptions {
     timeoutMs?: number;
 }
 export interface ConnectRawTcpP2PTransportOptions {
+    /** Data plane authentication; the signaled path always sets it (audit N03). */
+    secure?: P2PDataPlaneSecurityOptions;
     localCandidates: P2PTransportCandidate[];
     remoteCandidates: P2PTransportCandidate[];
     connectTimeoutMs?: number;

package/dist/edge/reachability/TcpP2PSignalingSession.js

@@ -13,6 +13,7 @@ exports.filterRawTcpRemoteCandidates = filterRawTcpRemoteCandidates;
 exports.selectRawTcpP2PRoute = selectRawTcpP2PRoute;
 exports.isRawTcpHolePunchCandidate = isRawTcpHolePunchCandidate;
 const node_net_1 = require("node:net");
+const P2PDataPlaneCrypto_1 = require("./P2PDataPlaneCrypto");
 const TcpP2PDataPlaneTransport_1 = require("./TcpP2PDataPlaneTransport");
 exports.RAW_TCP_HOLE_PUNCH_TRANSPORT = 'raw-tcp-hole-punch';
 exports.RAW_TCP_HOLE_PUNCH_CAPABILITY = 'tcp-punch';
@@ -61,6 +62,7 @@ async function createSignaledRawTcpP2PSession(options) {
         plan,
         candidateIdPrefix: options.candidateIdPrefix,
     });
+    const dataPlaneSecret = options.dataPlaneSecret ?? (0, P2PDataPlaneCrypto_1.createDataPlaneSecret)();
     const request = {
         clientId: options.clientId,
         capabilities: uniqueStrings([
@@ -68,6 +70,7 @@ async function createSignaledRawTcpP2PSession(options) {
             ...(options.capabilities ?? []),
         ]),
         candidates: localCandidates,
+        dataPlaneSecret,
     };
     const session = await options.signaling.createP2PSession(request);
     const effectiveLocalCandidates = localRawTcpCandidatesFromSessionOrFallback(session, localCandidates, 'client', options.clientId, plan.bucket);
@@ -76,6 +79,9 @@ async function createSignaledRawTcpP2PSession(options) {
         plan,
         localCandidates: effectiveLocalCandidates,
         rawTcpRoute: selectRawTcpP2PRoute(session.nodeCandidates),
+        // The API echoes the session back; a node that stripped the secret would otherwise let the
+        // client believe the plane is sealed while the node cannot open a single frame.
+        dataPlaneSecret: session.dataPlaneSecret ?? dataPlaneSecret,
     };
 }
 async function answerPendingRawTcpP2PSessionsOnce(options) {
@@ -159,7 +165,19 @@ async function acceptSignaledRawTcpP2PConnectionOnce(options) {
                 plan,
                 localCandidates: effectiveLocalCandidates,
                 remoteCandidates,
-                socketHandle: (0, TcpP2PDataPlaneTransport_1.attachTcpP2PDataPlaneSocket)({ socket, handler: options.handler }),
+                socketHandle: (0, TcpP2PDataPlaneTransport_1.attachTcpP2PDataPlaneSocket)({
+                    socket,
+                    handler: options.handler,
+                    ...(answeredSession.dataPlaneSecret
+                        ? {
+                            secure: {
+                                role: 'server',
+                                sessionId: answeredSession.sessionId,
+                                secret: answeredSession.dataPlaneSecret,
+                            },
+                        }
+                        : {}),
+                }),
             };
         }
         catch (error) {
@@ -208,6 +226,11 @@ async function connectSignaledRawTcpP2PTransport(options) {
         nowMs: options.nowMs,
         sleepMs: options.sleepMs,
         connectSocket: options.connectSocket,
+        secure: {
+            role: 'client',
+            sessionId: signaled.session.sessionId,
+            secret: signaled.dataPlaneSecret,
+        },
     });
     return {
         ...signaled,
@@ -222,6 +245,7 @@ async function connectRawTcpP2PTransport(options) {
         remotePort: attempt.remotePort,
         socket,
         timeoutMs: options.timeoutMs,
+        ...(options.secure ? { secure: options.secure } : {}),
     });
 }
 async function connectRawTcpP2PSocket(options) {

package/dist/edge/reachability/TcpP2PSignalingSession.jsonld

@@ -63,6 +63,10 @@
           "@id": "undefineds:dist/edge/reachability/TcpP2PSignalingSession.jsonld#SignaledRawTcpP2PSessionOptions__member_clientId",
           "memberFieldName": "clientId"
         },
+        {
+          "@id": "undefineds:dist/edge/reachability/TcpP2PSignalingSession.jsonld#SignaledRawTcpP2PSessionOptions__member_dataPlaneSecret",
+          "memberFieldName": "dataPlaneSecret"
+        },
         {
           "@id": "undefineds:dist/edge/reachability/TcpP2PSignalingSession.jsonld#SignaledRawTcpP2PSessionOptions__member_host",
           "memberFieldName": "host"
@@ -119,6 +123,10 @@
         {
           "@id": "undefineds:dist/edge/reachability/TcpP2PSignalingSession.jsonld#SignaledRawTcpP2PSession__member_rawTcpRoute",
           "memberFieldName": "rawTcpRoute"
+        },
+        {
+          "@id": "undefineds:dist/edge/reachability/TcpP2PSignalingSession.jsonld#SignaledRawTcpP2PSession__member_dataPlaneSecret",
+          "memberFieldName": "dataPlaneSecret"
         }
       ],
       "constructorArguments": []
@@ -203,6 +211,10 @@
       "requireElement": "ConnectRawTcpP2PTransportOptions",
       "parameters": [],
       "memberFields": [
+        {
+          "@id": "undefineds:dist/edge/reachability/TcpP2PSignalingSession.jsonld#ConnectRawTcpP2PTransportOptions__member_secure",
+          "memberFieldName": "secure"
+        },
         {
           "@id": "undefineds:dist/edge/reachability/TcpP2PSignalingSession.jsonld#ConnectRawTcpP2PTransportOptions__member_localCandidates",
           "memberFieldName": "localCandidates"

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

@@ -4,6 +4,7 @@ export * from './ReachabilitySessionService';
 export * from './ManagedRouteSelector';
 export * from './CanonicalFetch';
 export * from './P2PDataPlane';
+export * from './P2PDataPlaneCrypto';
 export * from './P2PSignalingClient';
 export * from './TcpP2PDataPlaneTransport';
 export * from './TcpP2PSignalingSession';

package/dist/edge/reachability/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./ReachabilitySessionService"), exports);
 __exportStar(require("./ManagedRouteSelector"), exports);
 __exportStar(require("./CanonicalFetch"), exports);
 __exportStar(require("./P2PDataPlane"), exports);
+__exportStar(require("./P2PDataPlaneCrypto"), exports);
 __exportStar(require("./P2PSignalingClient"), exports);
 __exportStar(require("./TcpP2PDataPlaneTransport"), exports);
 __exportStar(require("./TcpP2PSignalingSession"), exports);

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

@@ -3,7 +3,8 @@ export type AccessRouteVisibility = 'local-only' | 'same-account' | 'authorized-
 export type AccessRouteHealth = 'unknown' | 'healthy' | 'degraded' | 'unreachable';
 export interface AccessRoute {
     id: string;
-    nodeId: string;
+    /** Absent while the node has no identity yet, as on a standalone Local runtime. */
+    nodeId?: string;
     canonicalUrl: string;
     kind: AccessRouteKind;
     targetUrl: string;
@@ -21,7 +22,12 @@ export interface RouteSet {
     generatedAt: string;
     routes: AccessRoute[];
 }
-export type RouteAudience = 'public' | 'managed';
+/**
+ * Who is asking for routes. `local` is the node's own host, which is the only
+ * place a loopback access point means anything; `managed` is an authorized
+ * client elsewhere, and `public` is unauthenticated discovery.
+ */
+export type RouteAudience = 'public' | 'managed' | 'local';
 export interface BuildRouteSetSource {
     nodeId: string;
     canonicalUrl?: string;
@@ -45,6 +51,12 @@ export interface P2PSessionRequest {
     owner?: P2PSessionOwner;
     capabilities?: string[];
     candidates?: unknown[];
+    /**
+     * Base64 per-session secret for the data plane (audit N03). The creator generates it; the
+     * signaling API is the only channel that carries it, so a network peer that can reach the
+     * punched port still cannot read or forge frames.
+     */
+    dataPlaneSecret?: string;
 }
 export interface P2PSessionOwner {
     type: 'solid';
@@ -88,6 +100,8 @@ export interface P2PSession {
     capabilities: string[];
     candidates: P2PTransportCandidate[];
     limits?: P2PSessionLimits;
+    /** Present for data planes that authenticate and encrypt their frames (audit N03). */
+    dataPlaneSecret?: string;
 }
 export interface P2PSessionList {
     kind: 'p2p';

package/dist/edge/reachability/types.jsonld

@@ -181,6 +181,10 @@
         {
           "@id": "undefineds:dist/edge/reachability/types.jsonld#P2PSessionRequest__member_candidates",
           "memberFieldName": "candidates"
+        },
+        {
+          "@id": "undefineds:dist/edge/reachability/types.jsonld#P2PSessionRequest__member_dataPlaneSecret",
+          "memberFieldName": "dataPlaneSecret"
         }
       ],
       "constructorArguments": []
@@ -354,6 +358,10 @@
         {
           "@id": "undefineds:dist/edge/reachability/types.jsonld#P2PSession__member_limits",
           "memberFieldName": "limits"
+        },
+        {
+          "@id": "undefineds:dist/edge/reachability/types.jsonld#P2PSession__member_dataPlaneSecret",
+          "memberFieldName": "dataPlaneSecret"
         }
       ],
       "constructorArguments": []

package/dist/http/SubgraphSparqlHttpHandler.d.ts

@@ -1,5 +1,5 @@
 import { HttpHandler } from '@solid/community-server';
-import type { HttpHandlerInput, HttpRequest, HttpResponse } from '@solid/community-server';
+import type { HttpHandlerInput } from '@solid/community-server';
 import type { ActivityEmitter, CredentialsExtractor, PermissionReader, Authorizer } from '@solid/community-server';
 import { SubgraphQueryEngine } from '../storage/sparql/SubgraphQueryEngine';
 import { MixDataAccessor } from '../storage/accessors/MixDataAccessor';
@@ -14,22 +14,6 @@ interface SubgraphSparqlHttpHandlerOptions {
     usageDbUrl?: string;
     defaultAccountBandwidthLimitBps?: number | null;
 }
-export interface TrustedSubgraphSparqlHandler {
-    handleTrustedInternalSelect(input: {
-        ownerWebId: string;
-        endpointUrl: string;
-        query: string;
-        request: HttpRequest;
-        response: HttpResponse;
-    }): Promise<void>;
-    handleTrustedInternalUpdate(input: {
-        ownerWebId: string;
-        endpointUrl: string;
-        query: string;
-        request: HttpRequest;
-        response: HttpResponse;
-    }): Promise<void>;
-}
 export declare class SubgraphSparqlHttpHandler extends HttpHandler {
     protected readonly logger: import("global-logger-factory").Logger<unknown>;
     private readonly engine;
@@ -47,14 +31,6 @@ export declare class SubgraphSparqlHttpHandler extends HttpHandler {
     constructor(queryEngine: SubgraphQueryEngine, credentialsExtractor: CredentialsExtractor, permissionReader: PermissionReader, authorizer: Authorizer, options?: SubgraphSparqlHttpHandlerOptions, updateAuthority?: MixDataAccessor, emitter?: ActivityEmitter);
     canHandle({ request }: HttpHandlerInput): Promise<void>;
     handle({ request, response }: HttpHandlerInput): Promise<void>;
-    /**
-     * Execute the model collection SELECT after InternalPodDataHttpHandler has
-     * verified the signed owner intent. This is deliberately not reachable from
-     * the normal HTTP routing path and performs its own exact owner/endpoint
-     * validation before bypassing caller credentials.
-     */
-    handleTrustedInternalSelect(input: Parameters<TrustedSubgraphSparqlHandler['handleTrustedInternalSelect']>[0]): Promise<void>;
-    handleTrustedInternalUpdate(input: Parameters<TrustedSubgraphSparqlHandler['handleTrustedInternalUpdate']>[0]): Promise<void>;
     private sendErrorResponse;
     private acceptsJson;
     private executeSelect;

package/dist/http/SubgraphSparqlHttpHandler.js

@@ -14,7 +14,6 @@ const db_1 = require("../identity/drizzle/db");
 const PodLookupRepository_1 = require("../identity/drizzle/PodLookupRepository");
 const UsageRepository_1 = require("../storage/quota/UsageRepository");
 const BandwidthThrottleTransform_1 = require("../util/stream/BandwidthThrottleTransform");
-const AiConnectionsServiceAccess_1 = require("../api/ai-gateway/service-access/AiConnectionsServiceAccess");
 const ALLOWED_METHODS = ['GET', 'POST', 'OPTIONS'];
 const MODEL_COLLECTION_SUFFIX = '/settings/providers/-/sparql';
 const SETTINGS_COLLECTION_SUFFIX = '/settings/-/sparql';
@@ -141,64 +140,6 @@ class SubgraphSparqlHttpHandler extends community_server_1.HttpHandler {
             throw error;
         }
     }
-    /**
-     * Execute the model collection SELECT after InternalPodDataHttpHandler has
-     * verified the signed owner intent. This is deliberately not reachable from
-     * the normal HTTP routing path and performs its own exact owner/endpoint
-     * validation before bypassing caller credentials.
-     */
-    async handleTrustedInternalSelect(input) {
-        const target = trustedSelectTarget(input.ownerWebId, input.endpointUrl);
-        if (!target) {
-            throw new community_server_2.BadRequestHttpError('Trusted SPARQL endpoint is outside the owner Pod.');
-        }
-        const query = input.query.trim();
-        if (!query || (target.query && query !== target.query)) {
-            throw new community_server_2.BadRequestHttpError('A trusted SPARQL query is required.');
-        }
-        const parsed = new sparqljs_1.Parser({ baseIRI: target.baseUrl }).parse(query);
-        if (parsed.type !== 'query' || parsed.queryType !== 'SELECT') {
-            throw new community_server_2.BadRequestHttpError('Trusted SPARQL access only supports SELECT queries.');
-        }
-        const context = await this.resolveUsageContext(target.basePath);
-        await this.recordBandwidth(context, Buffer.byteLength(query, 'utf8'), 0);
-        await this.executeSelect(input.request, {
-            basePath: target.basePath,
-            baseUrl: target.baseUrl,
-            ...(target.sourceUri === undefined ? {} : { sourceUri: target.sourceUri }),
-            defaultDataset: target.defaultDataset,
-            query,
-            origin: target.origin,
-            method: 'GET',
-            ingressBytes: Buffer.byteLength(query, 'utf8'),
-        }, input.response, context, true);
-    }
-    async handleTrustedInternalUpdate(input) {
-        const target = trustedSettingsCollectionTarget(input.ownerWebId, input.endpointUrl, false);
-        if (!target) {
-            throw new community_server_2.BadRequestHttpError('Trusted settings update endpoint is outside the owner Pod.');
-        }
-        const query = input.query.trim();
-        if (!query) {
-            throw new community_server_2.BadRequestHttpError('A trusted settings update is required.');
-        }
-        const parsed = new sparqljs_1.Parser({ baseIRI: target.baseUrl }).parse(query);
-        if (parsed.type !== 'update') {
-            throw new community_server_2.BadRequestHttpError('Trusted settings access only supports UPDATE operations.');
-        }
-        const context = await this.resolveUsageContext(target.basePath);
-        const ingressBytes = Buffer.byteLength(query, 'utf8');
-        await this.recordBandwidth(context, ingressBytes, 0);
-        await this.executeUpdate({
-            basePath: target.basePath,
-            baseUrl: target.baseUrl,
-            defaultDataset: target.defaultDataset,
-            query,
-            origin: target.origin,
-            method: 'POST',
-            ingressBytes,
-        }, parsed, input.request, input.response, context, true);
-    }
     sendErrorResponse(request, response, statusCode, message, jsonPayload) {
         response.statusCode = statusCode;
         if (this.acceptsJson(request)) {
@@ -1127,47 +1068,6 @@ class SubgraphSparqlHttpHandler extends community_server_1.HttpHandler {
 }
 exports.SubgraphSparqlHttpHandler = SubgraphSparqlHttpHandler;
 SubgraphSparqlHttpHandler.XSD_STRING = 'http://www.w3.org/2001/XMLSchema#string';
-function trustedSelectTarget(ownerWebId, endpointUrl) {
-    return trustedGatewayAccessKeyDocumentTarget(ownerWebId, endpointUrl) ??
-        trustedModelCollectionTarget(ownerWebId, endpointUrl) ??
-        trustedSettingsCollectionTarget(ownerWebId, endpointUrl, true);
-}
-function trustedGatewayAccessKeyDocumentTarget(ownerWebId, endpointUrl) {
-    let owner;
-    let endpoint;
-    try {
-        owner = new URL(ownerWebId);
-        endpoint = new URL(endpointUrl);
-    }
-    catch {
-        return undefined;
-    }
-    if ((owner.protocol !== 'http:' && owner.protocol !== 'https:') ||
-        owner.hash !== '#me' || !owner.pathname.endsWith('/profile/card') ||
-        endpoint.username || endpoint.password || endpoint.hash ||
-        !(0, AiConnectionsServiceAccess_1.isGatewayAccessKeySparqlEndpoint)(ownerWebId, endpoint)) {
-        return undefined;
-    }
-    const keys = Array.from(endpoint.searchParams.keys());
-    if (keys.length > 0 && (keys.length !== 1 || keys[0] !== 'query' || !endpoint.searchParams.get('query')?.trim())) {
-        return undefined;
-    }
-    const basePath = endpoint.pathname.slice(0, -'/-/sparql'.length);
-    return {
-        basePath,
-        baseUrl: `${endpoint.origin}${basePath}`,
-        sourceUri: `${endpoint.origin}${basePath}`,
-        defaultDataset: 'exactSource',
-        origin: endpoint.origin,
-        query: endpoint.searchParams.get('query')?.trim() ?? '',
-    };
-}
-function trustedModelCollectionTarget(ownerWebId, endpointUrl) {
-    return trustedCollectionTarget(ownerWebId, endpointUrl, MODEL_COLLECTION_SUFFIX, true);
-}
-function trustedSettingsCollectionTarget(ownerWebId, endpointUrl, allowQuery) {
-    return trustedCollectionTarget(ownerWebId, endpointUrl, SETTINGS_COLLECTION_SUFFIX, allowQuery);
-}
 function trustedCollectionTarget(ownerWebId, endpointUrl, suffix, allowQuery) {
     let owner;
     let endpoint;

package/dist/http/SubgraphSparqlHttpHandler.jsonld

@@ -200,14 +200,6 @@
           "@id": "undefineds:dist/http/SubgraphSparqlHttpHandler.jsonld#SubgraphSparqlHttpHandler__member_handle",
           "memberFieldName": "handle"
         },
-        {
-          "@id": "undefineds:dist/http/SubgraphSparqlHttpHandler.jsonld#SubgraphSparqlHttpHandler__member_handleTrustedInternalSelect",
-          "memberFieldName": "handleTrustedInternalSelect"
-        },
-        {
-          "@id": "undefineds:dist/http/SubgraphSparqlHttpHandler.jsonld#SubgraphSparqlHttpHandler__member_handleTrustedInternalUpdate",
-          "memberFieldName": "handleTrustedInternalUpdate"
-        },
         {
           "@id": "undefineds:dist/http/SubgraphSparqlHttpHandler.jsonld#SubgraphSparqlHttpHandler__member_sendErrorResponse",
           "memberFieldName": "sendErrorResponse"

package/dist/identity/drizzle/EdgeNodeRepository.d.ts

@@ -72,6 +72,18 @@ export declare class EdgeNodeRepository {
         lastConnectivityCheck?: Date;
     } | undefined>;
     mergeNodeMetadata(nodeId: string, patch: Record<string, unknown>): Promise<void>;
+    /**
+     * Compare-and-swap on the whole `metadata` blob.
+     *
+     * Reachability state (sessions, candidates) lives inside that blob, so a read-modify-write
+     * silently drops whatever another writer committed in between — the lost update the audit
+     * calls out as N07. This write only lands when the stored value is still the one the caller
+     * read; `false` means somebody else won and the caller must re-read and re-apply.
+     *
+     * The comparison is on the serialized payload. Two equivalent-but-differently-ordered
+     * payloads therefore fail the swap, which costs a retry but can never lose a write.
+     */
+    updateNodeMetadataAtomic(nodeId: string, expected: Record<string, unknown> | null, next: Record<string, unknown>): Promise<boolean>;
     getNodeMetadata(nodeId: string): Promise<{
         nodeId: string;
         metadata: Record<string, unknown> | null;

package/dist/identity/drizzle/EdgeNodeRepository.js

@@ -152,6 +152,43 @@ class EdgeNodeRepository {
       WHERE id = ${nodeId}
     `);
     }
+    /**
+     * Compare-and-swap on the whole `metadata` blob.
+     *
+     * Reachability state (sessions, candidates) lives inside that blob, so a read-modify-write
+     * silently drops whatever another writer committed in between — the lost update the audit
+     * calls out as N07. This write only lands when the stored value is still the one the caller
+     * read; `false` means somebody else won and the caller must re-read and re-apply.
+     *
+     * The comparison is on the serialized payload. Two equivalent-but-differently-ordered
+     * payloads therefore fail the swap, which costs a retry but can never lose a write.
+     */
+    async updateNodeMetadataAtomic(nodeId, expected, next) {
+        await this.ready;
+        const payload = JSON.stringify(next);
+        const expectedPayload = expected === null ? null : JSON.stringify(expected);
+        const ts = (0, db_1.toDbTimestamp)(this.db, new Date());
+        const changed = await (0, db_1.executeStatementWithCount)(this.db, expectedPayload === null
+            ? (0, drizzle_orm_1.sql) `
+          UPDATE cluster_node
+          SET metadata = ${payload},
+              updated_at = ${ts}
+          WHERE id = ${nodeId} AND metadata IS NULL
+        `
+            : (0, drizzle_orm_1.sql) `
+          UPDATE cluster_node
+          SET metadata = ${payload},
+              updated_at = ${ts}
+          WHERE id = ${nodeId} AND metadata = ${expectedPayload}
+        `);
+        if (typeof changed === 'number') {
+            return changed > 0;
+        }
+        // A driver that reports no row count cannot answer "did my write land": verify instead of
+        // assuming, so a lost race is retried rather than reported as success.
+        const stored = await this.getNodeMetadata(nodeId);
+        return JSON.stringify(stored?.metadata ?? null) === payload;
+    }
     async getNodeMetadata(nodeId) {
         await this.ready;
         const result = await (0, db_1.executeQuery)(this.db, (0, drizzle_orm_1.sql) `

package/dist/identity/drizzle/PodInterfaceKeyRepository.d.ts

@@ -0,0 +1,36 @@
+import type { IdentityDatabase } from './db';
+/**
+ * The interface access key a Pod grants its owner's server-side components.
+ *
+ * It is an ordinary Pod credential - the same kind a browser holds - so the server reaches the
+ * Pod through the standard interface as that user. The ciphertext lives here rather than in the
+ * Pod, because this key is what opens the Pod.
+ */
+export interface PodInterfaceKeyRecord {
+    ownerWebId: string;
+    clientId: string;
+    /** Vault-sealed JSON `{ clientSecret }`. */
+    sealedSecret: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface PodInterfaceKeyRepositoryPort {
+    read(ownerWebId: string): Promise<PodInterfaceKeyRecord | undefined>;
+    /** Every stored row, for the one-shot migration into the task layer. */
+    list(): Promise<PodInterfaceKeyRecord[]>;
+    write(record: Omit<PodInterfaceKeyRecord, 'createdAt' | 'updatedAt'>): Promise<void>;
+    remove(ownerWebId: string): Promise<void>;
+}
+export declare class PodInterfaceKeyRepository implements PodInterfaceKeyRepositoryPort {
+    private readonly db;
+    private readonly logger;
+    private readonly schema;
+    private readonly ready;
+    private initError?;
+    constructor(db: IdentityDatabase);
+    read(ownerWebId: string): Promise<PodInterfaceKeyRecord | undefined>;
+    list(): Promise<PodInterfaceKeyRecord[]>;
+    write(record: Omit<PodInterfaceKeyRecord, 'createdAt' | 'updatedAt'>): Promise<void>;
+    remove(ownerWebId: string): Promise<void>;
+    private ensureReady;
+}