@hachej/boring-files 0.4.35 → 0.4.37

package/README.md

@@ -8,7 +8,7 @@ Opaque resource view IDs are provider-scoped and bound to the actual backing/inc
 
 `@hachej/boring-files/workspace` exports `createWorkspaceProvider({ identity, fs, journal })`: the one provider of a workspace's files ([One place for files](../../docs/architecture/FILES-GIT-EXEC.md#one-place-for-files)). It takes a Pi `FileSystem` (a disk environment, the virtual workspace or the SQLite backend below), the host's workspace identity and a journal (`createWorkspaceJournal(connection)` from `@hachej/boring-files/journal`, receipts, intents and the last 20 versions of each file in SQLite). Revisions are Git blob ids of the bytes. A conditional write checks every expected revision and precondition inside the workspace's queue, records its intent first and its receipt last; an intent without a completion looks up as `unknown` and is never replayed. Its owner closes the connection; the provider borrows it. Node currently marks `node:sqlite` experimental.
 
-The provider accepts all-or-nothing create, replace and conditional delete, plus conditional rename through `renaming.rename`. It refuses working views, per-change requests and folder mutations before any effect. Logical paths are relative to the workspace root; a path whose real location leaves the root is denied. A single file is replaced atomically by every backend; a multi-file batch only by the SQLite backend, together with its receipt when the journal shares the database. Access control is the host's, at the workspace boundary: there are no per-file permissions inside a workspace, and external revocation fencing is not implemented.
+The provider accepts all-or-nothing create, replace and conditional delete, plus conditional rename through `renaming.rename`. It refuses working views and folder mutations before any effect. Logical paths are relative to the workspace root; a path whose real location leaves the root is denied. A single file is replaced atomically by every backend; a multi-file batch only by the SQLite backend, together with its receipt when the journal shares the database. Access control is the host's, at the workspace boundary: there are no per-file permissions inside a workspace, and external revocation fencing is not implemented.
 
 ### Agent writes and the change feed
 

package/dist/contracts.d.ts

@@ -91,7 +91,7 @@ export type ResourceChange = {
 export interface PublicationRequest {
     readonly operationId: string;
     readonly changes: NonEmpty<ResourceChange>;
-    readonly atomicity: 'all-or-nothing' | 'per-change';
+    readonly atomicity: 'all-or-nothing';
     /** Extra exact-content/absence dependencies, in addition to change targets.
      * Search/listing predicate evidence needs its separately qualified provider
      * integration; this minimal contract does not pretend to implement it.
@@ -149,19 +149,7 @@ export type PublicationOutcome = {
     readonly operationId: string;
     readonly reason: string;
 };
-/** Result association survives multiple changes/views and lost responses.
- * Providers validate index coverage/uniqueness and target/receipt agreement.
- */
-export interface PublicationItem {
-    readonly changeIndex: number;
-    readonly target: ResourceLocator;
-    readonly outcome: PublicationOutcome;
-}
-export type PublicationResult = PublicationOutcome | {
-    readonly kind: 'partial';
-    readonly operationId: string;
-    readonly items: NonEmpty<PublicationItem>;
-};
+export type PublicationResult = PublicationOutcome;
 export interface ProviderGuarantees {
     readonly pinnedReads: boolean;
     readonly conditionalPublication: boolean;
@@ -189,11 +177,15 @@ export interface ResourceRenameRequest {
     readonly to: ResourceLocator;
     readonly expectedRevision: string;
     readonly operationId: string;
+    /** Also remove the folders this leaves empty: a folder operation in the tree, never a single-file change, since another consumer may have its cwd there. */
+    readonly pruneEmptied?: true;
 }
 export interface ResourceDeleteRequest {
     readonly path: ResourceLocator;
     readonly expectedRevision: string;
     readonly operationId: string;
+    /** Also remove the folders this leaves empty: a folder operation in the tree, never a single-file change, since another consumer may have its cwd there. */
+    readonly pruneEmptied?: true;
 }
 /** Conditional regular-file mutations; receipts and lookup use the publication journal. */
 export interface ResourceRenamer {

package/dist/publication-input.js

@@ -79,7 +79,7 @@ export function publicationSnapshot(value) {
     const input = object(value);
     if (!Array.isArray(input.changes) || !input.changes.length)
         throw new TypeError('Publication requires changes');
-    if (input.atomicity !== 'all-or-nothing' && input.atomicity !== 'per-change')
+    if (input.atomicity !== 'all-or-nothing')
         throw new TypeError('Invalid atomicity');
     const [first, ...rest] = input.changes;
     const changes = [change(first), ...rest.map(change)];
@@ -99,11 +99,11 @@ export function renameSnapshot(value) {
         throw new TypeError('Rename requires one provider and view');
     if (from.resource.path === to.resource.path || from.resource.path.startsWith(`${to.resource.path}/`) || to.resource.path.startsWith(`${from.resource.path}/`))
         throw new TypeError('Rename requires independent file paths');
-    return { from, to, expectedRevision: identifier(input.expectedRevision), operationId: identifier(input.operationId) };
+    return { from, to, expectedRevision: identifier(input.expectedRevision), operationId: identifier(input.operationId), ...(input.pruneEmptied === true ? { pruneEmptied: true } : {}) };
 }
 export function deleteSnapshot(value) {
     const input = object(value);
-    return { path: locator(input.path), expectedRevision: identifier(input.expectedRevision), operationId: identifier(input.operationId) };
+    return { path: locator(input.path), expectedRevision: identifier(input.expectedRevision), operationId: identifier(input.operationId), ...(input.pruneEmptied === true ? { pruneEmptied: true } : {}) };
 }
 export function deletePublication(request) {
     return { operationId: request.operationId, atomicity: 'all-or-nothing', changes: [{ kind: 'delete', target: { ...request.path, revision: request.expectedRevision } }] };
@@ -172,19 +172,5 @@ function publicationOutcome(value) {
 }
 /** Parse transport/provider output before treating it as acknowledgement. */
 export function parsePublicationResult(value) {
-    const input = object(value);
-    if (input.kind !== 'partial')
-        return publicationOutcome(input);
-    if (!Array.isArray(input.items) || !input.items.length)
-        throw new TypeError('Partial publication requires items');
-    const items = input.items.map(value => {
-        const item = object(value);
-        if (typeof item.changeIndex !== 'number' || !Number.isSafeInteger(item.changeIndex) || item.changeIndex < 0)
-            throw new TypeError('Invalid change index');
-        return { changeIndex: item.changeIndex, target: locator(item.target), outcome: publicationOutcome(item.outcome) };
-    });
-    const [first, ...rest] = items;
-    if (!first || new Set(items.map(item => item.changeIndex)).size !== items.length)
-        throw new TypeError('Invalid partial publication coverage');
-    return { kind: 'partial', operationId: identifier(input.operationId), items: [first, ...rest] };
+    return publicationOutcome(object(value));
 }

package/dist/remote-protocol.js

@@ -76,8 +76,6 @@ export function decodeCall(input) {
         return change.kind === 'delete' ? change : { ...change, bytes: bytes(change.bytes) };
     });
     const request = publicationSnapshot({ ...value, changes });
-    if (request.atomicity !== 'all-or-nothing')
-        throw new TypeError('Remote per-change publication is not qualified');
     return { kind: 'publish', value: request };
 }
 export function encode(value, limit) {
@@ -148,8 +146,6 @@ function outcomeAgreement(result, operationId, selected, changes, digest) {
 }
 export function publicationResult(value, operationId, selected, request, digest) {
     const result = parsePublicationResult(value);
-    if (result.kind === 'partial')
-        throw new TypeError('Remote partial receipts are not qualified');
     outcomeAgreement(result, operationId, selected, request?.changes, digest);
     return result;
 }

package/dist/remote.js

@@ -65,8 +65,6 @@ export function createResourceClient(options) {
                 const captured = publicationSnapshot(request);
                 let digest;
                 try {
-                    if (captured.atomicity !== 'all-or-nothing')
-                        throw new TypeError('Remote per-change publication is not qualified');
                     digest = await publicationDigest(captured);
                 }
                 catch {

package/dist/sqlite-filesystem.js

@@ -439,7 +439,7 @@ export function openSqliteFileSystem(options) {
         setMaxFileBytes: limit => { assertLimit(limit); maxFileBytes = limit; },
         bytes: path => { const found = row(normalize(path)); return !found ? null : found.kind === 'directory' ? undefined : bytes(normalize(path)); },
         write: (path, content) => { const absolute = normalize(path); makeDirectory(dirname(absolute), true); write(absolute, content); notify(); },
-        rename: (from, to) => { rename(normalize(from), normalize(to)); notify(); },
+        rename: (from, to) => { const target = normalize(to); makeDirectory(dirname(target), true); rename(normalize(from), target); notify(); },
         remove: path => { remove(normalize(path)); notify(); },
     });
     return fs;

package/dist/workspace.js

@@ -157,6 +157,20 @@ export function createWorkspaceProvider(options) {
         const bytes = Uint8Array.from(result.value);
         return { kind: 'file', bytes, revision: await blobRevision(bytes) };
     }
+    /**
+     * A folder exists through its files: the one a move or delete left empty goes, up to the first that still holds something. Best effort and
+     * never recursive, so a file landing meanwhile stays; a file system that cannot remove a directory that way (Pi's Node one) keeps the folder.
+     */
+    const pruneEmptied = async (path) => {
+        for (let folder = path.slice(0, Math.max(0, path.lastIndexOf('/'))); folder; folder = folder.slice(0, Math.max(0, folder.lastIndexOf('/')))) {
+            const listed = await fs.listDir(absolute(folder), fsContext()).catch(() => undefined);
+            if (!listed?.ok || listed.value.length)
+                return;
+            const gone = await fs.remove(absolute(folder), { recursive: false }, fsContext()).catch(() => undefined);
+            if (!gone?.ok)
+                return;
+        }
+    };
     /** Once per provider, before its first operation: remove temporary files that an earlier process left behind. */
     let swept;
     const sweep = () => swept ??= (async () => {
@@ -216,12 +230,10 @@ export function createWorkspaceProvider(options) {
             changes: committedChanges(stored.changes, ref),
         };
     }
-    const mutate = async (request, access) => {
+    const mutate = async (request, access, prune = false) => {
         const moving = 'from' in request ? request : undefined;
         const publication = 'changes' in request ? request : undefined;
         const digest = moving ? await renameDigest(moving) : await publicationDigest(publication);
-        if (publication && publication.atomicity !== 'all-or-nothing')
-            return { kind: 'unavailable', reason: 'This provider accepts all-or-nothing publication only' };
         if (publication && publication.changes.length !== 1 && !batch)
             return { kind: 'unavailable', reason: 'This provider cannot apply a multi-file batch atomically; only a single-file change is accepted' };
         const changes = moving ? [{ kind: 'delete', target: { ...moving.from, revision: moving.expectedRevision } }] : publication.changes;
@@ -365,11 +377,28 @@ export function createWorkspaceProvider(options) {
                     applying = true;
                     if (!together)
                         journal.complete(operation, record, versions);
+                    if (prune && moving)
+                        await pruneEmptied(moving.from.resource.path);
+                    else if (prune)
+                        for (const plan of plans)
+                            if (plan.change.kind === 'delete')
+                                await pruneEmptied(plan.path);
                 }
                 else if (moving || plans[0].change.kind === 'delete') {
                     applying = true;
+                    // Like a publication, a move creates the folder it lands in: a folder renames file by file, so the first file finds none.
+                    const landing = moving ? absolute(moving.to.resource.path) : '';
+                    if (moving) {
+                        const made = await fs.createDir(landing.slice(0, landing.lastIndexOf('/')) || '/', { recursive: true }, fsContext(access.signal));
+                        if (!made.ok) {
+                            if (made.error.code === 'unknown' || made.error.code === 'aborted')
+                                throw made.error;
+                            return refuse(made.error.message);
+                        }
+                    }
+                    const leaving = moving ? moving.from.resource.path : plans[0].path;
                     const result = moving
-                        ? await fs.renameFile(absolute(moving.from.resource.path), absolute(moving.to.resource.path), fsContext(access.signal))
+                        ? await fs.renameFile(absolute(moving.from.resource.path), landing, fsContext(access.signal))
                         : await fs.remove(absolute(plans[0].path), { recursive: false }, fsContext(access.signal));
                     if (!result.ok) {
                         if (result.error.code === 'unknown' || result.error.code === 'aborted')
@@ -377,6 +406,8 @@ export function createWorkspaceProvider(options) {
                         return refuse(result.error.message);
                     }
                     journal.complete(operation, record, versions);
+                    if (prune)
+                        await pruneEmptied(leaving);
                 }
                 else {
                     const { change, path, unchanged } = plans[0];
@@ -419,8 +450,8 @@ export function createWorkspaceProvider(options) {
         });
     };
     const publish = async (input, context) => mutate(publicationSnapshot(input), accessSnapshot(context));
-    const rename = async (input, context) => mutate(renameSnapshot(input), accessSnapshot(context));
-    const remove = async (input, context) => mutate(deletePublication(deleteSnapshot(input)), accessSnapshot(context));
+    const rename = async (input, context) => { const request = renameSnapshot(input); return mutate(request, accessSnapshot(context), request.pruneEmptied === true); };
+    const remove = async (input, context) => { const request = deleteSnapshot(input); return mutate(deletePublication(request), accessSnapshot(context), request.pruneEmptied === true); };
     const lookup = async (operationId, context) => {
         const id = identifier(operationId);
         const access = accessSnapshot(context);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-files",
-  "version": "0.4.35",
+  "version": "0.4.37",
   "license": "MIT",
   "private": false,
   "type": "module",