@push.rocks/smartdb 5.0.5 → 5.2.0

package/dist_ts/ts_smartdb/server/SmartdbServer.js

@@ -1,6 +1,7 @@
 import { RustDbBridge, SmartDbManagementOperationTerminationError, } from '../rust-db-bridge.js';
 import { AuthMetadataMigrationRunner, SmartDbStorageMigrationCleanupError, StorageMigrator, } from '../../ts_migration/index.js';
 import { validateSmartDbManagementOperationOptions } from '../offline-inspection.js';
+import { assertNoLocalSmartDbStorageRootRelocationWorkspace } from '../storage-root-relocation.js';
 /**
  * SmartdbServer - Wire protocol compatible database server backed by Rust
  *
@@ -115,6 +116,8 @@ export class SmartdbServer {
             checkpoint();
             // Run storage migration for file-based storage before starting Rust engine
             if (this.options.storage === 'file' && this.options.storagePath) {
+                await assertNoLocalSmartDbStorageRootRelocationWorkspace(this.options.storagePath);
+                checkpoint();
                 const migrator = new StorageMigrator(this.options.storagePath);
                 await migrator.run(startupAbortController.signal);
                 checkpoint();
@@ -448,4 +451,4 @@ export class SmartdbServer {
         return `mongodb://${auth}${host}/${encodeURIComponent(databaseName)}?${query.toString()}`;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SmartdbServer.js","sourceRoot":"","sources":["../../../ts/ts_smartdb/server/SmartdbServer.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SmartdbServer.js","sourceRoot":"","sources":["../../../ts/ts_smartdb/server/SmartdbServer.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts_smartdb/storage-root-relocation.d.ts

@@ -0,0 +1,27 @@
+export declare const localSmartDbStorageRootRelocationErrorCodes: readonly ["INVALID_REQUEST", "UNSUPPORTED", "BUSY", "NOT_FOUND", "DESTINATION_CONFLICT", "IDENTITY_MISMATCH", "STATE_CORRUPT", "IO", "RECOVERY_REQUIRED"];
+export type TLocalSmartDbStorageRootRelocationErrorCode = (typeof localSmartDbStorageRootRelocationErrorCodes)[number];
+export interface ILocalSmartDbStoppedStorageRootRelocationInput {
+    sourceFolderPath: string;
+    destinationFolderPath: string;
+    relocationId: string;
+}
+export interface ILocalSmartDbStoppedStorageRootRelocationReceipt {
+    format: 'smartdb.storage-root-relocation.receipt.v1';
+    version: 1;
+    relocationId: string;
+    sourceFolderPath: string;
+    destinationFolderPath: string;
+    providerRootId: string;
+    storageRootDevice: string;
+    storageRootInode: string;
+    receiptSha256: string;
+    sourceReceiptRetained: true;
+}
+export declare class LocalSmartDbStorageRootRelocationError extends Error {
+    readonly code: TLocalSmartDbStorageRootRelocationErrorCode;
+    constructor(codeArg: TLocalSmartDbStorageRootRelocationErrorCode);
+}
+export declare const normalizeLocalSmartDbStoppedStorageRootRelocationInput: (inputArg: ILocalSmartDbStoppedStorageRootRelocationInput) => ILocalSmartDbStoppedStorageRootRelocationInput;
+export declare const normalizeLocalSmartDbStoppedStorageRootRelocationReceipt: (valueArg: unknown, inputArg: ILocalSmartDbStoppedStorageRootRelocationInput) => ILocalSmartDbStoppedStorageRootRelocationReceipt;
+export declare const assertNoLocalSmartDbStorageRootRelocationWorkspace: (storagePathArg: string) => Promise<void>;
+export declare const isLocalSmartDbStorageRootRelocationErrorCode: (valueArg: unknown) => valueArg is TLocalSmartDbStorageRootRelocationErrorCode;

package/dist_ts/ts_smartdb/storage-root-relocation.js

@@ -0,0 +1,211 @@
+import * as plugins from './plugins.js';
+export const localSmartDbStorageRootRelocationErrorCodes = [
+    'INVALID_REQUEST',
+    'UNSUPPORTED',
+    'BUSY',
+    'NOT_FOUND',
+    'DESTINATION_CONFLICT',
+    'IDENTITY_MISMATCH',
+    'STATE_CORRUPT',
+    'IO',
+    'RECOVERY_REQUIRED',
+];
+export class LocalSmartDbStorageRootRelocationError extends Error {
+    constructor(codeArg) {
+        super(`SmartDB stopped storage-root relocation failed with code ${codeArg}`);
+        this.name = 'LocalSmartDbStorageRootRelocationError';
+        this.code = codeArg;
+    }
+}
+const relocationInputKeys = [
+    'sourceFolderPath',
+    'destinationFolderPath',
+    'relocationId',
+];
+const relocationReceiptKeys = [
+    'format',
+    'version',
+    'relocationId',
+    'sourceFolderPath',
+    'destinationFolderPath',
+    'providerRootId',
+    'storageRootDevice',
+    'storageRootInode',
+    'receiptSha256',
+    'sourceReceiptRetained',
+];
+const maximumFolderPathBytes = 4095;
+const maximumRelocationIdBytes = 256;
+const maximumU64Decimal = '18446744073709551615';
+const receiptDigestDomain = 'smartdb.storage-root-relocation.receipt.v1\0';
+const relocationError = (codeArg) => new LocalSmartDbStorageRootRelocationError(codeArg);
+const isPlainExactDataObject = (valueArg, keysArg) => {
+    if (typeof valueArg !== 'object'
+        || valueArg === null
+        || Array.isArray(valueArg)
+        || Object.getPrototypeOf(valueArg) !== Object.prototype) {
+        return false;
+    }
+    const ownKeys = Reflect.ownKeys(valueArg);
+    if (ownKeys.length !== keysArg.length
+        || ownKeys.some((keyArg) => typeof keyArg !== 'string' || !keysArg.includes(keyArg))) {
+        return false;
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(valueArg);
+    return keysArg.every((keyArg) => {
+        const descriptor = descriptors[keyArg];
+        return descriptor !== undefined
+            && descriptor.enumerable
+            && Object.prototype.hasOwnProperty.call(descriptor, 'value');
+    });
+};
+const isValidUnicodeScalarString = (valueArg) => {
+    for (let index = 0; index < valueArg.length; index++) {
+        const code = valueArg.charCodeAt(index);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const next = valueArg.charCodeAt(index + 1);
+            if (next < 0xdc00 || next > 0xdfff)
+                return false;
+            index++;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            return false;
+        }
+    }
+    return true;
+};
+const isNestedPath = (parentArg, childArg) => {
+    const relative = plugins.path.relative(parentArg, childArg);
+    return relative !== ''
+        && relative !== '..'
+        && !relative.startsWith(`..${plugins.path.sep}`)
+        && !plugins.path.isAbsolute(relative);
+};
+const normalizeFolderPath = (valueArg) => {
+    if (typeof valueArg !== 'string'
+        || !plugins.path.isAbsolute(valueArg)
+        || !isValidUnicodeScalarString(valueArg)
+        || [...valueArg].some(characterArg => /\p{Cc}/u.test(characterArg))) {
+        throw relocationError('INVALID_REQUEST');
+    }
+    const initialBytes = plugins.buffer.Buffer.byteLength(valueArg, 'utf8');
+    if (initialBytes < 1 || initialBytes > maximumFolderPathBytes) {
+        throw relocationError('INVALID_REQUEST');
+    }
+    const normalized = plugins.path.resolve(valueArg);
+    const normalizedBytes = plugins.buffer.Buffer.byteLength(normalized, 'utf8');
+    if (normalizedBytes < 1
+        || normalizedBytes > maximumFolderPathBytes
+        || plugins.path.parse(normalized).root === normalized
+        || !isValidUnicodeScalarString(normalized)
+        || [...normalized].some(characterArg => /\p{Cc}/u.test(characterArg))) {
+        throw relocationError('INVALID_REQUEST');
+    }
+    return normalized;
+};
+export const normalizeLocalSmartDbStoppedStorageRootRelocationInput = (inputArg) => {
+    if (!isPlainExactDataObject(inputArg, relocationInputKeys)) {
+        throw relocationError('INVALID_REQUEST');
+    }
+    const sourceFolderPath = normalizeFolderPath(inputArg.sourceFolderPath);
+    const destinationFolderPath = normalizeFolderPath(inputArg.destinationFolderPath);
+    const sourceFolderPathBytes = plugins.buffer.Buffer.byteLength(sourceFolderPath, 'utf8');
+    const destinationFolderPathBytes = plugins.buffer.Buffer.byteLength(destinationFolderPath, 'utf8');
+    if (sourceFolderPath === destinationFolderPath
+        || isNestedPath(sourceFolderPath, destinationFolderPath)
+        || isNestedPath(destinationFolderPath, sourceFolderPath)
+        || destinationFolderPathBytes > sourceFolderPathBytes) {
+        throw relocationError('INVALID_REQUEST');
+    }
+    if (typeof inputArg.relocationId !== 'string'
+        || plugins.buffer.Buffer.byteLength(inputArg.relocationId, 'utf8') > maximumRelocationIdBytes
+        || !/^[A-Za-z0-9][A-Za-z0-9._:@-]*$/.test(inputArg.relocationId)) {
+        throw relocationError('INVALID_REQUEST');
+    }
+    return {
+        sourceFolderPath,
+        destinationFolderPath,
+        relocationId: inputArg.relocationId,
+    };
+};
+const receiptDigest = (receiptArg) => plugins.crypto
+    .createHash('sha256')
+    .update(receiptDigestDomain, 'utf8')
+    .update(JSON.stringify(receiptArg), 'utf8')
+    .digest('hex');
+const isCanonicalU64Decimal = (valueArg) => typeof valueArg === 'string'
+    && /^(?:0|[1-9][0-9]{0,19})$/.test(valueArg)
+    && (valueArg.length < 20 || valueArg <= maximumU64Decimal);
+const isLowercaseSha256 = (valueArg) => typeof valueArg === 'string' && /^[0-9a-f]{64}$/.test(valueArg);
+export const normalizeLocalSmartDbStoppedStorageRootRelocationReceipt = (valueArg, inputArg) => {
+    if (!isPlainExactDataObject(valueArg, relocationReceiptKeys)) {
+        throw relocationError('RECOVERY_REQUIRED');
+    }
+    const receipt = valueArg;
+    if (receipt.format !== 'smartdb.storage-root-relocation.receipt.v1'
+        || receipt.version !== 1
+        || receipt.relocationId !== inputArg.relocationId
+        || receipt.sourceFolderPath !== inputArg.sourceFolderPath
+        || receipt.destinationFolderPath !== inputArg.destinationFolderPath
+        || !isLowercaseSha256(receipt.providerRootId)
+        || !isCanonicalU64Decimal(receipt.storageRootDevice)
+        || !isCanonicalU64Decimal(receipt.storageRootInode)
+        || !isLowercaseSha256(receipt.receiptSha256)
+        || receipt.sourceReceiptRetained !== true) {
+        throw relocationError('RECOVERY_REQUIRED');
+    }
+    const withoutDigest = {
+        format: receipt.format,
+        version: receipt.version,
+        relocationId: receipt.relocationId,
+        sourceFolderPath: receipt.sourceFolderPath,
+        destinationFolderPath: receipt.destinationFolderPath,
+        providerRootId: receipt.providerRootId,
+        storageRootDevice: receipt.storageRootDevice,
+        storageRootInode: receipt.storageRootInode,
+        sourceReceiptRetained: receipt.sourceReceiptRetained,
+    };
+    if (receiptDigest(withoutDigest) !== receipt.receiptSha256) {
+        throw relocationError('RECOVERY_REQUIRED');
+    }
+    return { ...withoutDigest, receiptSha256: receipt.receiptSha256 };
+};
+export const assertNoLocalSmartDbStorageRootRelocationWorkspace = async (storagePathArg) => {
+    const storagePath = plugins.path.resolve(storagePathArg);
+    const internalPath = plugins.path.join(storagePath, '.__rustdb_internal');
+    const workspacePath = plugins.path.join(internalPath, 'storage-root-relocation');
+    try {
+        const storage = await plugins.fs.stat(storagePath);
+        if (!storage.isDirectory()) {
+            throw new Error('not a directory');
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw new Error('SmartDB storage-root relocation workspace inspection is ambiguous');
+    }
+    try {
+        const internal = await plugins.fs.lstat(internalPath);
+        if (internal.isSymbolicLink() || !internal.isDirectory()) {
+            throw new Error('not a safe directory');
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw new Error('SmartDB storage-root relocation workspace inspection is ambiguous');
+    }
+    try {
+        await plugins.fs.lstat(workspacePath);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw new Error('SmartDB storage-root relocation workspace inspection is ambiguous');
+    }
+    throw new Error('SmartDB storage-root relocation recovery must complete before startup');
+};
+export const isLocalSmartDbStorageRootRelocationErrorCode = (valueArg) => typeof valueArg === 'string'
+    && localSmartDbStorageRootRelocationErrorCodes.includes(valueArg);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage-root-relocation.js","sourceRoot":"","sources":["../../ts/ts_smartdb/storage-root-relocation.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartdb",
-  "version": "5.0.5",
+  "version": "5.2.0",
   "private": false,
   "description": "A MongoDB-compatible embedded database server with wire protocol support, backed by a high-performance Rust engine.",
   "exports": {
@@ -17,7 +17,7 @@
     "@git.zone/tsbuild": "^4.4.2",
     "@git.zone/tsbundle": "^2.11.4",
     "@git.zone/tsrun": "^2.0.6",
-    "@git.zone/tsrust": "^1.8.0",
+    "@git.zone/tsrust": "^1.9.1",
     "@git.zone/tstest": "^4.0.0",
     "@types/node": "26.2.0",
     "mongodb": "^7.5.0"
@@ -31,6 +31,7 @@
   ],
   "files": [
     "ts/**/*",
+    "scripts/**/*",
     "ts_web/**/*",
     "dist/**/*",
     "dist_*/**/*",
@@ -45,7 +46,9 @@
   "publishConfig": {
     "executableFiles": [
       "./dist_rust/rustdb_linux_amd64",
-      "./dist_rust/rustdb_linux_arm64"
+      "./dist_rust/rustdb_linux_arm64",
+      "./dist_rust/rustdb_macos_amd64",
+      "./dist_rust/rustdb_macos_arm64"
     ]
   },
   "keywords": [
@@ -71,6 +74,8 @@
     "test": "(tstest test/. --verbose --logfile --timeout 60)",
     "test:rust": "(cd rust && cargo test)",
     "build": "(tsbundle) && (tsbuild tsfolders) && (tsrust)",
-    "buildDocs": "tsdoc"
+    "buildDocs": "tsdoc",
+    "release:check-builders": "tsrun scripts/release-artifacts.ts check",
+    "release:build-artifacts": "tsrun scripts/release-artifacts.ts build"
   }
 }

package/readme.hints.md

@@ -1,5 +1,14 @@
 # smartdb hints
 
+## Stopped Storage-Root Relocation
+
+- `LocalSmartDb.relocateStoppedStorageRoot()` is the only supported path-changing operation. It uses a dedicated serialized mutating sidecar runner; do not route it through the disposable offline-inspection helper. A bridge whose termination is unconfirmed remains in the static cleanup gate, and no later relocation may spawn until cleanup succeeds.
+- Rust owns the descriptor-relative operation in `rust/crates/rustdb/src/storage_root_relocation.rs`. It never constructs `RustDb`. The fixed journal phases are `preparing`, `prepared`, `exchanged`, `providerPublished`, `sentinelPublished`, and `cleaned`; retries reconcile the exact source-root/destination-absent-or-receipt topology or source-receipt/destination-root topology before continuing.
+- The destination receipt is published with an exclusive rename, then exchanged with the source root using an atomic swap (`RENAME_NOREPLACE`/`RENAME_EXCHANGE` on Linux and `RENAME_EXCL`/`RENAME_SWAP` on macOS). Provider and sentinel replacement also uses checked exchanges, retaining each previous object in the workspace until the replacement is durable and verified. The original root inode ends at the destination and the original receipt inode remains at the source indefinitely. Parent, root, internal, lock, provider, and sentinel identities are revalidated around publication.
+- Eligibility is intentionally narrow: Linux on the existing supported local-filesystem set or macOS on qualified local APFS, exact current owner/provider/sentinel metadata, no auth path digest, and no resource receipt, allocation, retired lock, durable database/transaction workspace, database marker, symlink, unknown entry, or unsafe ownership/mode/link profile. macOS additionally rejects case, Unicode, mount, and ancestry aliases by retained physical identity. Missing metadata is rejected and never initialized by relocation.
+- Both TypeScript startup paths check for `.__rustdb_internal/storage-root-relocation` before `StorageMigrator`. Rust checks immediately after securely opening an existing root and repeats the descriptor-relative check after acquiring the owner lock, before storage initialization. This closes the interval where a relocation can create its workspace and release the lock after startup's first inspection. Occupancy or inspection ambiguity is a startup error; only an exact relocation retry performs recovery.
+- Completed roots retain the SmartDB 5.0.1 provider/sentinel JSON shape, changing only their storage-root path digest. Interrupted Linux state requires 5.1.0 or newer; interrupted macOS state requires a macOS-capable release. Exact replay lasts only while the destination remains current; a later relocation supersedes the old source/destination tuple.
+
 ## Restricted Deny-All Views
 
 - `rustdb-commands/src/views.rs` is the sole owner of `system.views` parsing, bounds, canonical `_id_` metadata validation, exact deny-all pipeline validation, and authoritative namespace classification. There is intentionally no mutable cross-command view cache; aggregate and transaction commit reuse one immutable authoritative catalog per database for that operation.
@@ -30,8 +39,9 @@
 
 ## Static Rust Binaries
 
-- The Rust binaries in `dist_rust/` are statically linked (static-pie) via `"static": true` in the `@git.zone/tsrust` block of `.smartconfig.json` (tsrust >= 1.4.1). They run on both glibc (Debian/Ubuntu) and musl (Alpine) systems.
+- The Linux Rust binaries in `dist_rust/` are statically linked (static-pie) via `"static": true` in the `@git.zone/tsrust` block of `.smartconfig.json` (tsrust >= 1.4.1). They run on both glibc (Debian/Ubuntu) and musl (Alpine) systems. The macOS amd64 and arm64 binaries use the normal Apple platform linkage.
 - tsrust injects `RUSTFLAGS="-C target-feature=+crt-static"` only into its own per-target cargo invocations and verifies the result (no `PT_INTERP` ELF header). Keep `rust/.cargo/config.toml` free of `rustflags` entries: the injected env variable would replace them, and a repo-wide `rustflags` would also break plain `cargo test`/`cargo check` (proc-macros cannot build with `+crt-static` on linux-gnu without an explicit `--target`). The repo previously carried such `rustflags` lines; they were removed when the tsrust `static` option was adopted.
 - `pnpm run test:rust` runs the Rust unit tests; plain `cargo test` in `rust/` works as well.
 - Verify linkage manually with `ldd dist_rust/<binary>_linux_amd64` → "statically linked".
 - Do NOT verify feature presence in release binaries with `strings`/`grep`: on x86_64 release builds LLVM embeds short string literals (≤16 bytes, e.g. BSON doc keys like `volatileOnly`) as instruction immediates, so they are invisible to byte scans while the aarch64 binary shows them in `.rodata`. This produces false "stale binary" alarms. Verify behavior by running the binary (the wire tests spawn the host-arch binary from `dist_rust/`), or disassemble: `objdump -d <bin> | grep <hex-of-literal-LE>`.
+- Release builds use tsrust 1.9 host partitions and strict sidecar assembly. The enabled gitzone test preflight compiles and executes a static Linux arm64 probe through `binfmt` and checks macOS Rosetta before versioning. The post-version build transfers exact HEAD by Git bundle, executes all four target binaries, and assembles separate Linux and macOS inputs. Remote cleanup is limited to the unique sentinel-owned child below `SMARTDB_RELEASE_MACOS_TEMP_ROOT`.

package/readme.md

@@ -358,7 +358,7 @@ Single-node transactions are supported through official MongoDB driver sessions.
 
 ### Durable Database Publication Holds
 
-File-backed SmartDB can keep a replaced or deleted database closed after the local mutation is durable and until a downstream coordinator confirms its own fsync. Check the explicit health contract before using this flow:
+On Linux, file-backed SmartDB can keep a replaced or deleted database closed after the local mutation is durable and until a downstream coordinator confirms its own fsync. Check the explicit health contract before using this flow:
 
 ```typescript
 const health = await server.getHealth();
@@ -400,6 +400,8 @@ const released = await server.commitDatabasePublication({
 
 The held barrier survives restart and blocks wire commands, transactions, startup recovery, compaction, index restoration, and close-time hint writes for that database while unrelated databases remain available. Commit is exact and idempotent. A successful commit removes the raw capability from durable state and retains only protected verification material. Provider/root identity, durable fenced-mode markers, and bounded startup validation make copied, missing, corrupt, or legacy-active publication state fail closed. A higher fencing token compacts resolved older receipts, so long-lived coordinators do not exhaust receipt capacity.
 
+Durable database publication holds and allocation fencing remain Linux-only. The macOS support described under stopped storage-root relocation does not enable these runtime mutation features.
+
 Coordinators that do not yet have their own durable record can call `getDatabaseResourceFenceState({ databaseName })` before creating it. File-backed SmartDB returns the durable scope, highest token, current publication phase, and allocation lifecycle/identity when the name is allocation-managed, or `null` only when both fence state and its durable marker are absent. The inspection never returns mutation IDs, mutation payload digests, publication receipts, or publication capabilities. Treat any active phase, identity mismatch, corrupt state, unsupported storage, or unsafe token as a hard stop rather than creating coordinator state.
 
 ### Authoritative Database Allocation
@@ -539,9 +541,59 @@ const db = new LocalSmartDb({
 | `getConnectionUri()` | `string` | Get the connection URI |
 | `getServer()` | `SmartdbServer` | Access the underlying server |
 | `running` | `boolean` | Whether the server is running |
+| `LocalSmartDb.relocateStoppedStorageRoot(input, options?)` | `Promise<ILocalSmartDbStoppedStorageRootRelocationReceipt>` | Atomically relocate one eligible stopped Linux or macOS file-storage root and retain a source receipt |
 | `LocalSmartDb.inspectOfflineStringValue(input, options?)` | `Promise<TLocalSmartDbOfflineStringValueInspectionResult>` | Read one exact top-level string value from stopped file storage without starting or mutating the engine |
 | `LocalSmartDb.inspectOfflinePhysicalNamespaces(input, options?)` | `Promise<ILocalSmartDbOfflinePhysicalNamespaceInspectionResult>` | Validate stopped physical file storage and return only deterministic database and collection names |
 
+#### Stopped Storage-Root Relocation
+
+`relocateStoppedStorageRoot()` moves an eligible stopped file-storage root without starting `RustDb`, binding a listener, running a TypeScript migration, initializing storage or auth, or performing WAL recovery. It supports Linux on the existing qualified local-filesystem set and macOS on writable local APFS volumes with ownership, persistent object identities, `flock`, and atomic exclusive/swap rename support. The source root, source parent, and destination parent must be trusted descriptor-safe objects on the same filesystem. The supplied source and destination must be absolute and resolve to distinct, non-root, non-nested physical paths, and the destination must be absent. macOS also rejects case-folded, Unicode-normalized, and ancestry aliases before creating relocation state. The trusted parents may differ.
+
+```typescript
+import { LocalSmartDb } from '@push.rocks/smartdb';
+
+const receipt = await LocalSmartDb.relocateStoppedStorageRoot({
+  sourceFolderPath: '/var/lib/myapp/harness-controller/smartdb',
+  destinationFolderPath: '/var/lib/myapp/hcon/smartdb',
+  relocationId: 'move-2026-08-17-1',
+}, {
+  timeoutMs: 30_000,
+});
+
+// Start only the destination. The source is now the retained receipt file.
+const db = new LocalSmartDb({ folderPath: receipt.destinationFolderPath });
+await db.start();
+```
+
+The input must be a plain object with exactly the own enumerable data fields `sourceFolderPath`, `destinationFolderPath`, and `relocationId`. Each supplied path must already be absolute, is normalized before sidecar creation, is limited to 1 through 4095 UTF-8 bytes, and cannot contain control characters. The normalized destination path may not be longer in UTF-8 bytes than the normalized source path, so every root-relative path accepted by SmartDB 5.0.1 at the source remains no longer after relocation. `relocationId` is a 1 through 256-byte ASCII identifier beginning with an alphanumeric character and otherwise using only alphanumerics, `.`, `_`, `:`, `@`, or `-`. Management `timeoutMs` and `signal` use the same validation and one-deadline behavior as other SmartDB management operations.
+
+The returned exact receipt has this shape:
+
+```typescript
+interface ILocalSmartDbStoppedStorageRootRelocationReceipt {
+  format: 'smartdb.storage-root-relocation.receipt.v1';
+  version: 1;
+  relocationId: string;
+  sourceFolderPath: string;
+  destinationFolderPath: string;
+  providerRootId: string;
+  storageRootDevice: string; // canonical decimal u64
+  storageRootInode: string;  // canonical decimal u64
+  receiptSha256: string;
+  sourceReceiptRetained: true;
+}
+```
+
+On success, the destination directory is the original storage-root inode and the source path is an exact mode-0600 regular-file receipt. SmartDB does not remove that source receipt. Data, WAL, hint, and index bytes are not copied or rewritten. `providerRootId`, root device/inode, and every provider/sentinel field are preserved; only `storageRootSha256` changes to the destination's canonical path digest. This leaves a completed destination compatible with SmartDB 5.0.1.
+
+Relocation deliberately supports only the plain, unbound `LocalSmartDb` topology. The existing owner lock, `provider-identity.json`, and resource-fencing sentinel must all be present; the operation never creates missing ownership metadata. A provider identity containing `authUsersPathSha256` is unsupported. Any durable fence receipt or capability, allocation state, retired fence lock, database mutation/transaction journal, allocation/publication marker, symlink, unknown entry, unsafe mode/owner/link count, exhausted scan bound, active owner, or ambiguous identity fails closed.
+
+The operation journals phases `preparing`, `prepared`, `exchanged`, `providerPublished`, `sentinelPublished`, and `cleaned`. If a call returns `RECOVERY_REQUIRED`, stop all startup attempts and retry the exact same normalized source path, destination path, and `relocationId` with the same SmartDB version that began the relocation or a newer version. Startup rejects any relocation-workspace occupancy and does not mutate or recover it. Do not delete, rename, edit, or replace either path between attempts. Linux relocation state created by SmartDB 5.1.0 remains recoverable by 5.1.0 or newer; macOS recovery requires a macOS-capable release. A completed root remains 5.0.1-compatible.
+
+An exact completed replay returns the same receipt only while the destination remains the current root. A later successful relocation leaves another receipt at that destination path and supersedes the earlier replay topology; retry the later operation instead. Manual copy or rename remains unsupported and continues to fail provider path/inode fencing.
+
+Failures are exposed as `LocalSmartDbStorageRootRelocationError` with a code-only union: `INVALID_REQUEST`, `UNSUPPORTED`, `BUSY`, `NOT_FOUND`, `DESTINATION_CONFLICT`, `IDENTITY_MISMATCH`, `STATE_CORRUPT`, `IO`, or `RECOVERY_REQUIRED`. Error messages and causes do not include supplied paths. Timeout, abort, write, exit, or malformed-response failures after command dispatch are always `RECOVERY_REQUIRED`; exact retry is the only recovery action.
+
 #### Offline String-Value Inspection
 
 `inspectOfflineStringValue()` is a Linux-only operational API for reading one metadata value while the owning `LocalSmartDb` engine is stopped. Other platforms reject the call because the reader requires Linux `openat2` descriptor traversal. It starts only the Rust management sidecar: it does not start a database listener, run storage migrations, repair tails, replay or truncate the WAL, compact data, or persist hints.
@@ -959,7 +1011,27 @@ The Rust engine is organized as a Cargo workspace with 9 focused crates:
 | `rustdb-auth` | SCRAM-SHA-256 credential handling, user metadata persistence, RBAC checks |
 | `rustdb-commands` | 40+ command handlers wiring everything together |
 
-Cross-compiled for `linux_amd64` and `linux_arm64` via [@git.zone/tsrust](https://www.npmjs.com/package/@git.zone/tsrust).
+Cross-compiled for `linux_amd64`, `linux_arm64`, `macos_amd64`, and `macos_arm64` via [@git.zone/tsrust](https://www.npmjs.com/package/@git.zone/tsrust).
+
+### Multi-host release artifacts
+
+Normal `tsrust` builds select only the current host's partition from `targetsByHost`. Releases coordinate both partitions after the version commit exists, then publish only after every exact-commit binary has executed and passed strict provenance assembly.
+
+The release coordinator must be Linux amd64 with `aarch64-linux-gnu-gcc` and a registered Linux arm64 `binfmt` interpreter. Set these environment variables to an authorized Apple Silicon builder with Rosetta and a dedicated temporary root:
+
+```bash
+export SMARTDB_RELEASE_MACOS_SSH="release-user@mac-builder.example"
+export SMARTDB_RELEASE_MACOS_TEMP_ROOT="/absolute/dedicated/smartdb-release"
+```
+
+`gitzone release` first runs `pnpm run release:check-builders`, before creating a version commit or tag. It compiles and executes a static arm64 probe and rejects missing cross-toolchain or `binfmt` execution, an unsuitable macOS host, missing Rosetta, missing tools, or an unwritable remote temporary root. The release build then:
+
+1. Builds and executes the Linux amd64 and arm64 binaries.
+2. Transfers a Git bundle of the unpushed release commit into a unique sentinel-owned macOS workspace.
+3. Builds both Darwin targets from the frozen lockfile, verifies their Cargo bytes and signatures, and executes both architectures.
+4. Copies each host output into separate `.nogit` inputs and runs strict `tsrust assemble` into `dist_rust/`.
+
+No host address or path is stored in the repository. A failed run retains its unique diagnostic directories and prints their paths. Successful cleanup can remove only the generated child whose path and random ownership sentinel both match.
 
 ### Storage Engine Reliability 🔒
 

package/readme.plan.md

@@ -287,7 +287,7 @@ Every applicable release must pass the narrowest relevant set of these gates:
 - deterministic persistence failpoints and randomized process-kill tests
 - storage/index/content-digest reconciliation after recovery
 - 24-hour nightly and 72-hour release-candidate resource soaks
-- both published Linux architectures
+- all published Linux and macOS architectures
 - automated backup/restore drills once backup exists
 - partition, failover, and history verification once replication exists
 - supply-chain, provenance, security, upgrade, and rollback checks for managed tiers