@undefineds.co/xpod 0.4.20 → 0.4.25

package/dist/service/PodDeletionLifecycleService.jsonld

@@ -0,0 +1,210 @@
+{
+  "@context": [
+    "https://linkedsoftwaredependencies.org/bundles/npm/@undefineds.co/xpod/^0.0.0/components/context.jsonld",
+    "https://linkedsoftwaredependencies.org/bundles/npm/@solid/community-server/^8.0.0/components/context.jsonld"
+  ],
+  "@id": "npmd:@undefineds.co/xpod",
+  "components": [
+    {
+      "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService",
+      "@type": "Class",
+      "requireElement": "PodDeletionLifecycleService",
+      "comment": "Owns account metadata only after the complete Pod data deletion succeeds.",
+      "parameters": [
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService_options_podStore",
+          "range": "css:dist/identity/interaction/pod/util/PodStore.jsonld#PodStore"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService_options_accountStorage",
+          "range": {
+            "@type": "ParameterRangeGenericComponent",
+            "component": "css:dist/storage/keyvalue/IndexedStorage.jsonld#IndexedStorage",
+            "genericTypeInstances": [
+              {
+                "@type": "ParameterRangeWildcard"
+              }
+            ]
+          }
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService_options_dataDeletion",
+          "range": "undefineds:dist/service/PodDataDeletionService.jsonld#PodDataDeletionService"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService_options_identityDbUrl",
+          "range": "xsd:string"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService_options_storageBaseUrl",
+          "range": "xsd:string"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService_options_edition",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              "xsd:string",
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          }
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService_options_resourceLocker",
+          "range": "css:dist/util/locking/ExpiringReadWriteLocker.jsonld#ExpiringReadWriteLocker"
+        }
+      ],
+      "memberFields": [
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService__member_options",
+          "memberFieldName": "options"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService__member_operations",
+          "memberFieldName": "operations",
+          "range": "undefineds:dist/identity/drizzle/PodDeletionOperationRepository.jsonld#PodDeletionOperationRepository"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService__member_nodes",
+          "memberFieldName": "nodes"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService__member_root",
+          "memberFieldName": "root"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService__member_active",
+          "memberFieldName": "active"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService__member_constructor",
+          "memberFieldName": "constructor"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService__member_whileCreating",
+          "memberFieldName": "whileCreating"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService__member_canDelete",
+          "memberFieldName": "canDelete"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService__member_canAuthorizeDeletion",
+          "memberFieldName": "canAuthorizeDeletion"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService__member_requestDeletionAuthorization",
+          "memberFieldName": "requestDeletionAuthorization"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService__member_deleteOwned",
+          "memberFieldName": "deleteOwned"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService__member_deleteLocal",
+          "memberFieldName": "deleteLocal"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService__member_runLocal",
+          "memberFieldName": "runLocal"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService__member_removeMetadata",
+          "memberFieldName": "removeMetadata"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService__member_isLocal",
+          "memberFieldName": "isLocal"
+        }
+      ],
+      "constructorArguments": [
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService_options__constructorArgument",
+          "fields": [
+            {
+              "keyRaw": "podStore",
+              "value": {
+                "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService_options_podStore"
+              }
+            },
+            {
+              "keyRaw": "accountStorage",
+              "value": {
+                "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService_options_accountStorage"
+              }
+            },
+            {
+              "keyRaw": "dataDeletion",
+              "value": {
+                "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService_options_dataDeletion"
+              }
+            },
+            {
+              "keyRaw": "identityDbUrl",
+              "value": {
+                "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService_options_identityDbUrl"
+              }
+            },
+            {
+              "keyRaw": "storageBaseUrl",
+              "value": {
+                "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService_options_storageBaseUrl"
+              }
+            },
+            {
+              "keyRaw": "edition",
+              "value": {
+                "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService_options_edition"
+              }
+            },
+            {
+              "keyRaw": "resourceLocker",
+              "value": {
+                "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleService_options_resourceLocker"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleOptions",
+      "@type": "AbstractClass",
+      "requireElement": "PodDeletionLifecycleOptions",
+      "parameters": [],
+      "memberFields": [
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleOptions__member_podStore",
+          "memberFieldName": "podStore"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleOptions__member_accountStorage",
+          "memberFieldName": "accountStorage"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleOptions__member_dataDeletion",
+          "memberFieldName": "dataDeletion"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleOptions__member_identityDbUrl",
+          "memberFieldName": "identityDbUrl"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleOptions__member_storageBaseUrl",
+          "memberFieldName": "storageBaseUrl"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleOptions__member_edition",
+          "memberFieldName": "edition"
+        },
+        {
+          "@id": "undefineds:dist/service/PodDeletionLifecycleService.jsonld#PodDeletionLifecycleOptions__member_resourceLocker",
+          "memberFieldName": "resourceLocker"
+        }
+      ],
+      "constructorArguments": []
+    }
+  ]
+}

package/dist/shared/xpod-route-policy.d.ts

@@ -1,7 +1,9 @@
 /** Application routes that may be restored after the one Xpod login transaction. */
-export declare const XPOD_RETURN_PATH_PREFIXES: readonly ["/dashboard", "/status", "/network", "/settings", "/ai-config", "/ai-connections"];
+export declare const XPOD_RETURN_PATH_PREFIXES: readonly ["/dashboard", "/status", "/network", "/settings", "/ai-config", "/ai-connections", "/tasks", "/pod", "/device", "/inbox", "/notifications"];
 export declare const XPOD_PRODUCT_ALIASES: {};
 export type XpodProductAlias = keyof typeof XPOD_PRODUCT_ALIASES;
+/** New applet names must not reserve every resource inside a same-named Pod. */
+export declare function isXpodProductPath(pathname: string): boolean;
 /**
  * Keep API aliases and the client callback on the same application-relative path policy.
  * Query strings are intentionally retained; fragments are not part of an HTTP request URL.

package/dist/shared/xpod-route-policy.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XPOD_PRODUCT_ALIASES = exports.XPOD_RETURN_PATH_PREFIXES = void 0;
+exports.isXpodProductPath = isXpodProductPath;
 exports.normalizeXpodReturnPath = normalizeXpodReturnPath;
 exports.resolveXpodAliasTarget = resolveXpodAliasTarget;
 /** Application routes that may be restored after the one Xpod login transaction. */
@@ -11,8 +12,25 @@ exports.XPOD_RETURN_PATH_PREFIXES = [
     '/settings',
     '/ai-config',
     '/ai-connections',
+    '/tasks',
+    '/pod',
+    '/device',
+    '/inbox',
+    '/notifications',
 ];
 exports.XPOD_PRODUCT_ALIASES = {};
+const desktopPages = new Set([
+    '/tasks', '/pod', '/pod/models', '/pod/search', '/pod/apps', '/pod/data',
+    '/device', '/device/network', '/device/services', '/device/runtime', '/device/logs',
+    '/inbox', '/notifications',
+]);
+/** New applet names must not reserve every resource inside a same-named Pod. */
+function isXpodProductPath(pathname) {
+    const path = pathname.replace(/\/$/u, '');
+    if (desktopPages.has(path))
+        return true;
+    return exports.XPOD_RETURN_PATH_PREFIXES.slice(0, 6).some(prefix => path === prefix || path.startsWith(`${prefix}/`));
+}
 /**
  * Keep API aliases and the client callback on the same application-relative path policy.
  * Query strings are intentionally retained; fragments are not part of an HTTP request URL.
@@ -33,7 +51,7 @@ function normalizeXpodReturnPath(value) {
         || /^[a-z][a-z\d+.-]*:/i.test(decoded)
         || decoded.startsWith('//')
         || pathname.split('/').some((segment) => segment === '..')
-        || !exports.XPOD_RETURN_PATH_PREFIXES.some((prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`))) {
+        || !isXpodProductPath(pathname)) {
         throw new TypeError('returnTo must be a safe path within the application allow-list');
     }
     return normalized;

package/dist/solidfs/LocalRdfAuthorityRecoveryInitializer.js

@@ -22,7 +22,7 @@ class LocalRdfAuthorityRecoveryInitializer extends community_server_1.Initialize
     }
     async handle() {
         const root = node_path_1.default.resolve(this.rootFilePath);
-        const syncer = new RdfIndexSolidFsSyncer_1.RdfIndexSolidFsSyncer({ index: this.index });
+        const syncer = new RdfIndexSolidFsSyncer_1.RdfIndexSolidFsSyncer({ index: this.index, rdfSourceMode: 'authority' });
         await this.journal.bootstrapWorkspace({
             workspace: this.baseUrl,
             cwd: root,

package/dist/solidfs/PodSolidFsHttpClient.d.ts

@@ -1,16 +1,16 @@
 import type { SolidAuthContext } from '../api/auth/AuthContext';
+import type { PodAccessFetchProvider } from '../api/ai-gateway/pod/OwnerPodAccess';
 import type { SolidFsManifest } from './types';
 export interface PodSolidFsHttpClientOptions {
     fetch?: typeof fetch;
-    tokenEndpoint?: string;
+    /** The host's shared, owner-bound authenticated Pod transport. */
+    podAccess?: PodAccessFetchProvider;
 }
 export declare class PodSolidFsHttpClient {
+    private readonly options;
     private readonly fetchImpl;
-    private readonly tokenEndpoint?;
     constructor(options?: PodSolidFsHttpClientOptions);
-    request(input: string, init: RequestInit): Promise<Response>;
-    createAuthHeaders(context: unknown, operation: string): Promise<Headers>;
-    private exchangeClientCredentials;
+    request(input: string, init: RequestInit, context: unknown): Promise<Response>;
 }
 export declare function resolvePodWorkspaceResourceUrl(relativePath: string, workspace: SolidFsManifest): string | undefined;
 export declare function solidAuthFromContext(context: unknown): SolidAuthContext | undefined;

package/dist/solidfs/PodSolidFsHttpClient.js

@@ -4,57 +4,25 @@ exports.PodSolidFsHttpClient = void 0;
 exports.resolvePodWorkspaceResourceUrl = resolvePodWorkspaceResourceUrl;
 exports.solidAuthFromContext = solidAuthFromContext;
 const AuthContext_1 = require("../api/auth/AuthContext");
+const CallerPodAccess_1 = require("../api/ai-gateway/auth/CallerPodAccess");
 class PodSolidFsHttpClient {
     constructor(options = {}) {
+        this.options = options;
         this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
-        this.tokenEndpoint = options.tokenEndpoint ?? resolveDefaultTokenEndpoint();
     }
-    async request(input, init) {
-        return this.fetchImpl(input, init);
-    }
-    async createAuthHeaders(context, operation) {
+    async request(input, init, context) {
         const auth = solidAuthFromContext(context);
-        if (!auth) {
-            throw new Error(`Cannot ${operation} without Solid auth context`);
-        }
-        const headers = new Headers();
-        if (auth.accessToken) {
-            headers.set('Authorization', `${auth.tokenType ?? 'Bearer'} ${auth.accessToken}`);
-            return headers;
-        }
-        const token = await this.exchangeClientCredentials(auth);
-        headers.set('Authorization', `${token.tokenType ?? 'Bearer'} ${token.accessToken}`);
-        return headers;
-    }
-    async exchangeClientCredentials(auth) {
-        if (!this.tokenEndpoint) {
-            throw new Error('Cannot access Pod HTTP resource with client credentials because CSS token endpoint is not configured');
-        }
-        if (!auth.clientId || !auth.clientSecret) {
-            throw new Error('Cannot access Pod HTTP resource without access token or Solid client credentials');
-        }
-        const response = await this.request(this.tokenEndpoint, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
-            },
-            body: new URLSearchParams({
-                grant_type: 'client_credentials',
-                client_id: auth.clientId,
-                client_secret: auth.clientSecret,
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`SolidFS token exchange failed: ${response.status} ${await response.text().catch(() => '')}`);
-        }
-        const token = await response.json();
-        if (!token.access_token) {
-            throw new Error(`SolidFS token exchange response missing access_token: ${JSON.stringify(token)}`);
-        }
-        return {
-            accessToken: token.access_token,
-            tokenType: token.token_type?.toUpperCase() === 'DPOP' ? 'DPoP' : 'Bearer',
-        };
+        if (!auth)
+            throw new Error('SolidFS Pod access requires an authenticated owner');
+        const taskCredential = context.taskCredential;
+        const authenticated = this.options.podAccess
+            ? await this.options.podAccess.getPodFetch(auth.webId, { auth, ...(taskCredential ? { taskCredential } : {}) })
+            : !taskCredential ? (0, CallerPodAccess_1.createCallerAuthenticatedPodFetch)(auth.webId, auth, this.fetchImpl) : undefined;
+        if (!authenticated)
+            throw new Error('SolidFS Pod access is unavailable');
+        // The shared provider signs DPoP and checks grant validity per request. A rejected write
+        // is returned once; copying a token header or replaying with a refreshed token is unsafe.
+        return authenticated(input, init);
     }
 }
 exports.PodSolidFsHttpClient = PodSolidFsHttpClient;
@@ -81,13 +49,4 @@ function normalizePodRelativePath(input) {
     }
     return parts.join('/');
 }
-function resolveDefaultTokenEndpoint() {
-    if (process.env.CSS_TOKEN_ENDPOINT) {
-        return process.env.CSS_TOKEN_ENDPOINT;
-    }
-    if (process.env.CSS_BASE_URL) {
-        return new URL('.oidc/token', process.env.CSS_BASE_URL.endsWith('/') ? process.env.CSS_BASE_URL : `${process.env.CSS_BASE_URL}/`).href;
-    }
-    return undefined;
-}
 //# sourceMappingURL=PodSolidFsHttpClient.js.map

package/dist/solidfs/PodSolidFsHydrator.d.ts

@@ -1,8 +1,6 @@
 import { type SolidFsCommitHydratedInput, type SolidFsHydrateInput, type SolidFsHydrator } from './types';
-export interface PodSolidFsHydratorOptions {
-    fetch?: typeof fetch;
-    tokenEndpoint?: string;
-}
+import { type PodSolidFsHttpClientOptions } from './PodSolidFsHttpClient';
+export type PodSolidFsHydratorOptions = PodSolidFsHttpClientOptions;
 /**
  * Hydrates object-backed Pod resources through the normal Pod HTTP boundary.
  *

package/dist/solidfs/PodSolidFsHydrator.js

@@ -23,11 +23,11 @@ class PodSolidFsHydrator {
     }
     async hydrate(input) {
         const resourceUrl = this.resolveResourceUrl(input.path, input.workspace);
-        const headers = await this.http.createAuthHeaders(input.context, `hydrate SolidFS object: ${resourceUrl}`);
+        const headers = new Headers();
         const response = await this.http.request(resourceUrl, {
             method: 'GET',
             headers,
-        });
+        }, input.context);
         if (response.status === 404) {
             throw new types_1.SolidFsNotFoundError(`SolidFS object not found: ${resourceUrl}`);
         }
@@ -46,7 +46,7 @@ class PodSolidFsHydrator {
     }
     async commit(input) {
         const resourceUrl = this.resolveChangeResourceUrl(input);
-        const headers = await this.http.createAuthHeaders(input.context, `commit SolidFS object: ${resourceUrl}`);
+        const headers = new Headers();
         if (input.change.contentType) {
             headers.set('Content-Type', input.change.contentType);
         }
@@ -58,7 +58,7 @@ class PodSolidFsHydrator {
             headers,
             body: (0, node_fs_1.createReadStream)(input.change.sourcePath),
             duplex: 'half',
-        });
+        }, input.context);
         if (response.status === 409 || response.status === 412) {
             throw new types_1.SolidFsConflictError([{
                     path: input.change.path,
@@ -77,14 +77,14 @@ class PodSolidFsHydrator {
     }
     async delete(input) {
         const resourceUrl = this.resolveChangeResourceUrl(input);
-        const headers = await this.http.createAuthHeaders(input.context, `delete SolidFS object: ${resourceUrl}`);
+        const headers = new Headers();
         if (input.change.sourceVersion) {
             headers.set('If-Match', input.change.sourceVersion);
         }
         const response = await this.http.request(resourceUrl, {
             method: 'DELETE',
             headers,
-        });
+        }, input.context);
         if (response.status === 409 || response.status === 412) {
             throw new types_1.SolidFsConflictError([{
                     path: input.change.path,

package/dist/solidfs/PodSolidFsSyncer.d.ts

@@ -1,14 +1,16 @@
 import type { SolidFsChange, SolidFsManifest, SolidFsSyncer } from './types';
-export interface PodSolidFsSyncerOptions {
-    fetch?: typeof fetch;
-    tokenEndpoint?: string;
-}
+import { type PodSolidFsHttpClientOptions } from './PodSolidFsHttpClient';
+export type PodSolidFsSyncerOptions = PodSolidFsHttpClientOptions;
 /**
- * Writes SolidFS RDF file changes back through the Pod HTTP surface.
+ * Writes SolidFS file changes back through the Pod HTTP surface.
  *
- * The CSS/MixDataAccessor path remains responsible for parsing RDF documents
- * into the structured RDF index. This adapter only bridges runtime workspace
- * edits back to the Pod resource URL with the caller's stored auth context.
+ * RDF documents still flow through the CSS/MixDataAccessor path, which parses
+ * them into the structured RDF index. Non-RDF (text/binary) workspace edits are
+ * sent as byte-buffered payloads to the same Pod resource URL with the caller's
+ * stored auth context; otherwise the journal would mark an upload done while the
+ * Pod never received the bytes and the resource stayed missing. (A Node
+ * ReadStream body is rejected with an empty HTTP 400 at this boundary, so the
+ * file bytes are buffered before the PUT.)
  */
 export declare class PodSolidFsSyncer implements SolidFsSyncer {
     private readonly http;

package/dist/solidfs/PodSolidFsSyncer.js

@@ -2,15 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PodSolidFsSyncer = void 0;
 exports.resolvePodResourceUrl = resolvePodResourceUrl;
-const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
 const RdfContentTypes_1 = require("../storage/rdf/RdfContentTypes");
 const PodSolidFsHttpClient_1 = require("./PodSolidFsHttpClient");
 /**
- * Writes SolidFS RDF file changes back through the Pod HTTP surface.
+ * Writes SolidFS file changes back through the Pod HTTP surface.
  *
- * The CSS/MixDataAccessor path remains responsible for parsing RDF documents
- * into the structured RDF index. This adapter only bridges runtime workspace
- * edits back to the Pod resource URL with the caller's stored auth context.
+ * RDF documents still flow through the CSS/MixDataAccessor path, which parses
+ * them into the structured RDF index. Non-RDF (text/binary) workspace edits are
+ * sent as byte-buffered payloads to the same Pod resource URL with the caller's
+ * stored auth context; otherwise the journal would mark an upload done while the
+ * Pod never received the bytes and the resource stayed missing. (A Node
+ * ReadStream body is rejected with an empty HTTP 400 at this boundary, so the
+ * file bytes are buffered before the PUT.)
  */
 class PodSolidFsSyncer {
     constructor(options = {}) {
@@ -26,33 +30,33 @@ class PodSolidFsSyncer {
         }
     }
     async sync(change, workspace, context) {
-        if (!isRdfChange(change)) {
-            return;
-        }
         const resourceUrl = resolvePodResourceUrl(change, workspace);
         if (!resourceUrl) {
             return;
         }
-        const headers = await this.http.createAuthHeaders(context, `sync SolidFS RDF change: ${resourceUrl}`);
+        const headers = new Headers();
         if (change.type === 'deleted') {
             const response = await this.http.request(resourceUrl, {
                 method: 'DELETE',
                 headers,
-            });
+            }, context);
             if (!response.ok && response.status !== 404) {
-                throw new Error(`SolidFS RDF delete sync failed for ${resourceUrl}: ${response.status} ${await response.text().catch(() => '')}`);
+                throw new Error(`SolidFS delete sync failed for ${resourceUrl}: ${response.status} ${await response.text().catch(() => '')}`);
             }
             return;
         }
-        headers.set('Content-Type', change.contentType ?? 'text/turtle');
+        const isRdf = isRdfChange(change);
+        headers.set('Content-Type', change.contentType ?? (isRdf ? 'text/turtle' : 'application/octet-stream'));
+        // The Pod HTTP boundary rejects a Node ReadStream body with an empty 400, which the
+        // journal then records as failed and the resource never lands. Send the file bytes.
+        const body = await (0, promises_1.readFile)(change.sourcePath);
         const response = await this.http.request(resourceUrl, {
             method: 'PUT',
             headers,
-            body: (0, node_fs_1.createReadStream)(change.sourcePath),
-            duplex: 'half',
-        });
+            body,
+        }, context);
         if (!response.ok) {
-            throw new Error(`SolidFS RDF write sync failed for ${resourceUrl}: ${response.status} ${await response.text().catch(() => '')}`);
+            throw new Error(`SolidFS write sync failed for ${resourceUrl}: ${response.status} ${await response.text().catch(() => '')}`);
         }
     }
 }

package/dist/solidfs/RdfIndexSolidFsSyncer.d.ts

@@ -5,6 +5,8 @@ import type { SolidFsChange, SolidFsManifest, SolidFsSyncer } from './types';
 type MaybePromise<T> = T | Promise<T>;
 export interface RdfIndexSolidFsSyncerOptions {
     index: LocalRdfIndexAccessor;
+    /** Recovery reads the existing authority; materialized workspaces copy their content back. */
+    rdfSourceMode?: 'copy' | 'authority';
     textIndex?: RdfTextIndexLike;
     vectorIndex?: RdfVectorIndexLike;
     vectorizeText?: (input: RdfIndexSolidFsVectorizeInput) => MaybePromise<RdfVectorChunkInput[]>;
@@ -40,6 +42,7 @@ export interface RdfIndexSolidFsRebuildError {
  */
 export declare class RdfIndexSolidFsSyncer implements SolidFsSyncer {
     private readonly index;
+    private readonly rdfSourceMode;
     private readonly textIndex?;
     private readonly vectorIndex?;
     private readonly vectorizeText?;

package/dist/solidfs/RdfIndexSolidFsSyncer.js

@@ -22,6 +22,7 @@ class RdfIndexSolidFsSyncer {
             throw new Error('RdfIndexSolidFsSyncer vectorIndex requires vectorizeText');
         }
         this.index = options.index;
+        this.rdfSourceMode = options.rdfSourceMode ?? 'copy';
         this.textIndex = options.textIndex;
         this.vectorIndex = options.vectorIndex;
         this.vectorizeText = options.vectorizeText;
@@ -145,7 +146,7 @@ class RdfIndexSolidFsSyncer {
         const source = this.sourceInput(change, workspace);
         const identifier = this.resolveIdentifier(change, workspace);
         if (options.rdf && identifier && isRdfChange(change)) {
-            await this.index.syncLocalRdfDocument(identifier, (0, community_server_1.guardStream)((0, node_fs_1.createReadStream)(change.sourcePath)), change.contentType, source);
+            await this.index.syncLocalRdfDocument(identifier, this.rdfSourceMode === 'authority' ? undefined : (0, community_server_1.guardStream)((0, node_fs_1.createReadStream)(change.sourcePath)), change.contentType, { ...source, sourcePath: change.sourcePath });
         }
         let text;
         if (options.text || options.vector) {
@@ -200,7 +201,7 @@ class RdfIndexSolidFsSyncer {
         }
         const source = this.sourceInput(change, workspace);
         if (identifier && isRdfChange(change)) {
-            await this.index.syncLocalRdfDocument(identifier, (0, community_server_1.guardStream)((0, node_fs_1.createReadStream)(change.sourcePath)), change.contentType, source);
+            await this.index.syncLocalRdfDocument(identifier, this.rdfSourceMode === 'authority' ? undefined : (0, community_server_1.guardStream)((0, node_fs_1.createReadStream)(change.sourcePath)), change.contentType, { ...source, sourcePath: change.sourcePath });
         }
         const textSearchIndexable = isTextSearchIndexableChange(change);
         const vectorIndexable = isTextIndexableChange(change);
@@ -275,7 +276,7 @@ class RdfIndexSolidFsSyncer {
                 return;
             }
         }
-        await this.index.syncLocalRdfDocument(nextIdentifier, (0, community_server_1.guardStream)((0, node_fs_1.createReadStream)(change.sourcePath)), change.contentType, nextSource);
+        await this.index.syncLocalRdfDocument(nextIdentifier, this.rdfSourceMode === 'authority' ? undefined : (0, community_server_1.guardStream)((0, node_fs_1.createReadStream)(change.sourcePath)), change.contentType, { ...nextSource, sourcePath: change.sourcePath });
         if (previousSource) {
             await this.index.deleteLocalRdfIndex({ path: previousSource });
         }

package/dist/solidfs/SolidFsSyncJournal.d.ts

@@ -62,6 +62,17 @@ export declare class SqliteSolidFsSyncJournal implements LocalRdfAuthorityJourna
     getOperation(id: string): SolidFsSyncJournalOperation | undefined;
     listOperations(stages?: SolidFsSyncJournalStage[]): SolidFsSyncJournalOperation[];
     listPending(): SolidFsSyncJournalOperation[];
+    /**
+     * Rebase the operation's expected hash to the file version its own sync produced.
+     *
+     * A direct-projection Pod sync PUTs a resource whose local file is the same
+     * authority file CSS serves, so the write itself moves the file version (mtime,
+     * possibly inode) without changing the bytes. Only that same-bytes timestamp
+     * drift may be rebased. When the content identity (size and digest) differs,
+     * a concurrent writer changed the authority bytes during the sync, so the
+     * original guard must stand and the operation is left for reconciliation.
+     */
+    recordSyncedSourceHash(id: string, afterHash: string | undefined): Promise<void>;
     markDone(id: string): Promise<void>;
     markRetryableFailure(id: string, error: unknown): Promise<void>;
     markReconcileRequired(id: string, reason: string): Promise<void>;