@xtrable-ltd/nanoesis 0.1.5 → 0.1.6

package/dist/adapter-azure-blob.js

@@ -1,6 +1,6 @@
 import {
   contentTypeFor
-} from "./chunk-S23S4ZAK.js";
+} from "./chunk-Y7PUOM5I.js";
 
 // ../../adapters/azure-blob/src/container.ts
 var InMemoryBlobContainer = class {

package/dist/{chunk-S23S4ZAK.js → chunk-Y7PUOM5I.js}

@@ -237,6 +237,20 @@ var IndexedStore = class {
   store;
   index;
   loading;
+  /**
+   * Per-instance mutex (DESIGN §11d): every mutation (`write`/`delete`/`rename`/`reconcile`)
+   * runs through {@link serializeMutation}, which chains onto the previous mutation's
+   * completion. Without it, two concurrent mutations both read the cached `this.index`,
+   * each compute their "next" key set from that stale snapshot, and the second
+   * `saveIndex` clobbers the first — the file writes land in blob, but the index keeps
+   * stale references or loses fresh ones (the "I deleted it and it's still there" or
+   * "I added it and it didn't appear" bugs surfaced dogfooding the marketing site,
+   * 2026-05-28). Reads (`list`/`exists`/`readBytes`) are *not* serialised; an
+   * in-flight mutation simply means a reader sees the pre-mutation index, eventually
+   * consistent and safe. Crashes inside `work()` release the lock so a single failure
+   * does not deadlock subsequent operations.
+   */
+  mutationLock = Promise.resolve();
   /** The index, loaded once on first need and cached (mutations replace the cached copy). */
   async loaded() {
     if (this.index !== void 0) return this.index;
@@ -244,6 +258,21 @@ var IndexedStore = class {
     this.index = await this.loading;
     return this.index;
   }
+  serializeMutation(work) {
+    const previous = this.mutationLock;
+    let release;
+    this.mutationLock = new Promise((resolve) => {
+      release = resolve;
+    });
+    return (async () => {
+      try {
+        await previous;
+        return await work();
+      } finally {
+        release();
+      }
+    })();
+  }
   async list(dir) {
     return childrenOf((await this.loaded()).keys, dir);
   }
@@ -262,31 +291,35 @@ var IndexedStore = class {
    * Create or overwrite `key`. The index is rewritten only when `key` is new (an
    * overwrite leaves the key set unchanged, so editing an item is a single `put`).
    */
-  async write(key, bytes) {
-    const target = guarded(normalize(key));
-    await this.store.put(target, bytes);
-    const index = await this.loaded();
-    if (!index.keys.includes(target)) {
-      this.index = await saveIndex(this.store, index, [...index.keys, target]);
-    }
+  write(key, bytes) {
+    return this.serializeMutation(async () => {
+      const target = guarded(normalize(key));
+      await this.store.put(target, bytes);
+      const index = await this.loaded();
+      if (!index.keys.includes(target)) {
+        this.index = await saveIndex(this.store, index, [...index.keys, target]);
+      }
+    });
   }
   /**
    * Delete a file, or a whole directory subtree (every key under `key/`). Idempotent: a
    * path the index does not know is still deleted from the store (clearing an orphan),
    * and deleting nothing is a no-op.
    */
-  async delete(key) {
-    const target = guarded(normalize(key));
-    const index = await this.loaded();
-    const prefix = `${target}/`;
-    const removed = index.keys.filter((k) => k === target || k.startsWith(prefix));
-    if (removed.length === 0) {
-      await this.store.delete(target);
-      return;
-    }
-    await Promise.all(removed.map((k) => this.store.delete(k)));
-    const remaining = index.keys.filter((k) => k !== target && !k.startsWith(prefix));
-    this.index = await saveIndex(this.store, index, remaining);
+  delete(key) {
+    return this.serializeMutation(async () => {
+      const target = guarded(normalize(key));
+      const index = await this.loaded();
+      const prefix = `${target}/`;
+      const removed = index.keys.filter((k) => k === target || k.startsWith(prefix));
+      if (removed.length === 0) {
+        await this.store.delete(target);
+        return;
+      }
+      await Promise.all(removed.map((k) => this.store.delete(k)));
+      const remaining = index.keys.filter((k) => k !== target && !k.startsWith(prefix));
+      this.index = await saveIndex(this.store, index, remaining);
+    });
   }
   /**
    * Move/rename a file, or a whole directory subtree (every key under `from/` is remapped
@@ -295,32 +328,34 @@ var IndexedStore = class {
    * `/api/rename` enforces. (Mutating the reserved namespace is a programmer error and
    * still throws.)
    */
-  async rename(from, to) {
-    const source = guarded(normalize(from));
-    const dest = guarded(normalize(to));
-    if (source === dest) return { ok: true };
-    const index = await this.loaded();
-    const sourcePrefix = `${source}/`;
-    const affected = index.keys.filter((k) => k === source || k.startsWith(sourcePrefix));
-    if (affected.length === 0) return { ok: false, reason: "missing" };
-    const destPrefix = `${dest}/`;
-    if (index.keys.some((k) => k === dest || k.startsWith(destPrefix))) {
-      return { ok: false, reason: "exists" };
-    }
-    const moves = affected.map((k) => ({
-      from: k,
-      to: k === source ? dest : dest + k.slice(source.length)
-    }));
-    for (const move of moves) {
-      const bytes = await this.store.get(move.from);
-      if (bytes === void 0) continue;
-      await this.store.put(move.to, bytes);
-      await this.store.delete(move.from);
-    }
-    const movedFrom = new Set(moves.map((move) => move.from));
-    const next = index.keys.filter((k) => !movedFrom.has(k)).concat(moves.map((m) => m.to));
-    this.index = await saveIndex(this.store, index, next);
-    return { ok: true };
+  rename(from, to) {
+    return this.serializeMutation(async () => {
+      const source = guarded(normalize(from));
+      const dest = guarded(normalize(to));
+      if (source === dest) return { ok: true };
+      const index = await this.loaded();
+      const sourcePrefix = `${source}/`;
+      const affected = index.keys.filter((k) => k === source || k.startsWith(sourcePrefix));
+      if (affected.length === 0) return { ok: false, reason: "missing" };
+      const destPrefix = `${dest}/`;
+      if (index.keys.some((k) => k === dest || k.startsWith(destPrefix))) {
+        return { ok: false, reason: "exists" };
+      }
+      const moves = affected.map((k) => ({
+        from: k,
+        to: k === source ? dest : dest + k.slice(source.length)
+      }));
+      for (const move of moves) {
+        const bytes = await this.store.get(move.from);
+        if (bytes === void 0) continue;
+        await this.store.put(move.to, bytes);
+        await this.store.delete(move.from);
+      }
+      const movedFrom = new Set(moves.map((move) => move.from));
+      const next = index.keys.filter((k) => !movedFrom.has(k)).concat(moves.map((m) => m.to));
+      this.index = await saveIndex(this.store, index, next);
+      return { ok: true };
+    });
   }
   /**
    * Rebuild this store's index from the *actual* keys the underlying store holds (DESIGN
@@ -330,10 +365,12 @@ var IndexedStore = class {
    * {@link reconcileIndex} on a fresh store, this also refreshes the cached in-memory
    * index, so this live instance sees the recovered files immediately.
    */
-  async reconcile(actualKeys) {
-    const result = await reconcileIndex(this.store, actualKeys);
-    this.index = result.index;
-    return result;
+  reconcile(actualKeys) {
+    return this.serializeMutation(async () => {
+      const result = await reconcileIndex(this.store, actualKeys);
+      this.index = result.index;
+      return result;
+    });
   }
 };
 function guarded(key) {

package/dist/editor-api.js

@@ -8,7 +8,7 @@ import {
   loadTemplate,
   renderReferenceMarkdown,
   validateSite
-} from "./chunk-S23S4ZAK.js";
+} from "./chunk-Y7PUOM5I.js";
 
 // ../editor-api/src/scaffold.ts
 var HOME_HTML = `<!doctype html>

package/dist/index.d.ts

@@ -281,9 +281,24 @@ declare class IndexedStore implements WorkingStore {
     private readonly store;
     private index;
     private loading;
+    /**
+     * Per-instance mutex (DESIGN §11d): every mutation (`write`/`delete`/`rename`/`reconcile`)
+     * runs through {@link serializeMutation}, which chains onto the previous mutation's
+     * completion. Without it, two concurrent mutations both read the cached `this.index`,
+     * each compute their "next" key set from that stale snapshot, and the second
+     * `saveIndex` clobbers the first — the file writes land in blob, but the index keeps
+     * stale references or loses fresh ones (the "I deleted it and it's still there" or
+     * "I added it and it didn't appear" bugs surfaced dogfooding the marketing site,
+     * 2026-05-28). Reads (`list`/`exists`/`readBytes`) are *not* serialised; an
+     * in-flight mutation simply means a reader sees the pre-mutation index, eventually
+     * consistent and safe. Crashes inside `work()` release the lock so a single failure
+     * does not deadlock subsequent operations.
+     */
+    private mutationLock;
     constructor(store: BlobStore);
     /** The index, loaded once on first need and cached (mutations replace the cached copy). */
     private loaded;
+    private serializeMutation;
     list(dir: string): Promise<readonly DirEntry[]>;
     readText(path: string): Promise<string>;
     readBytes(path: string): Promise<Uint8Array>;

package/dist/index.js

@@ -61,7 +61,7 @@ import {
   validateSite,
   valueKindOf,
   wholeValueToken
-} from "./chunk-S23S4ZAK.js";
+} from "./chunk-Y7PUOM5I.js";
 export {
   ContentParseError,
   DEFAULT_DIRS,