@xtrable-ltd/nanoesis 0.1.4 → 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.d.ts

@@ -216,16 +216,28 @@ declare function readMcpResource(uri: string): {
  * §11d) and bundled here as **pure data**, so the engine's purity is untouched and the
  * scaffold works identically for every host and the MCP server with no per-host wiring.
  *
- * Deliberately minimal (the owner's call, distinct from the fuller `examples/starter`):
- * one home page, a page template, the document shell, and a stylesheet. It is gate-clean
- * by construction — no collection loops (nothing to point at yet), no custom components,
- * no required fields left unset — so a fresh adopter can publish it immediately, and the
- * home page is a **draft** (`isPublished: false`) so going live is a deliberate act.
+ * Auto-fires on first sign-in to an empty store (revised 2026-05-28). The earlier behaviour
+ * — a confirm prompt that the user could dismiss — left a user who said no with no path
+ * forward (the empty Content workspace has no signposted route to the Dev workspace, and
+ * every alternative to scaffolding needs templates to already exist). Removing the choice
+ * removes a concept; the scaffold is idempotent and gate-clean, so doing it always is safe.
+ *
+ * Deliberately minimal (revised 2026-05-28, owner's call):
+ *   - `templates/home.html` is a **full HTML document** (DESIGN §6.10: with no
+ *     `templates/document.html`, a page template is the whole document) — no shared shell.
+ *     The user can extract one later when they add a second page; for the bootstrap state,
+ *     three files is simpler than four.
+ *   - `public/styles.css` for baseline readability — a one-page site without any CSS reads
+ *     poorly, and the styles.css path is the editor's canonical "your site's CSS" location.
+ *   - `content/index.json` with `isPublished: true` (revised 2026-05-28). The earlier
+ *     "draft, so going live is deliberate" framing turned out to be a footgun: a new user
+ *     would hit Publish and get the "nothing went live" warning without obvious cause. A
+ *     published placeholder is honest about what a publish will do; the user's first edit
+ *     is to replace the placeholder copy, not to also remember to toggle a flag.
  */
 /**
  * The starter files, keyed by working-store path. Written through the store's `write`
- * (so the index records each), in this order — templates and styles before the content
- * that depends on them, though the store has no cross-file ordering requirement.
+ * (so the index records each). The store has no cross-file ordering requirement.
  */
 declare const SCAFFOLD_FILES: Readonly<Record<string, string>>;
 

package/dist/editor-api.js

@@ -8,45 +8,32 @@ import {
   loadTemplate,
   renderReferenceMarkdown,
   validateSite
-} from "./chunk-S23S4ZAK.js";
+} from "./chunk-Y7PUOM5I.js";
 
 // ../editor-api/src/scaffold.ts
-var DOCUMENT_HTML = `<!doctype html>
+var HOME_HTML = `<!doctype html>
 <html lang="en">
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>{title}</title>
-    <meta name="description" content="{meta_description}" />
     <link rel="stylesheet" href="/styles.css" />
   </head>
   <body>
-    <header class="site-header">
-      <a class="brand" href="/">Your site</a>
-    </header>
     <main>
-      <slot></slot>
+      <h1>{title}</h1>
+      <div class="prose" data-type="richtext">{body}</div>
     </main>
-    <footer class="site-footer">
-      <p>Built with nanoesis \u2014 static HTML, no runtime.</p>
-    </footer>
   </body>
 </html>
 `;
-var HOME_HTML = `<section class="hero">
-  <h1>{title}</h1>
-  <p class="lead">{lead}</p>
-</section>
-<div class="prose" data-type="richtext">{body}</div>
-`;
 var HOME_JSON = `${JSON.stringify(
   {
     template: "home",
     title: "Welcome",
-    isPublished: false,
+    isPublished: true,
     fields: {
-      lead: "Edit this page in the nanoesis editor, then publish when you are ready.",
-      body: "<p>This is your new site. It compiles to plain static HTML \u2014 there is no server and no client framework, and nothing of the editor survives into production.</p>"
+      body: "<p>This is your starter home page. Edit it in the nanoesis editor and click Publish to update your site.</p>"
     }
   },
   null,
@@ -67,30 +54,16 @@ body {
   margin: 0;
 }
 
-.site-header,
-main,
-.site-footer {
+main {
   max-width: var(--max);
   margin-inline: auto;
   padding: 1.5rem 1.25rem;
 }
 
-.site-header .brand {
-  font-weight: 700;
-  text-decoration: none;
-  color: var(--ink);
-}
-
-.hero h1 {
+h1 {
   font-size: 2.25rem;
   letter-spacing: -0.01em;
-  margin: 0 0 0.5rem;
-}
-
-.lead {
-  font-size: 1.2rem;
-  color: var(--muted);
-  margin: 0 0 2rem;
+  margin: 0 0 1rem;
 }
 
 .prose {
@@ -100,15 +73,8 @@ main,
 a {
   color: var(--accent);
 }
-
-.site-footer {
-  color: var(--muted);
-  font-size: 0.9rem;
-  border-top: 1px solid #eee;
-}
 `;
 var SCAFFOLD_FILES = {
-  "templates/document.html": DOCUMENT_HTML,
   "templates/home.html": HOME_HTML,
   "public/styles.css": STYLES_CSS,
   "content/index.json": HOME_JSON

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,