@hachej/boring-files 0.4.6 → 0.4.8

package/README.md

@@ -8,11 +8,11 @@ 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 and replace. It refuses working views, per-change requests and deletes (files are removed with the workspace's own tools) 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, 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.
 
 ### Agent writes and the change feed
 
-Agent writes are observed, never receipted ([owner ruling 2](../../docs/architecture/FILES-GIT-EXEC.md#one-place-for-files)). `provider.record({ path, before?, after, source: 'agent', conversationId? }, access)` is what the file guard (`@hachej/boring-agent/file-guard`) calls after a Pi `write` or `edit` succeeded: the file's history gains the written revision with `source: 'agent'` (and the replaced revision, `source: 'observed'`, when `before` carries its bytes), and the change feed an `agent` event. It never writes the publication journal and never mints a receipt. It does not enter the provider's queue (the guard already runs inside it), so calling it from queued work cannot deadlock. History entries (`saves`, `catalog.history`) carry `source`: `publish`, `agent` or `observed` (`keep` and replaced revisions).
+Agent writes are observed, never receipted ([owner ruling 2](../../docs/architecture/FILES-GIT-EXEC.md#one-place-for-files)). `provider.record({ path, before?, after, source: 'agent', conversationId? }, access)` is what the file guard (`@hachej/boring-agent/file-guard`) calls after a Pi `write` or `edit` succeeded: the file's history gains the written revision with `source: 'agent'` (and the replaced revision, `source: 'observed'`, when `before` carries its bytes), and the change feed an `agent` event. It never writes the publication journal and never mints a receipt. It does not enter the provider's queue (the guard already runs inside it), so calling it from queued work cannot deadlock. History entries (`saves`, `catalog.history`) carry `source`: `publish`, `agent`, `observed` (`keep` and replaced revisions), `rename` or `delete` (the affected retained version). History remains one row per content revision, not an operation log; receipts retain every conditional mutation. A rename retains the moved version at both paths; a delete retains its removed version without inventing a tombstone revision. `savedAt` remains the version's first recorded save time at that path, not a separate deletion timestamp.
 
 `provider.changes({ since?, signal }, access)` is one change feed for every file view: an `AsyncIterable` of `{ kind: 'change', path, revision | null, source: 'publish' | 'agent' | 'poll' | 'watch', seq, at }`, ordered by `seq` and replayable from `since` (the last `seq` seen; `changeHead()` is "now"). The provider retains the last `changeBuffer` events (default 1024); a cursor older than that, from another provider lifetime or ahead of this one, and a listener that falls behind get `{ kind: 'resnapshot', seq, at }`: reload everything shown, then continue. Events are invalidation hints; bytes and the journal stay authoritative. Sources: conditional writes (`publish`), `record` (`agent`), `poll` and, while someone listens (and `watchLingerMs` after, default 30 s), the file system's own `watch` (`watch`; a reported directory is `{ revision: null, directory: true }`). The SQLite file system reports writes through its own connection at once and polls every second for other connections. When the file system cannot watch (the virtual and remote environments report `not_supported`), the host calls `provider.poll()` at the end of each agent turn: without paths it hashes every file (not `.git` or `node_modules`); the first call takes the baseline, later ones report changed, new and removed files. A `bash` write gets change events only, never history. After the last listener leaves the watcher lingers and then closes; changes made while no watcher was open are unknown, so the first listener afterwards makes the feed append a `resnapshot` (a client that stays connected is never affected). `changeIncarnation` names the provider lifetime: a cursor sent with another `incarnation` is a `resnapshot` whatever its number. `provider.close()` ends every change stream, closes the watcher and drops the listeners.
 
@@ -43,7 +43,7 @@ A large or binary file (up to 100 MB) can live in the host's blob store as an im
 
 ## Optional authenticated resource transport
 
-`@hachej/boring-files/remote` exports `createResourceClient` and `createResourceHandler`. Both are Fetch adapters over the existing resource contracts. They import no Pi runtime, filesystem or database. The client implements `ResourceClient`; `publication: true` and `reconciliation: true` independently select its optional methods. The handler borrows a reader, optional publisher and optional lookup. It never closes them.
+`@hachej/boring-files/remote` exports `createResourceClient` and `createResourceHandler`. Both are Fetch adapters over the existing resource contracts. They import no Pi runtime, filesystem or database. The client implements `ResourceClient`; `publication: true` selects `publish`, `rename` and `delete`, and `reconciliation: true` selects `lookup`. The handler borrows a reader, optional publisher, renamer, deleter and lookup. It never closes them.
 
 ```ts
 const handler = createResourceHandler({
@@ -51,6 +51,8 @@ const handler = createResourceHandler({
   reader: provider,
   publisher: provider.publication,
   lookup: provider.reconciliation,
+  renamer: provider.renaming,
+  deleter: provider.deletion,
 });
 const client = createResourceClient({
   identity: { principalId, scopeId, initiatorId },
@@ -61,7 +63,7 @@ const client = createResourceClient({
 });
 ```
 
-`publication: true` requires `reconciliation: true` (types and constructor): a save whose acknowledgement is lost is `unknown`, and only a lookup can resolve it. A read-only client sets neither.
+`publication: true` requires `reconciliation: true` (types and constructor): a mutation whose acknowledgement is lost is `unknown`, and only a lookup can resolve it. A read-only client sets neither. The handler answers 405 for an uninstalled capability; client opt-ins grant no server authority.
 
 Authentication returns trusted `ResourceAccess` or null. Its optional signal represents host revocation; the handler combines it with request cancellation. Client identity is expected response metadata, never authority. The host owns credentials, origin/CSRF/CORS policy, endpoint routing and provider confinement. The injected Fetch must honor `redirect: 'error'`, preserve cancellation and never retry effects. Bind a handler to the host's selected provider capabilities. Browser JSON cannot grant access or supply a trusted digest or approval.
 
@@ -109,7 +111,7 @@ scope in the same database:
 | `openSqliteResources({ connection, ... })` (a Durable Object) | the same calls with `durableObjectSqliteConnection(ctx.storage)` from `@hachej/boring-files/sqlite-durable-object` |
 | `authorize(action, target, access)` inside the store | the host checks its policy before calling the workspace's provider; [`shared/sqlite-workspaces.mjs`](../../shared/sqlite-workspaces.mjs) shows one way (a refused write whose operation committed and a refused lookup read `unknown`) |
 | `provider.close()` | `connection.close()` by the connection's owner |
-| a `delete` change | the workspace's own file tools (`fs.remove`, Pi's `bash`); publication refuses deletes |
+| a `delete` change | conditional publication with the observed revision, or `provider.deletion.delete({ path: locator, expectedRevision, operationId }, access)` |
 | revisions were random ids; saving the same bytes made a new revision | revisions are Git blob ids: the same bytes keep their revision, and `before` equal to `after` is a valid committed change |
 | every revision retained | the last 20 versions per file (`createWorkspaceJournal(connection, { historyLimit })`); older ones read `unavailable` |
 
@@ -155,8 +157,43 @@ const revisionProvider = await connectRevisionProvider({
 
 The binding discovers identity and workspace incarnation from the authenticated
 server. Reconnect when the selected workspace changes. It exposes `list`,
-filename `search`, retained `history`, `locate`, `read`, `publish`, `lookup` and
-`changes({ since?, signal })`, the workspace's change feed.
+filename `search`, retained `history`, `locate`, `read`, `publish`, `lookup`,
+`rename`, `delete` and `changes({ since?, signal })`, the workspace's change feed.
+
+```ts
+const moved = await revisionProvider.rename?.({
+  from: revisionProvider.locate('draft.md'),
+  to: revisionProvider.locate('final.md'),
+  expectedRevision: loaded.snapshot.ref.revision,
+  operationId: 'move-draft-1',
+});
+const removed = await revisionProvider.delete?.({
+  path: revisionProvider.locate('final.md'),
+  expectedRevision: loaded.snapshot.ref.revision,
+  operationId: 'remove-final-1',
+});
+```
+
+These methods send `rename` and `delete` kinds on the same authenticated files
+endpoint. `from`, `to` and `path` are `ResourceLocator`s, not strings. Both require
+the current source revision; rename also requires an absent target in the same
+provider/view and an existing parent directory. Direct workspace callers use
+`provider.renaming.rename(request, access)` and `provider.deletion.delete(request, access)`.
+A rename receipt is a delete/create pair with the same content revision; its feed
+emits old-path `revision: null` then the new-path revision, both `source: 'publish'`.
+Delete emits `revision: null`. Stale revisions and existing file targets conflict.
+Identical operation-ID retries and `lookup` return the original receipt; changed
+arguments conflict. A lost reply stays `unknown`, never an automatic retry.
+`createRevisionHandler` installs these capabilities from its selected provider
+and holds the same workspace lease until they settle. Generic resource handlers
+install `renamer`/`deleter` explicitly. Folders, recursive deletion and file-tree
+Rename/Delete controls are not part of this endpoint increment.
+
+Both operations use the workspace queue and Pi's native `renameFile`/`remove`.
+SQLite (including the Durable Object adapter) reuses those filesystem mutations
+inside the bytes/history/receipt transaction when the journal shares its connection.
+Disk/remote backends retain their existing crash window: an effect without a
+completed journal receipt is `unknown`. Shell writers remain outside the queue.
 
 The feed is `GET <endpoint>?op=changes[&since=<seq>&incarnation=<id>]` with the binding header:
 server-sent events (`event: ready` with the current seq and the provider incarnation, then `event: change` or

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { ResourceRead, ReadResult, PublicationRequest, PublicationResult, PublicationLookupResult } from './contracts.js';
+import type { ResourceRead, ReadResult, PublicationRequest, PublicationResult, PublicationLookupResult, ResourceRenameRequest, ResourceDeleteRequest } from './contracts.js';
 /** Authenticated host/client binding. No ResourceAccess, approval authority or
  * trusted request digest is accepted from the browser. A request still requires
  * real server validation. Uncertain saves can use optional reconciliation.
@@ -8,5 +8,7 @@ export interface ResourceClient {
     /** PublicationNotDispatchedError describes this call only; reconcile any earlier uncertain attempt separately. */
     readonly publish?: (request: PublicationRequest, signal?: AbortSignal) => Promise<PublicationResult>;
     readonly lookup?: (operationId: string, signal?: AbortSignal) => Promise<PublicationLookupResult>;
+    readonly rename?: (request: ResourceRenameRequest, signal?: AbortSignal) => Promise<PublicationResult>;
+    readonly delete?: (request: ResourceDeleteRequest, signal?: AbortSignal) => Promise<PublicationResult>;
 }
 //# sourceMappingURL=client.d.ts.map

package/dist/contracts.d.ts

@@ -171,8 +171,8 @@ export interface ProviderGuarantees {
     readonly revocationFencing: boolean;
 }
 export interface ResourceCapabilities {
-    readonly supported: readonly ('read' | 'create' | 'replace' | 'delete' | 'lookup')[];
-    readonly effective: readonly ('read' | 'create' | 'replace' | 'delete' | 'lookup')[];
+    readonly supported: readonly ('read' | 'create' | 'replace' | 'delete' | 'rename' | 'lookup')[];
+    readonly effective: readonly ('read' | 'create' | 'replace' | 'delete' | 'rename' | 'lookup')[];
     readonly availability: 'available' | 'unavailable' | 'unknown';
     readonly observedAt: string;
     readonly guarantees: ProviderGuarantees;
@@ -184,6 +184,24 @@ export interface ResourceReader {
 export interface ResourcePublisher {
     readonly publish: (request: PublicationRequest, access: ResourceAccess) => Promise<PublicationResult>;
 }
+export interface ResourceRenameRequest {
+    readonly from: ResourceLocator;
+    readonly to: ResourceLocator;
+    readonly expectedRevision: string;
+    readonly operationId: string;
+}
+export interface ResourceDeleteRequest {
+    readonly path: ResourceLocator;
+    readonly expectedRevision: string;
+    readonly operationId: string;
+}
+/** Conditional regular-file mutations; receipts and lookup use the publication journal. */
+export interface ResourceRenamer {
+    readonly rename: (request: ResourceRenameRequest, access: ResourceAccess) => Promise<PublicationResult>;
+}
+export interface ResourceDeleter {
+    readonly delete: (request: ResourceDeleteRequest, access: ResourceAccess) => Promise<PublicationResult>;
+}
 export type PublicationLookupResult = PublicationResult | {
     readonly kind: 'not-found';
 };
@@ -198,5 +216,7 @@ export interface ResourceProvider extends ResourceReader {
     readonly capabilities: (target: ResourceLocator, access: ResourceAccess) => Promise<ResourceCapabilities>;
     readonly publication?: ResourcePublisher;
     readonly reconciliation?: PublicationLookup;
+    readonly renaming?: ResourceRenamer;
+    readonly deletion?: ResourceDeleter;
 }
 //# sourceMappingURL=contracts.d.ts.map

package/dist/journal.d.ts

@@ -44,7 +44,7 @@ export interface StoredVersion {
      */
     readonly source?: HistorySource;
 }
-export type HistorySource = 'publish' | 'agent' | 'observed';
+export type HistorySource = 'publish' | 'agent' | 'observed' | 'rename' | 'delete';
 /**
  * The operation journal plus what a workspace needs beyond receipts: an intent row written before an operation's first effect
  * (an intent without a completion is an operation of unknown outcome), and the last versions of each file when there is no Git.

package/dist/journal.js

@@ -59,7 +59,7 @@ export function committedChanges(changes, ref) {
         throw new Error('Stored operation has no changes');
     return [first, ...rest];
 }
-const historySource = (value) => value === 'agent' || value === 'observed' ? value : 'publish';
+const historySource = (value) => value === 'agent' || value === 'observed' || value === 'rename' || value === 'delete' ? value : 'publish';
 export function createWorkspaceJournal(db, options = {}) {
     const limit = options.historyLimit ?? 20;
     if (!Number.isSafeInteger(limit) || limit < 1)

package/dist/publication-input.d.ts

@@ -1,4 +1,4 @@
-import type { PublicationRequest, PublicationResult, ResourceAccess, ResourceLocator, ResourceRef } from './contracts.js';
+import type { PublicationRequest, PublicationResult, ResourceAccess, ResourceLocator, ResourceRef, ResourceRenameRequest, ResourceDeleteRequest } from './contracts.js';
 /** This invocation did not dispatch. Earlier attempts with the same ID may still have effects. */
 export declare class PublicationNotDispatchedError extends Error {
     readonly operationId: string;
@@ -9,6 +9,10 @@ export declare function locator(value: unknown): ResourceLocator;
 export declare function reference(value: unknown): ResourceRef;
 export declare function accessSnapshot(value: ResourceAccess): ResourceAccess;
 export declare function publicationSnapshot(value: unknown): PublicationRequest;
+export declare function renameSnapshot(value: unknown): ResourceRenameRequest;
+export declare function deleteSnapshot(value: unknown): ResourceDeleteRequest;
+export declare function deletePublication(request: ResourceDeleteRequest): PublicationRequest;
+export declare function renameDigest(input: ResourceRenameRequest): Promise<string>;
 export declare function publicationDigest(input: PublicationRequest): Promise<string>;
 /** Parse transport/provider output before treating it as acknowledgement. */
 export declare function parsePublicationResult(value: unknown): PublicationResult;

package/dist/publication-input.js

@@ -93,6 +93,26 @@ export function publicationSnapshot(value) {
         ...(input.preconditions === undefined ? {} : { preconditions: input.preconditions.map(expectation) }),
     };
 }
+export function renameSnapshot(value) {
+    const input = object(value), from = locator(input.from), to = locator(input.to);
+    if (from.resource.providerId !== to.resource.providerId || JSON.stringify(from.view) !== JSON.stringify(to.view))
+        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) };
+}
+export function deleteSnapshot(value) {
+    const input = object(value);
+    return { path: locator(input.path), expectedRevision: identifier(input.expectedRevision), operationId: identifier(input.operationId) };
+}
+export function deletePublication(request) {
+    return { operationId: request.operationId, atomicity: 'all-or-nothing', changes: [{ kind: 'delete', target: { ...request.path, revision: request.expectedRevision } }] };
+}
+export async function renameDigest(input) {
+    const { from, to, expectedRevision } = renameSnapshot(input);
+    const digest = await sha256(new TextEncoder().encode(JSON.stringify({ format: 'boring-rename-v1', from, to, expectedRevision })));
+    return 'boring-rename-v1:sha256:' + Array.from(digest, byte => byte.toString(16).padStart(2, '0')).join('');
+}
 export async function publicationDigest(input) {
     const request = publicationSnapshot(input);
     const canonical = JSON.stringify({

package/dist/remote-handler.d.ts

@@ -1,9 +1,11 @@
-import type { PublicationLookup, ResourceAccess, ResourcePublisher, ResourceReader } from './contracts.js';
+import type { PublicationLookup, ResourceAccess, ResourcePublisher, ResourceReader, ResourceRenamer, ResourceDeleter } from './contracts.js';
 export interface ResourceHandlerOptions {
     readonly authenticate: (request: Request) => Promise<ResourceAccess | null>;
     readonly reader: ResourceReader;
     readonly publisher?: ResourcePublisher;
     readonly lookup?: PublicationLookup;
+    readonly renamer?: ResourceRenamer;
+    readonly deleter?: ResourceDeleter;
     readonly maxRequestBytes?: number;
     readonly maxResponseBytes?: number;
 }

package/dist/remote-handler.js

@@ -1,8 +1,8 @@
 import { guardStatus, readJsonBody } from './request-guard.js';
-import { accessSnapshot, publicationDigest } from './publication-input.js';
-import { contentType, decodeCall, encode, envelope, identity, limit, lookupResult, observe, publicationResult, readResult, sameIdentity, schema, version } from './remote-protocol.js';
+import { accessSnapshot, publicationDigest, renameDigest, deletePublication } from './publication-input.js';
+import { contentType, decodeCall, encode, envelope, identity, limit, lookupResult, observe, publicationResult, renameResult, readResult, sameIdentity, schema, version } from './remote-protocol.js';
 export function createResourceHandler(options) {
-    const { authenticate, reader, publisher, lookup } = options;
+    const { authenticate, reader, publisher, lookup, renamer, deleter } = options;
     const requestLimit = limit(options.maxRequestBytes ?? 4_194_304), responseLimit = limit(options.maxResponseBytes ?? 8_388_608);
     return async (request) => {
         const refuse = (status) => new Response(null, { status, headers: { 'cache-control': 'no-store' } });
@@ -38,6 +38,25 @@ export function createResourceHandler(options) {
                     value = publicationResult(await observe(publisher.publish(call.value, access), signal), call.value.operationId, captured, call.value, digest);
                     break;
                 }
+                case 'rename': {
+                    if (!renamer)
+                        return refuse(405);
+                    const digest = await observe(renameDigest(call.value), signal);
+                    if (signal.aborted)
+                        return refuse(403);
+                    value = renameResult(await observe(renamer.rename(call.value, access), signal), call.value, captured, digest);
+                    break;
+                }
+                case 'delete': {
+                    if (!deleter)
+                        return refuse(405);
+                    const publication = deletePublication(call.value);
+                    const digest = await observe(publicationDigest(publication), signal);
+                    if (signal.aborted)
+                        return refuse(403);
+                    value = publicationResult(await observe(deleter.delete(call.value, access), signal), call.value.operationId, captured, publication, digest);
+                    break;
+                }
                 case 'lookup': {
                     if (!lookup)
                         return refuse(405);

package/dist/remote-protocol.d.ts

@@ -1,4 +1,4 @@
-import type { PublicationLookupResult, PublicationRequest, PublicationResult, ReadResult, ResourceAccess, ResourceRead } from './contracts.js';
+import type { PublicationLookupResult, PublicationRequest, PublicationResult, ReadResult, ResourceAccess, ResourceRead, ResourceRenameRequest, ResourceDeleteRequest } from './contracts.js';
 export type ResourceIdentity = Pick<ResourceAccess, 'principalId' | 'scopeId' | 'initiatorId'>;
 export type ResourceCall = {
     readonly kind: 'read';
@@ -6,6 +6,12 @@ export type ResourceCall = {
 } | {
     readonly kind: 'publish';
     readonly value: PublicationRequest;
+} | {
+    readonly kind: 'rename';
+    readonly value: ResourceRenameRequest;
+} | {
+    readonly kind: 'delete';
+    readonly value: ResourceDeleteRequest;
 } | {
     readonly kind: 'lookup';
     readonly value: string;
@@ -30,5 +36,6 @@ export declare function observe<Value>(pending: Promise<Value>, signal?: AbortSi
 export { readJsonBody as jsonBody } from './request-guard.js';
 export declare function readResult(value: unknown, request: ResourceRead, wire?: boolean): ReadResult;
 export declare function publicationResult(value: unknown, operationId: string, selected: ResourceIdentity, request?: PublicationRequest, digest?: string): PublicationResult;
+export declare function renameResult(value: unknown, request: ResourceRenameRequest, selected: ResourceIdentity, digest: string): PublicationResult;
 export declare function lookupResult(value: unknown, operationId: string, selected: ResourceIdentity): PublicationLookupResult;
 //# sourceMappingURL=remote-protocol.d.ts.map

package/dist/remote-protocol.js

@@ -1,4 +1,4 @@
-import { accessSnapshot, identifier, locator, parsePublicationResult, publicationSnapshot, reference } from './publication-input.js';
+import { accessSnapshot, identifier, locator, parsePublicationResult, publicationSnapshot, reference, renameSnapshot, deleteSnapshot } from './publication-input.js';
 export const schema = 'boring-resource';
 export const version = 2;
 export const contentType = 'application/json';
@@ -22,7 +22,7 @@ export function envelope(value) {
     const input = object(value);
     if (input.schema !== schema || input.version !== version)
         throw new TypeError('Unsupported resource protocol');
-    if (input.kind !== 'read' && input.kind !== 'publish' && input.kind !== 'lookup')
+    if (input.kind !== 'read' && input.kind !== 'publish' && input.kind !== 'lookup' && input.kind !== 'rename' && input.kind !== 'delete')
         throw new TypeError('Unsupported resource method');
     return { requestId: identifier(input.requestId), identity: wireIdentity(input.identity), kind: input.kind, value: input.value };
 }
@@ -64,6 +64,10 @@ export function decodeCall(input) {
         return { kind: 'read', value: readSnapshot(input.value) };
     if (input.kind === 'lookup')
         return { kind: 'lookup', value: identifier(input.value) };
+    if (input.kind === 'rename')
+        return { kind: 'rename', value: renameSnapshot(input.value) };
+    if (input.kind === 'delete')
+        return { kind: 'delete', value: deleteSnapshot(input.value) };
     const value = object(input.value);
     if (!Array.isArray(value.changes))
         throw new TypeError('Missing changes');
@@ -149,6 +153,18 @@ export function publicationResult(value, operationId, selected, request, digest)
     outcomeAgreement(result, operationId, selected, request?.changes, digest);
     return result;
 }
+export function renameResult(value, request, selected, digest) {
+    const result = publicationResult(value, request.operationId, selected, undefined, digest);
+    if (result.kind !== 'committed')
+        return result;
+    const changes = result.receipt.changes;
+    const removed = changes.find(change => change.kind === 'delete');
+    const created = changes.find(change => change.kind === 'create');
+    if (changes.length !== 2 || !removed || !created || !sameTarget(removed.before, request.from) || removed.before.revision !== request.expectedRevision
+        || !sameTarget(created.after, request.to) || created.after.revision !== request.expectedRevision)
+        throw new TypeError('Rename receipt mismatch');
+    return result;
+}
 export function lookupResult(value, operationId, selected) {
     return object(value).kind === 'not-found' ? { kind: 'not-found' } : publicationResult(value, operationId, selected);
 }

package/dist/remote.js

@@ -1,5 +1,5 @@
-import { PublicationNotDispatchedError, identifier, publicationDigest, publicationSnapshot } from './publication-input.js';
-import { contentType, encode, envelope, identity, jsonBody, limit, lookupResult, observe, publicationResult, readResult, readSnapshot, sameIdentity, schema, version } from './remote-protocol.js';
+import { PublicationNotDispatchedError, identifier, publicationDigest, publicationSnapshot, renameSnapshot, renameDigest, deleteSnapshot, deletePublication } from './publication-input.js';
+import { contentType, encode, envelope, identity, jsonBody, limit, lookupResult, observe, publicationResult, renameResult, readResult, readSnapshot, sameIdentity, schema, version } from './remote-protocol.js';
 import { randomUUID } from './platform.js';
 export { createResourceHandler } from './remote-handler.js';
 export function createResourceClient(options) {
@@ -37,7 +37,7 @@ export function createResourceClient(options) {
             return result.value;
         }
         catch {
-            if (call.kind === 'publish' && !dispatched)
+            if ((call.kind === 'publish' || call.kind === 'rename' || call.kind === 'delete') && !dispatched)
                 throw new PublicationNotDispatchedError(call.value.operationId);
             throw new Error('Remote resource operation is unconfirmed');
         }
@@ -76,6 +76,42 @@ export function createResourceClient(options) {
                     return { kind: 'unknown', operationId: captured.operationId, reason: 'Remote publication is unconfirmed; reconcile the original operation without automatic replay' };
                 }
             },
+            rename: async (request, signal) => {
+                const captured = renameSnapshot(request);
+                let digest;
+                try {
+                    digest = await renameDigest(captured);
+                }
+                catch {
+                    throw new PublicationNotDispatchedError(captured.operationId);
+                }
+                try {
+                    return renameResult(await invoke({ kind: 'rename', value: captured }, signal), captured, selected, digest);
+                }
+                catch (error) {
+                    if (error instanceof PublicationNotDispatchedError)
+                        throw error;
+                    return { kind: 'unknown', operationId: captured.operationId, reason: 'Remote rename is unconfirmed; reconcile the original operation without automatic replay' };
+                }
+            },
+            delete: async (request, signal) => {
+                const captured = deleteSnapshot(request), publication = deletePublication(captured);
+                let digest;
+                try {
+                    digest = await publicationDigest(publication);
+                }
+                catch {
+                    throw new PublicationNotDispatchedError(captured.operationId);
+                }
+                try {
+                    return publicationResult(await invoke({ kind: 'delete', value: captured }, signal), captured.operationId, selected, publication, digest);
+                }
+                catch (error) {
+                    if (error instanceof PublicationNotDispatchedError)
+                        throw error;
+                    return { kind: 'unknown', operationId: captured.operationId, reason: 'Remote delete is unconfirmed; reconcile the original operation without automatic replay' };
+                }
+            },
         } : {}),
         ...(options.reconciliation ? {
             lookup: async (operationId, signal) => {

package/dist/revision-contracts.d.ts

@@ -39,8 +39,8 @@ export interface FileSearchRequest {
 export interface SavedRevision {
     readonly revision: string;
     readonly savedAt: number;
-    /** Who wrote it: `publish` (a conditional write), `agent` (a Pi `write` or `edit`: observed, never receipted) or `observed` (retained as found). */
-    readonly source?: 'publish' | 'agent' | 'observed';
+    /** `publish`, `agent` or `observed` bytes; `rename`/`delete` retain the affected version. Receipts record each operation. */
+    readonly source?: 'publish' | 'agent' | 'observed' | 'rename' | 'delete';
 }
 /**
  * One entry of a workspace's change feed (ruling 2 of 2026-10-10): an invalidation hint, never content or a receipt. Bytes and

package/dist/revision-handler.js

@@ -163,6 +163,8 @@ export function createRevisionHandler(options) {
                     reader: { read: (value, context) => hold(provider.read(value, context)) },
                     publisher: { publish: (value, context) => hold(provider.publication.publish(value, context)) },
                     lookup: { lookup: (value, context) => hold(provider.reconciliation.lookup(value, context)) },
+                    ...(provider.renaming ? { renamer: { rename: (value, context) => hold(provider.renaming.rename(value, context)) } } : {}),
+                    ...(provider.deletion ? { deleter: { delete: (value, context) => hold(provider.deletion.delete(value, context)) } } : {}),
                 })(request);
             const input = record(await readJsonBody(request, 32_768, access.signal));
             const requestId = identifier(input.requestId);

package/dist/revision-protocol.js

@@ -37,7 +37,7 @@ export function savedRevisions(value) {
         const entry = record(item);
         if (typeof entry.savedAt !== 'number' || !Number.isSafeInteger(entry.savedAt) || entry.savedAt < 0)
             throw new RevisionError('invalid', 'Invalid save timestamp');
-        const source = entry.source === 'publish' || entry.source === 'agent' || entry.source === 'observed' ? entry.source : undefined;
+        const source = entry.source === 'publish' || entry.source === 'agent' || entry.source === 'observed' || entry.source === 'rename' || entry.source === 'delete' ? entry.source : undefined;
         return { revision: identifier(entry.revision), savedAt: entry.savedAt, ...(source ? { source } : {}) };
     });
 }

package/dist/sqlite-batch.d.ts

@@ -2,7 +2,7 @@ import type { SqliteConnection } from './sqlite.js';
 /**
  * Internal (not a package export): what the workspace provider needs from the SQLite file system to commit a multi-file batch in
  * one transaction. Registered by `openSqliteFileSystem` against the file system object it returns, so the provider keeps taking a
- * plain Pi `FileSystem`. Both functions are synchronous and run inside `connection.transaction`.
+ * plain Pi `FileSystem`. Its mutations are synchronous and run inside `connection.transaction`.
  */
 export interface SqliteBatch {
     readonly connection: SqliteConnection;
@@ -10,6 +10,8 @@ export interface SqliteBatch {
     readonly bytes: (path: string) => Uint8Array | null | undefined;
     /** Write a regular file at an absolute path, creating its missing parent directories. Throws a Pi `FileError` on failure. */
     readonly write: (path: string, bytes: Uint8Array) => void;
+    readonly rename: (from: string, to: string) => void;
+    readonly remove: (path: string) => void;
     /** The one byte limit of this file system: native writes and publications both enforce it. */
     readonly maxFileBytes: () => number;
     readonly setMaxFileBytes: (limit: number) => void;

package/dist/sqlite-filesystem.js

@@ -202,6 +202,45 @@ export function openSqliteFileSystem(options) {
         return seen;
     }
     const encode = (content) => typeof content === 'string' ? new TextEncoder().encode(content) : Uint8Array.from(content);
+    function rename(from, to) {
+        const moved = existing(from);
+        if (from === to)
+            return;
+        const oversized = db.get(`SELECT path, length(bytes) AS size FROM boring_workspace_files WHERE ${subtree(from)} AND kind = 'file' AND length(bytes) > ? LIMIT 1`, ...subtreeArgs(from), maxFileBytes);
+        if (oversized)
+            throw fileTooLarge(oversized.path, Number(oversized.size), maxFileBytes);
+        touched.add(from);
+        touched.add(to);
+        if (from === '/' || within(from, to))
+            throw failure('invalid', 'EINVAL', to, 'cannot move a directory into itself');
+        const target = row(to);
+        if (target) {
+            if (moved.kind !== 'directory' && target.kind === 'directory')
+                throw failure('is_directory', 'EISDIR', to, 'illegal operation on a directory');
+            if (moved.kind === 'directory' && target.kind !== 'directory')
+                throw failure('not_directory', 'ENOTDIR', to, 'not a directory');
+            if (target.kind === 'directory' && children(to).length)
+                throw failure('invalid', 'ENOTEMPTY', to, 'directory not empty');
+            db.run('DELETE FROM boring_workspace_files WHERE workspace = ? AND path = ?', workspace, to);
+        }
+        else
+            parent(to);
+        db.run(`UPDATE boring_workspace_files SET path = ? || substr(path, ?), parent = CASE WHEN path = ? THEN ? ELSE ? || substr(parent, ?) END WHERE ${subtree(from)}`, to, from.length + 1, from, dirname(to), to, from.length + 1, ...subtreeArgs(from));
+    }
+    function remove(absolute, options) {
+        const found = row(absolute);
+        if (!found) {
+            if (options?.force)
+                return;
+            throw absent(absolute);
+        }
+        if (absolute === '/' || absolute === fs.cwd)
+            throw failure('permission_denied', 'EPERM', absolute, 'the workspace root cannot be removed');
+        if (found.kind === 'directory' && !options?.recursive && children(absolute).length)
+            throw failure('invalid', 'ENOTEMPTY', absolute, 'directory not empty');
+        touched.add(absolute);
+        db.run(`DELETE FROM boring_workspace_files WHERE ${subtree(absolute)}`, ...subtreeArgs(absolute));
+    }
     const fs = {
         id: `sqlite:${workspace}`, cwd: normalize(options.cwd), incarnation,
         absolutePath: (path, context) => run(path, context, 'read', absolute => absolute),
@@ -298,33 +337,7 @@ export function openSqliteFileSystem(options) {
         // Every write is already a committed SQLite transaction.
         flushFile: (path, context) => run(path, context, 'read', absolute => { existing(absolute); }),
         // One transaction: a reader sees the old or the new path, never both or neither. A directory moves with everything below it.
-        renameFile: (source, destination, context) => run(source, context, 'write', from => {
-            const to = normalize(destination.startsWith('/') ? destination : `${fs.cwd}/${destination}`);
-            const moved = existing(from);
-            if (from === to)
-                return;
-            // A moved file keeps its bytes, so a file (or a file below a moved directory) over the limit cannot replace another file by renaming.
-            const oversized = db.get(`SELECT path, length(bytes) AS size FROM boring_workspace_files WHERE ${subtree(from)} AND kind = 'file' AND length(bytes) > ? LIMIT 1`, ...subtreeArgs(from), maxFileBytes);
-            if (oversized)
-                throw fileTooLarge(oversized.path, Number(oversized.size), maxFileBytes);
-            touched.add(from);
-            touched.add(to);
-            if (from === '/' || within(from, to))
-                throw failure('invalid', 'EINVAL', to, 'cannot move a directory into itself');
-            const target = row(to);
-            if (target) {
-                if (moved.kind !== 'directory' && target.kind === 'directory')
-                    throw failure('is_directory', 'EISDIR', to, 'illegal operation on a directory');
-                if (moved.kind === 'directory' && target.kind !== 'directory')
-                    throw failure('not_directory', 'ENOTDIR', to, 'not a directory');
-                if (target.kind === 'directory' && children(to).length)
-                    throw failure('invalid', 'ENOTEMPTY', to, 'directory not empty');
-                db.run('DELETE FROM boring_workspace_files WHERE workspace = ? AND path = ?', workspace, to);
-            }
-            else
-                parent(to);
-            db.run(`UPDATE boring_workspace_files SET path = ? || substr(path, ?), parent = CASE WHEN path = ? THEN ? ELSE ? || substr(parent, ?) END WHERE ${subtree(from)}`, to, from.length + 1, from, dirname(to), to, from.length + 1, ...subtreeArgs(from));
-        }),
+        renameFile: (source, destination, context) => run(source, context, 'write', from => rename(from, normalize(destination.startsWith('/') ? destination : `${fs.cwd}/${destination}`))),
         fileInfo: (path, context) => run(path, context, 'read', absolute => info(absolute, existing(absolute))),
         listDir: (path, context) => run(path, context, 'read', absolute => {
             directory(absolute);
@@ -415,20 +428,7 @@ export function openSqliteFileSystem(options) {
                 return;
             makeDirectory(absolute, options?.recursive !== false);
         }),
-        remove: (path, options, context) => run(path, context, 'write', absolute => {
-            const found = row(absolute);
-            if (!found) {
-                if (options?.force)
-                    return;
-                throw absent(absolute);
-            }
-            if (absolute === '/' || absolute === fs.cwd)
-                throw failure('permission_denied', 'EPERM', absolute, 'the workspace root cannot be removed');
-            if (found.kind === 'directory' && !options?.recursive && children(absolute).length)
-                throw failure('invalid', 'ENOTEMPTY', absolute, 'directory not empty');
-            touched.add(absolute);
-            db.run(`DELETE FROM boring_workspace_files WHERE ${subtree(absolute)}`, ...subtreeArgs(absolute));
-        }),
+        remove: (path, options, context) => run(path, context, 'write', absolute => remove(absolute, options)),
         createTempDir: (prefix, context) => temporary(prefix ?? 'tmp-', '', 'directory', context),
         createTempFile: (options, context) => temporary(options?.prefix ?? 'tmp-', options?.suffix ?? '', 'file', context),
         cleanup: async () => { },
@@ -439,6 +439,8 @@ 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(); },
+        remove: path => { remove(normalize(path)); notify(); },
     });
     return fs;
 }

package/dist/workspace.d.ts

@@ -1,5 +1,5 @@
 import type { FileSystem } from '@earendil-works/pi-durable/env';
-import type { PublicationLookupResult, PublicationResult, ReadResult, ResourceAccess, ResourceProvider } from './contracts.js';
+import type { PublicationLookupResult, PublicationResult, ReadResult, ResourceAccess, ResourceProvider, ResourceRenamer, ResourceDeleter } from './contracts.js';
 import type { WorkspaceCatalogOptions } from './workspace-catalog.js';
 import type { ChangeFeedRequest, WorkspaceCatalog, WorkspaceChangeEvent } from './revision-contracts.js';
 export type { ChangeFeedRequest, WorkspaceChangeEvent } from './revision-contracts.js';
@@ -42,6 +42,8 @@ export interface WorkspaceResourceProvider extends ResourceProvider {
     readonly reconciliation: {
         readonly lookup: (operationId: string, access: ResourceAccess) => Promise<PublicationLookupResult>;
     };
+    readonly renaming: ResourceRenamer;
+    readonly deletion: ResourceDeleter;
     /** The workspace's mutation queue. Native tool calls that must not interleave with a conditional write run through it. */
     readonly queue: WorkspaceQueue;
     /**

package/dist/workspace.js

@@ -1,7 +1,7 @@
 import { createWorkspaceCatalog } from './workspace-catalog.js';
 import { committedChanges } from './journal.js';
 import { randomUUID, sha1 } from './platform.js';
-import { accessSnapshot, identifier, locator, publicationDigest, publicationSnapshot } from './publication-input.js';
+import { accessSnapshot, identifier, locator, publicationDigest, publicationSnapshot, renameSnapshot, renameDigest, deleteSnapshot, deletePublication } from './publication-input.js';
 import { assertLimit, fileTooLarge } from './file-limits.js';
 import { journalConnectionOf, sqliteBatchOf } from './sqlite-batch.js';
 import { isTemporary, mediaTypeOf, temporaryFileName } from './file-types.js';
@@ -215,23 +215,18 @@ export function createWorkspaceProvider(options) {
             changes: committedChanges(stored.changes, ref),
         };
     }
-    const publish = async (input, context) => {
-        const request = publicationSnapshot(input);
-        const access = accessSnapshot(context);
-        const digest = await publicationDigest(request);
-        if (request.atomicity !== 'all-or-nothing')
+    const mutate = async (request, access) => {
+        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 (request.changes.length !== 1 && !batch)
+        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 = [];
-        for (const change of request.changes) {
-            if (change.kind === 'delete')
-                return { kind: 'unavailable', reason: 'This provider does not delete files through publication' };
-            changes.push(change);
-        }
+        const changes = moving ? [{ kind: 'delete', target: { ...moving.from, revision: moving.expectedRevision } }] : publication.changes;
         const expectations = [
             ...changes.map((change) => change.kind === 'create' ? { kind: 'absent', target: change.target } : { kind: 'revision', target: change.target }),
-            ...(request.preconditions ?? []),
+            ...(moving ? [{ kind: 'absent', target: moving.to }] : publication.preconditions ?? []),
         ];
         if (expectations.some(item => !supported(item.target)))
             return { kind: 'unavailable', reason: 'This provider serves its published view only' };
@@ -253,7 +248,7 @@ export function createWorkspaceProvider(options) {
             // After the receipt and intent checks, so a replay of a committed operation keeps its result under a lower limit.
             const limit = limitOf();
             if (limit !== undefined) {
-                const oversized = changes.find(change => change.bytes.length > limit);
+                const oversized = changes.find((change) => change.kind !== 'delete' && change.bytes.length > limit);
                 if (oversized) {
                     const size = oversized.bytes.length, path = oversized.target.resource.path;
                     return { kind: 'file_too_large', path, size, limit, reason: fileTooLarge(path, size, limit).message };
@@ -300,23 +295,39 @@ export function createWorkspaceProvider(options) {
                         journal.cancel(operation);
                         return { kind: 'denied', reason: forbidden };
                     }
-                    const after = await blobRevision(change.bytes);
+                    const after = change.kind === 'delete' ? null : await blobRevision(change.bytes);
                     const unchanged = change.kind === 'replace' && after === change.target.revision;
                     // The replaced revision was saved when its file was last modified, before this write changes that.
-                    plans.push({ change, path, before: observed.get(path), after, unchanged, beforeSavedAt: change.kind === 'replace' && !unchanged ? await savedAtOf(path, access.signal) : 0 });
+                    plans.push({ change, path, before: observed.get(path), after, unchanged, beforeSavedAt: change.kind !== 'create' && !unchanged ? await savedAtOf(path, access.signal) : 0 });
+                }
+                if (moving) {
+                    const path = moving.to.resource.path;
+                    const forbidden = await escape(path, true, access.signal);
+                    if (forbidden !== undefined) {
+                        journal.cancel(operation);
+                        return { kind: 'denied', reason: forbidden };
+                    }
+                    const before = observed.get(moving.from.resource.path);
+                    if (before?.kind !== 'file')
+                        return refuse('Rename requires a regular file');
+                    if (limit !== undefined && before.bytes.length > limit) {
+                        journal.cancel(operation);
+                        return { kind: 'file_too_large', path, size: before.bytes.length, limit, reason: fileTooLarge(path, before.bytes.length, limit).message };
+                    }
+                    plans.push({ change: { kind: 'create', target: moving.to, expected: { kind: 'absent' }, bytes: before.bytes, mediaType: journal.version(historyScope, moving.from.resource.path, before.revision)?.mediaType ?? mediaTypeOf(moving.from.resource.path) }, path, before: observed.get(path), after: before.revision, unchanged: false, beforeSavedAt: 0 });
                 }
                 const evidence = `${key.incarnation}:${randomUUID()}`;
                 const versions = plans.flatMap(({ change, path, before, after, unchanged, beforeSavedAt }) => {
                     const kept = (revision, bytes, mediaType, savedAt, source) => ({ scope: historyScope, path, version: { revision, bytes, mediaType, savedAt, source } });
                     return unchanged ? [] : [
-                        ...(change.kind === 'replace' && before?.kind === 'file'
-                            ? [kept(before.revision, before.bytes, journal.version(historyScope, path, before.revision)?.mediaType ?? mediaTypeOf(path), beforeSavedAt, 'observed')] : []),
-                        kept(after, change.bytes, change.mediaType, Date.now(), 'publish'),
+                        ...(change.kind !== 'create' && before?.kind === 'file'
+                            ? [kept(before.revision, before.bytes, journal.version(historyScope, path, before.revision)?.mediaType ?? mediaTypeOf(path), beforeSavedAt, moving ? 'rename' : change.kind === 'delete' ? 'delete' : 'observed')] : []),
+                        ...(change.kind !== 'delete' && after !== null ? [kept(after, change.bytes, change.mediaType, Date.now(), moving ? 'rename' : 'publish')] : []),
                     ];
                 });
                 const record = {
                     digest, evidence,
-                    changes: plans.map(({ change, path, after }) => change.kind === 'create' ? { kind: 'create', path, before: null, after } : { kind: 'replace', path, before: change.target.revision, after }),
+                    changes: plans.map(({ change, path, after }) => change.kind === 'create' ? { kind: 'create', path, before: null, after } : { kind: change.kind, path, before: change.target.revision, after }),
                 };
                 if (access.signal?.aborted)
                     return refuse('The save was cancelled before any change');
@@ -331,9 +342,16 @@ export function createWorkspaceProvider(options) {
                         }).map(([path]) => path);
                         if (changed.length)
                             return changed;
-                        for (const plan of plans)
-                            if (!plan.unchanged)
-                                batch.write(absolute(plan.path), plan.change.bytes);
+                        if (moving)
+                            batch.rename(absolute(moving.from.resource.path), absolute(moving.to.resource.path));
+                        else
+                            for (const plan of plans)
+                                if (!plan.unchanged) {
+                                    if (plan.change.kind === 'delete')
+                                        batch.remove(absolute(plan.path));
+                                    else
+                                        batch.write(absolute(plan.path), plan.change.bytes);
+                                }
                         if (together)
                             journal.complete(operation, record, versions);
                         return [];
@@ -347,8 +365,22 @@ export function createWorkspaceProvider(options) {
                     if (!together)
                         journal.complete(operation, record, versions);
                 }
+                else if (moving || plans[0].change.kind === 'delete') {
+                    applying = true;
+                    const result = moving
+                        ? await fs.renameFile(absolute(moving.from.resource.path), absolute(moving.to.resource.path), 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')
+                            throw result.error;
+                        return refuse(result.error.message);
+                    }
+                    journal.complete(operation, record, versions);
+                }
                 else {
                     const { change, path, unchanged } = plans[0];
+                    if (change.kind === 'delete')
+                        return refuse('Invalid file replacement');
                     if (!unchanged) {
                         applying = true;
                         const target = absolute(path);
@@ -385,6 +417,9 @@ 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 lookup = async (operationId, context) => {
         const id = identifier(operationId);
         const access = accessSnapshot(context);
@@ -626,7 +661,7 @@ export function createWorkspaceProvider(options) {
     return {
         providerId, read, queue, keep, identity: Object.freeze(key),
         catalog: createWorkspaceCatalog({ fs, ...(options.catalog ? { config: options.catalog } : {}), saves: path => journal.saves(historyScope, path) }),
-        publication: { publish }, reconciliation: { lookup }, poll, record, changes, changeHead: () => head, changeIncarnation: incarnationOfFeed,
+        publication: { publish }, reconciliation: { lookup }, renaming: { rename }, deletion: { delete: remove }, poll, record, changes, changeHead: () => head, changeIncarnation: incarnationOfFeed,
         lifetime: lifetime.signal,
         close: () => {
             // Every change stream ends, the watcher closes and the listeners are dropped: nothing of this provider keeps running.
@@ -646,7 +681,7 @@ export function createWorkspaceProvider(options) {
         capabilities: async (input) => {
             const selected = locator(input);
             const ok = supported(selected);
-            const actions = ['read', 'create', 'replace', 'lookup'];
+            const actions = ['read', 'create', 'replace', 'delete', 'rename', 'lookup'];
             return {
                 supported: ok ? actions : [], effective: ok ? actions : [], availability: ok ? 'available' : 'unavailable', observedAt: new Date().toISOString(),
                 guarantees: { pinnedReads: true, conditionalPublication: true, atomicMutationAndReceipt: batch !== undefined && journalConnectionOf(journal) === batch.connection, atomicBatch: batch !== undefined, operationLookup: true, revocationFencing: false },

package/package.json

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