@bendyline/docblocks 2.0.0 → 2.1.0

package/dist/{chunk-J32GU3F3.js → chunk-6IYMTYMQ.js}

@@ -2,8 +2,21 @@ import {
   withFileCommitLock
 } from "./chunk-AEHCVWU5.js";
 import {
+  parentChainWithRoot
+} from "./chunk-GM5YXU4L.js";
+import {
+  isRecord
+} from "./chunk-U722UUFN.js";
+import {
+  bytesEqual,
+  compareSnapshotsByName,
+  compareText,
+  copyBytes,
   parseFileSystemVersion
-} from "./chunk-AYZ4HN5M.js";
+} from "./chunk-P4WATND4.js";
+import {
+  decodeUtf8Text
+} from "./chunk-FA7UNOXK.js";
 import {
   FsError,
   WORKSPACE_ROOT,
@@ -12,160 +25,19 @@ import {
   workspacePathBasename,
   workspacePathContains,
   workspacePathDirname
-} from "./chunk-SI2LU2RP.js";
-
-// src/filesystem/indexeddb-store.ts
-var RawIndexedDBFileSystemStore = class {
-  constructor(databaseName, storeName) {
-    this.databaseName = databaseName;
-    this.storeName = storeName;
-    this.database = null;
-    this.opening = null;
-    this.closed = false;
-  }
-  async transaction(mode, operation) {
-    const database = await this.getDatabase();
-    const nativeTransaction = database.transaction(this.storeName, mode);
-    const completion = waitForTransaction(nativeTransaction);
-    const transaction = new RawIndexedDBFileSystemTransaction(
-      nativeTransaction.objectStore(this.storeName)
-    );
-    let result;
-    try {
-      result = await operation(transaction);
-    } catch (error) {
-      try {
-        nativeTransaction.abort();
-      } catch {
-      }
-      await completion.catch(() => void 0);
-      throw error;
-    }
-    await completion;
-    return result;
-  }
-  close() {
-    if (this.closed) return;
-    this.closed = true;
-    this.database?.close();
-    this.database = null;
-    this.opening = null;
-  }
-  getDatabase() {
-    if (this.closed) {
-      return Promise.reject(new Error("The IndexedDB filesystem store is closed."));
-    }
-    if (this.database) return Promise.resolve(this.database);
-    if (this.opening) return this.opening;
-    if (typeof indexedDB === "undefined") {
-      return Promise.reject(new Error("IndexedDB is not available in this environment."));
-    }
-    this.opening = openDatabaseWithStore(this.databaseName, this.storeName).then((database) => {
-      if (this.closed) {
-        database.close();
-        throw new Error("The IndexedDB filesystem store is closed.");
-      }
-      this.database = database;
-      this.opening = null;
-      database.onversionchange = () => {
-        database.close();
-        if (this.database === database) this.database = null;
-      };
-      return database;
-    }).catch((error) => {
-      this.opening = null;
-      throw error;
-    });
-    return this.opening;
-  }
-};
-var RawIndexedDBFileSystemTransaction = class {
-  constructor(store) {
-    this.store = store;
-  }
-  async get(key) {
-    const value = await requestResult(this.store.get(key));
-    return value === void 0 ? null : value;
-  }
-  async put(key, value) {
-    await requestResult(this.store.put(value, key));
-  }
-  async delete(key) {
-    await requestResult(this.store.delete(key));
-  }
-  async keys() {
-    const keys = await requestResult(this.store.getAllKeys());
-    return keys.map((key) => {
-      if (typeof key !== "string") {
-        throw new Error("The DocBlocks filesystem store contains a non-string key.");
-      }
-      return key;
-    });
-  }
-  async hasKeyWithPrefix(prefix) {
-    const cursor = await requestResult(this.store.openKeyCursor(IDBKeyRange.lowerBound(prefix)));
-    return cursor !== null && typeof cursor.key === "string" && cursor.key.startsWith(prefix);
-  }
-};
-async function openDatabaseWithStore(databaseName, storeName) {
-  const database = await openDatabase(databaseName, void 0, (upgradeDatabase) => {
-    if (!upgradeDatabase.objectStoreNames.contains(storeName)) {
-      upgradeDatabase.createObjectStore(storeName);
-    }
-  });
-  if (database.objectStoreNames.contains(storeName)) return database;
-  const nextVersion = database.version + 1;
-  database.close();
-  return openDatabase(databaseName, nextVersion, (upgradeDatabase) => {
-    if (!upgradeDatabase.objectStoreNames.contains(storeName)) {
-      upgradeDatabase.createObjectStore(storeName);
-    }
-  });
-}
-function openDatabase(databaseName, version, upgrade) {
-  return new Promise((resolve, reject) => {
-    const request = version === void 0 ? indexedDB.open(databaseName) : indexedDB.open(databaseName, version);
-    let settled = false;
-    request.onupgradeneeded = () => upgrade(request.result);
-    request.onsuccess = () => {
-      if (settled) {
-        request.result.close();
-        return;
-      }
-      settled = true;
-      resolve(request.result);
-    };
-    request.onerror = () => {
-      if (settled) return;
-      settled = true;
-      reject(request.error ?? new Error(`Could not open IndexedDB database ${databaseName}.`));
-    };
-    request.onblocked = () => {
-      if (settled) return;
-      settled = true;
-      reject(new Error(`IndexedDB database ${databaseName} is blocked by another open page.`));
-    };
-  });
-}
-function requestResult(request) {
-  return new Promise((resolve, reject) => {
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed."));
-  });
-}
-function waitForTransaction(transaction) {
-  return new Promise((resolve, reject) => {
-    transaction.oncomplete = () => resolve();
-    transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction was aborted."));
-    transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB transaction failed."));
-  });
-}
+} from "./chunk-JS6XFWQK.js";
+import {
+  RawIndexedDBFileSystemStore,
+  indexedDBWorkspaceDatabaseName
+} from "./chunk-RVPGQBWR.js";
 
 // src/filesystem/indexeddb-provider-v2.ts
 var ENTRY_SCHEMA_VERSION = 1;
 var STATE_SCHEMA_VERSION = 1;
 var LEGACY_CONFLICT_SCHEMA_VERSION = 2;
 var LEGACY_CONFLICT_SCHEMA_VERSION_V1 = 1;
+var LEGACY_OPAQUE_SCHEMA_VERSION = 2;
+var LEGACY_OPAQUE_SCHEMA_VERSION_V1 = 1;
 var ENTRY_PREFIX = "v2:entry:";
 var STATE_KEY = "v2:state";
 var LEGACY_CONFLICT_PREFIX = "v2:legacy-conflict:";
@@ -200,7 +72,7 @@ var IndexedDBFileSystemProviderV2 = class {
     this.disposed = false;
     this.id = id;
     this.label = label;
-    this.store = options.store ?? new RawIndexedDBFileSystemStore(`docblocks-fs-${id}`, "files");
+    this.store = options.store ?? new RawIndexedDBFileSystemStore(indexedDBWorkspaceDatabaseName(id), "files");
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
     this.closeStoreOnDispose = options.closeStoreOnDispose ?? true;
     this.versionPrefix = `idb-${encodeURIComponent(id).slice(0, 900) || "workspace"}`;
@@ -268,7 +140,7 @@ var IndexedDBFileSystemProviderV2 = class {
           children.push(toEntrySnapshot(entry));
         }
       }
-      children.sort(compareSnapshots);
+      children.sort(compareSnapshotsByName);
       return Object.freeze(children);
     });
   }
@@ -377,6 +249,7 @@ var IndexedDBFileSystemProviderV2 = class {
     await this.ensureInitialized("remove");
     return this.withMutationLock(
       () => this.transaction("readwrite", { operation: "remove", path: canonical }, async (tx) => {
+        await assertNoLegacyConflictInSubtree(tx, canonical, "remove");
         const mutation = new EntryMutation(tx);
         const existing = await mutation.get(canonical);
         const state = await readRequiredState(tx);
@@ -418,8 +291,8 @@ var IndexedDBFileSystemProviderV2 = class {
         "readwrite",
         { operation: "move", path: sourcePath, destinationPath },
         async (tx) => {
-          await assertNoLegacyConflict(tx, sourcePath, "move");
-          await assertNoLegacyConflict(tx, destinationPath, "move");
+          await assertNoLegacyConflictInSubtree(tx, sourcePath, "move");
+          await assertNoLegacyConflictInSubtree(tx, destinationPath, "move");
           const mutation = new EntryMutation(tx);
           const source = await mutation.get(sourcePath);
           if (!source) {
@@ -652,6 +525,91 @@ var IndexedDBFileSystemProviderV2 = class {
       })
     );
   }
+  /**
+   * List the unrecognized legacy keys this workspace archived during migration.
+   *
+   * Migration deletes the legacy `fs:` namespace, but a key it cannot interpret
+   * is copied aside first rather than dropped: those bytes belong to whatever
+   * tool wrote them against this origin, and DocBlocks is not entitled to
+   * decide they are worthless. Nothing else reads that archive, so without this
+   * call the bytes are invisible and their quota is unaccountable.
+   *
+   * Values are deliberately excluded — an archive large enough to matter is an
+   * archive too large to materialize just to count it. Use
+   * {@link readLegacyOpaqueRecord} for the values themselves.
+   */
+  async listLegacyOpaqueRecords() {
+    this.assertOpen("read");
+    await this.ensureInitialized("read");
+    return this.transaction("readonly", { operation: "read" }, async (tx) => {
+      const keys = (await tx.keys()).filter((key) => key.startsWith(LEGACY_OPAQUE_PREFIX));
+      const summaries = [];
+      for (const key of keys) {
+        summaries.push(
+          toOpaqueSummary(validateLegacyOpaqueRecord(await tx.get(key), key))
+        );
+      }
+      summaries.sort((left, right) => compareText(left.key, right.key));
+      return Object.freeze(summaries);
+    });
+  }
+  /** Retrieve every archived value for one unrecognized legacy key. */
+  async readLegacyOpaqueRecord(key) {
+    this.assertOpen("read");
+    await this.ensureInitialized("read");
+    return this.transaction("readonly", { operation: "read" }, async (tx) => {
+      const archiveKey = legacyOpaqueKey(key);
+      const raw = await tx.get(archiveKey);
+      if (raw === null) return null;
+      return toPublicOpaqueRecord(validateLegacyOpaqueRecord(raw, archiveKey));
+    });
+  }
+  /**
+   * Permanently destroy archived legacy values. This is the only operation that
+   * can lose data the archive exists to protect.
+   *
+   * For every target, all of that key's archived value snapshots are erased and
+   * the quota they held is reclaimed. There is no undo, no tombstone, and no
+   * other copy: migration already deleted the original `fs:` key, so the
+   * archive is the last one. Retrieve anything worth keeping with
+   * {@link readLegacyOpaqueRecord} before calling this.
+   *
+   * Each target must carry the `valueCount` the caller actually observed, which
+   * is why a target is a value returned by {@link listLegacyOpaqueRecords} or
+   * {@link readLegacyOpaqueRecord} rather than a bare key. A stale client can
+   * append a new snapshot at any time; if any target has grown since it was
+   * observed, the whole call fails with `conflict` and destroys nothing, so
+   * re-list and look again. A key that is already absent is not an error —
+   * discarding what is gone is a no-op — but a key whose count disagrees is.
+   *
+   * @returns how many records were destroyed.
+   */
+  async discardLegacyOpaqueRecords(targets) {
+    this.assertOpen("remove");
+    if (targets.length === 0) return 0;
+    await this.ensureInitialized("remove");
+    return this.withMutationLock(
+      () => this.transaction("readwrite", { operation: "remove" }, async (tx) => {
+        const doomed = [];
+        for (const target of targets) {
+          const archiveKey = legacyOpaqueKey(target.key);
+          const raw = await tx.get(archiveKey);
+          if (raw === null) continue;
+          const record = validateLegacyOpaqueRecord(raw, archiveKey);
+          if (record.values.length !== target.valueCount) {
+            throw new FsError(
+              "conflict",
+              `Archived legacy key ${target.key} now holds ${record.values.length} values, not ${target.valueCount}. Read it again before discarding it.`,
+              { operation: "remove", retryable: false }
+            );
+          }
+          doomed.push(archiveKey);
+        }
+        for (const archiveKey of doomed) await tx.delete(archiveKey);
+        return doomed.length;
+      })
+    );
+  }
   async ensureInitialized(operation) {
     this.assertOpen(operation);
     if (this.initialization) return this.initialization;
@@ -754,7 +712,7 @@ var IndexedDBFileSystemProviderV2 = class {
     for (const entry of entries.values()) {
       await tx.put(entryKey(entry.path), entry);
     }
-    await deleteLegacyNamespace(tx, keys);
+    await deleteLegacyNamespace(tx, keys, now);
     const state = {
       schemaVersion: STATE_SCHEMA_VERSION,
       migrationVersion: 2,
@@ -793,7 +751,7 @@ var IndexedDBFileSystemProviderV2 = class {
         fileRecoveryCandidate(legacy, entry?.kind === "directory" ? "kind-collision" : reason, now)
       );
     }
-    await deleteLegacyNamespace(tx, keys);
+    await deleteLegacyNamespace(tx, keys, now);
     for (const key of keys) {
       if (key.startsWith(LEGACY_IGNORED_PREFIX)) await tx.delete(key);
     }
@@ -880,7 +838,7 @@ var IndexedDBFileSystemProviderV2 = class {
   }
   async planParents(mutation, path, createParents, operation) {
     const missing = [];
-    for (const parent of parentChain(path)) {
+    for (const parent of parentChainWithRoot(path)) {
       const entry = await mutation.get(parent);
       if (entry?.kind === "file") {
         throw this.error(
@@ -905,7 +863,7 @@ var IndexedDBFileSystemProviderV2 = class {
     }
   }
   async touchParents(mutation, path, next) {
-    for (const parent of parentChain(path)) {
+    for (const parent of parentChainWithRoot(path)) {
       const entry = await mutation.get(parent);
       if (entry?.kind === "directory") {
         mutation.set(parent, directoryRecord(parent, next.version, next.lastModified));
@@ -1119,15 +1077,21 @@ function validateIgnoredLegacyPath(value) {
   if (!path) throw corrupt("Ignored legacy recovery marker cannot target the workspace root.");
   return path;
 }
-function bytesEqual(left, right) {
-  const leftBytes = ArrayBuffer.isView(left) ? new Uint8Array(left.buffer, left.byteOffset, left.byteLength) : new Uint8Array(left);
-  const rightBytes = ArrayBuffer.isView(right) ? new Uint8Array(right.buffer, right.byteOffset, right.byteLength) : new Uint8Array(right);
-  if (leftBytes.byteLength !== rightBytes.byteLength) return false;
-  return leftBytes.every((byte, index) => byte === rightBytes[index]);
-}
 async function assertNoLegacyConflict(transaction, path, operation) {
   if (await transaction.get(legacyConflictKey(path)) === null) return;
-  throw new FsError(
+  throw legacyConflictBlocked(path, operation);
+}
+async function assertNoLegacyConflictInSubtree(transaction, path, operation) {
+  for (const key of await transaction.keys()) {
+    if (!key.startsWith(LEGACY_CONFLICT_PREFIX)) continue;
+    const conflictPath = parseWorkspacePath(key.slice(LEGACY_CONFLICT_PREFIX.length));
+    if (conflictPath === path || workspacePathContains(path, conflictPath, false)) {
+      throw legacyConflictBlocked(conflictPath, operation);
+    }
+  }
+}
+function legacyConflictBlocked(path, operation) {
+  return new FsError(
     "conflict",
     "Resolve the legacy migration conflict before mutating this path.",
     {
@@ -1282,18 +1246,91 @@ function legacyPayloadsMatchEntry(legacy, entry) {
   return (legacy.content === null || bytesEqual(new TextEncoder().encode(legacy.content), entry.data)) && (legacy.binary === null || bytesEqual(legacy.binary, entry.data));
 }
 function hasFileAncestor(entries, path) {
-  return parentChain(path).some((parent) => entries.get(parent)?.kind === "file");
+  return parentChainWithRoot(path).some((parent) => entries.get(parent)?.kind === "file");
+}
+function legacyOpaqueKey(key) {
+  return `${LEGACY_OPAQUE_PREFIX}${encodeURIComponent(key)}`;
+}
+function validateLegacyOpaqueRecord(value, archiveKey) {
+  if (!isRecord(value) || !Array.isArray(value.values)) {
+    throw corrupt(`Archived legacy record is corrupt: ${archiveKey}.`);
+  }
+  const key = readString(value.key, "archived legacy key");
+  if (legacyOpaqueKey(key) !== archiveKey) {
+    throw corrupt(`Archived legacy record key does not match its key: ${archiveKey}.`);
+  }
+  if (value.schemaVersion === LEGACY_OPAQUE_SCHEMA_VERSION_V1) {
+    return {
+      schemaVersion: LEGACY_OPAQUE_SCHEMA_VERSION,
+      key,
+      values: Object.freeze(
+        value.values.map(
+          (item) => ({ value: item, archivedAt: null })
+        )
+      )
+    };
+  }
+  if (value.schemaVersion !== LEGACY_OPAQUE_SCHEMA_VERSION) {
+    throw corrupt(`Unsupported archived legacy record schema: ${archiveKey}.`);
+  }
+  const values = value.values.map((item) => {
+    if (!isRecord(item)) throw corrupt(`Archived legacy value is corrupt: ${archiveKey}.`);
+    return {
+      value: item.value,
+      // A v2 record legitimately carries null here for values it inherited from
+      // the untimestamped v1 shape, so this must stay nullable on the way back
+      // in or re-archiving a v1 record would make it permanently unreadable.
+      archivedAt: item.archivedAt === null ? null : readString(item.archivedAt, "archived legacy timestamp")
+    };
+  });
+  if (values.length === 0) throw corrupt(`Archived legacy record has no values: ${archiveKey}.`);
+  return { schemaVersion: LEGACY_OPAQUE_SCHEMA_VERSION, key, values: Object.freeze(values) };
+}
+function opaqueValueByteLength(value) {
+  if (value instanceof ArrayBuffer) return value.byteLength;
+  if (ArrayBuffer.isView(value)) return value.byteLength;
+  if (typeof value === "string") return new TextEncoder().encode(value).byteLength;
+  return null;
+}
+function toOpaqueSummary(record) {
+  let byteLength = 0;
+  for (const item of record.values) {
+    const size = opaqueValueByteLength(item.value);
+    byteLength = size === null || byteLength === null ? null : byteLength + size;
+  }
+  const stamps = record.values.map((item) => item.archivedAt);
+  return Object.freeze({
+    key: record.key,
+    valueCount: record.values.length,
+    byteLength,
+    firstArchivedAt: stamps[0] ?? null,
+    lastArchivedAt: stamps[stamps.length - 1] ?? null
+  });
 }
-async function deleteLegacyNamespace(transaction, keys) {
+function toPublicOpaqueRecord(record) {
+  return Object.freeze({
+    ...toOpaqueSummary(record),
+    values: Object.freeze(
+      record.values.map(
+        (item) => Object.freeze({
+          value: item.value instanceof ArrayBuffer ? copyBytes(item.value) : item.value,
+          byteLength: opaqueValueByteLength(item.value),
+          archivedAt: item.archivedAt
+        })
+      )
+    )
+  });
+}
+async function deleteLegacyNamespace(transaction, keys, archivedAt) {
   for (const key of keys) {
     if (key.startsWith(LEGACY_PREFIX) && !isRecognizedLegacyKey(key)) {
-      const archiveKey = `${LEGACY_OPAQUE_PREFIX}${encodeURIComponent(key)}`;
+      const archiveKey = legacyOpaqueKey(key);
       const existing = await transaction.get(archiveKey);
-      const values = isRecord(existing) && existing.schemaVersion === 1 && existing.key === key && Array.isArray(existing.values) ? existing.values : [];
+      const values = existing === null ? [] : validateLegacyOpaqueRecord(existing, archiveKey).values;
       await transaction.put(archiveKey, {
-        schemaVersion: 1,
+        schemaVersion: LEGACY_OPAQUE_SCHEMA_VERSION,
         key,
-        values: [...values, await transaction.get(key)]
+        values: [...values, { value: await transaction.get(key), archivedAt }]
       });
     }
     if (key.startsWith(LEGACY_PREFIX) || key.startsWith(LEGACY_IGNORED_PREFIX))
@@ -1354,19 +1391,10 @@ function selectLegacyPayload(conflict, resolution, path) {
   return { kind: "file", data: copyBytes(data) };
 }
 function addParentDirectories(entries, path, version, lastModified) {
-  for (const parent of parentChain(path)) {
+  for (const parent of parentChainWithRoot(path)) {
     if (!entries.has(parent)) entries.set(parent, directoryRecord(parent, version, lastModified));
   }
 }
-function parentChain(path) {
-  const parents = [];
-  let current = workspacePathDirname(path);
-  while (true) {
-    parents.unshift(current);
-    if (!current) return parents;
-    current = workspacePathDirname(current);
-  }
-}
 function directoryRecord(path, version, lastModified) {
   return {
     schemaVersion: ENTRY_SCHEMA_VERSION,
@@ -1413,19 +1441,6 @@ function toDirectorySnapshot(entry) {
     lastModified: entry.lastModified
   });
 }
-function compareSnapshots(left, right) {
-  if (left.kind !== right.kind) return left.kind === "directory" ? -1 : 1;
-  return compareText(left.name, right.name);
-}
-function compareText(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
-function copyBytes(data) {
-  const source = ArrayBuffer.isView(data) ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : new Uint8Array(data);
-  const copy = new Uint8Array(source.byteLength);
-  copy.set(source);
-  return copy.buffer;
-}
 function validateBytes(value, path) {
   if (value instanceof ArrayBuffer) return copyBytes(value);
   if (value instanceof Uint8Array) return copyBytes(value);
@@ -1435,9 +1450,6 @@ function readString(value, label) {
   if (typeof value !== "string") throw corrupt(`Invalid ${label}.`);
   return value;
 }
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
 function corrupt(message, path) {
   return new FsError("io", message, { operation: "read", path, retryable: false });
 }
@@ -1448,7 +1460,7 @@ var IndexedDBFileSystemProvider = class {
     this.disposed = false;
     this.id = id;
     this.label = label;
-    const store = options.store ?? new RawIndexedDBFileSystemStore(`docblocks-fs-${id}`, "files");
+    const store = options.store ?? new RawIndexedDBFileSystemStore(indexedDBWorkspaceDatabaseName(id), "files");
     this.v2 = new IndexedDBFileSystemProviderV2(id, label, {
       store,
       now: options.now,
@@ -1462,20 +1474,21 @@ var IndexedDBFileSystemProvider = class {
   }
   async readFile(path) {
     this.assertOpen("read");
-    const read = await this.v2.readFile(this.path(path, false, "read"));
-    return read ? new TextDecoder().decode(read.data) : null;
+    const canonical = this.path(path);
+    const read = await this.v2.readFile(canonical);
+    return read ? this.decode(read.data, canonical, "read") : null;
   }
   async writeFile(path, content) {
     this.assertOpen("write");
-    await this.v2.writeFile(this.path(path, false, "write"), new TextEncoder().encode(content), {
+    await this.v2.writeFile(this.path(path), new TextEncoder().encode(content), {
       createParents: true
     });
   }
   async commitFile(path, content, expectedContent) {
     this.assertOpen("write");
-    const canonical = this.path(path, false, "write");
+    const canonical = this.path(path);
     const current = await this.v2.readFile(canonical);
-    const currentContent = current ? new TextDecoder().decode(current.data) : null;
+    const currentContent = current ? this.decode(current.data, canonical, "write") : null;
     if (currentContent !== expectedContent && currentContent !== content) {
       return {
         status: "conflict",
@@ -1494,28 +1507,28 @@ var IndexedDBFileSystemProvider = class {
       const latest = await this.v2.readFile(canonical);
       return {
         status: "conflict",
-        content: latest ? new TextDecoder().decode(latest.data) : null,
+        content: latest ? this.decode(latest.data, canonical, "write") : null,
         version: latest?.entry.version ?? null
       };
     }
   }
   async delete(path) {
     this.assertOpen("remove");
-    await this.v2.remove(this.path(path, false, "remove"), {
+    await this.v2.remove(this.path(path), {
       recursive: true,
       missing: "ignore"
     });
   }
   async rename(oldPath, newPath) {
     this.assertOpen("move");
-    await this.v2.move(this.path(oldPath, false, "move"), this.path(newPath, false, "move"), {
+    await this.v2.move(this.path(oldPath), this.path(newPath), {
       createParents: true
     });
   }
   async readDirectory(path) {
     this.assertOpen("list");
     try {
-      const entries = await this.v2.readDirectory(this.path(path, true, "list"));
+      const entries = await this.v2.readDirectory(this.path(path));
       return entries.map((entry) => ({
         kind: entry.kind,
         name: entry.name,
@@ -1528,18 +1541,18 @@ var IndexedDBFileSystemProvider = class {
   }
   async exists(path) {
     this.assertOpen("stat");
-    return await this.v2.stat(this.path(path, true, "stat")) !== null;
+    return await this.v2.stat(this.path(path)) !== null;
   }
   async createDirectory(path) {
     this.assertOpen("create-directory");
-    await this.v2.createDirectory(this.path(path, false, "create-directory"), {
+    await this.v2.createDirectory(this.path(path), {
       createParents: true,
       mode: "ensure"
     });
   }
   async stat(path) {
     this.assertOpen("stat");
-    const entry = await this.v2.stat(this.path(path, false, "stat"));
+    const entry = await this.v2.stat(this.path(path));
     if (!entry || entry.kind !== "file") return null;
     return {
       name: entry.name,
@@ -1550,28 +1563,40 @@ var IndexedDBFileSystemProvider = class {
   }
   async readBinary(path) {
     this.assertOpen("read");
-    return (await this.v2.readFile(this.path(path, false, "read")))?.data ?? null;
+    return (await this.v2.readFile(this.path(path)))?.data ?? null;
   }
   async writeBinary(path, data) {
     this.assertOpen("write");
-    await this.v2.writeFile(this.path(path, false, "write"), data, { createParents: true });
-  }
-  path(path, allowRoot, operation) {
-    const canonical = parseWorkspacePath(path);
-    if (canonical || allowRoot) return canonical;
-    throw new FsError("invalid-path", "The filesystem root cannot be used as a mutation target.", {
-      operation,
-      path
-    });
+    await this.v2.writeFile(this.path(path), data, { createParents: true });
+  }
+  /**
+   * Canonicalize only. Root policy is the v2 authority's to state: it accepts
+   * the root wherever the root is a legitimate target (`stat`, `readDirectory`,
+   * `createDirectory`) and rejects it with one consistent code and message
+   * everywhere else. Re-deriving that policy here is how this facade previously
+   * drifted from both v2 and its sibling facades.
+   */
+  path(path) {
+    return parseWorkspacePath(path);
+  }
+  /**
+   * Byte-authoritative entries may hold payloads that are not valid UTF-8. A
+   * lossy decode would hand the caller replacement characters that a later save
+   * writes back over the user's original bytes, so surface the fault instead.
+   */
+  decode(data, path, operation) {
+    return decodeUtf8Text(data, { label: "The file", operation, path });
   }
   assertOpen(operation) {
     if (!this.disposed) return;
-    throw new FsError("closed", "The IndexedDB filesystem provider is disposed.", { operation });
+    throw new FsError("disposed", "Filesystem provider is disposed.", { operation });
   }
 };
 
 // src/filesystem/indexeddb-content-container.ts
 import { findDocumentPath } from "@bendyline/squisq/storage";
+
+// src/filesystem/internal/mime.ts
 var EXTENSION_MIME_MAP = {
   ".md": "text/markdown",
   ".txt": "text/plain",
@@ -1595,6 +1620,8 @@ function guessMimeType(path) {
   const ext = path.slice(dot).toLowerCase();
   return EXTENSION_MIME_MAP[ext] ?? "application/octet-stream";
 }
+
+// src/filesystem/indexeddb-content-container.ts
 var IndexedDBContentContainer = class {
   constructor(workspaceId) {
     this.provider = new IndexedDBFileSystemProviderV2(`${workspaceId}-media`, "Media Storage");
@@ -1659,6 +1686,7 @@ var IndexedDBContentContainer = class {
 export {
   IndexedDBFileSystemProviderV2,
   IndexedDBFileSystemProvider,
+  guessMimeType,
   IndexedDBContentContainer
 };
-//# sourceMappingURL=chunk-J32GU3F3.js.map
+//# sourceMappingURL=chunk-6IYMTYMQ.js.map