@xtrable-ltd/nanoesis 0.1.31 → 0.1.33

package/dist/adapter-azure-blob.d.ts

@@ -1,5 +1,5 @@
 import { ContainerClient } from '@azure/storage-blob';
-import { BlobStore, ArtifactSink, Storage } from '@nanoesis/engine';
+import { BlobStore, ConditionalBlobStore, ArtifactSink, Storage } from '@nanoesis/engine';
 export { contentTypeFor } from '@nanoesis/engine';
 
 /**
@@ -28,6 +28,23 @@ interface BlobContainer {
     write(name: string, data: Uint8Array, contentType: string, cacheControl?: string): Promise<void>;
     /** Delete a blob; a missing blob is a no-op (idempotent). */
     remove(name: string): Promise<void>;
+    /**
+     * A blob's bytes plus its current version tag (the Azure ETag), or null if absent. Pairs
+     * with {@link writeConditional} for the optimistic-concurrency the content index needs
+     * (DESIGN §11d): the bytes and the tag are captured together so the tag always describes
+     * the bytes returned.
+     */
+    readVersioned(name: string): Promise<{
+        bytes: Uint8Array;
+        version: string;
+    } | null>;
+    /**
+     * Write a blob only if its current version tag matches `expected` (or, when `expected` is
+     * null, only if it does not yet exist). Resolves to the new version tag on success, or
+     * `undefined` when the precondition failed because another writer got there first. A
+     * non-precondition failure still rejects.
+     */
+    writeConditional(name: string, data: Uint8Array, contentType: string, expected: string | null): Promise<string | undefined>;
 }
 /**
  * An in-memory {@link BlobContainer} backed by a name→bytes map. The test double for
@@ -36,11 +53,20 @@ interface BlobContainer {
 declare class InMemoryBlobContainer implements BlobContainer {
     private readonly blobs;
     private readonly cacheControls;
+    /** Per-blob version, bumped on every write, the in-memory stand-in for an ETag. */
+    private readonly versions;
+    private nextVersion;
     constructor(seed?: Readonly<Record<string, Uint8Array | string>>);
+    private store;
     list(prefix: string): Promise<readonly string[]>;
     read(name: string): Promise<Uint8Array | null>;
     write(name: string, data: Uint8Array, contentType?: string, cacheControl?: string): Promise<void>;
     remove(name: string): Promise<void>;
+    readVersioned(name: string): Promise<{
+        bytes: Uint8Array;
+        version: string;
+    } | null>;
+    writeConditional(name: string, data: Uint8Array, contentType: string, expected: string | null): Promise<string | undefined>;
     /** Test helper: the current blob names. */
     get names(): readonly string[];
     /** Test helper: the `Cache-Control` a blob was written with, if any. */
@@ -65,6 +91,11 @@ declare class AzureBlobContainer implements BlobContainer {
     read(name: string): Promise<Uint8Array | null>;
     write(name: string, data: Uint8Array, contentType: string, cacheControl?: string): Promise<void>;
     remove(name: string): Promise<void>;
+    readVersioned(name: string): Promise<{
+        bytes: Uint8Array;
+        version: string;
+    } | null>;
+    writeConditional(name: string, data: Uint8Array, contentType: string, expected: string | null): Promise<string | undefined>;
 }
 
 /**
@@ -74,12 +105,17 @@ declare class AzureBlobContainer implements BlobContainer {
  * in-memory container in tests (LSP). Keys are POSIX-style; `put` stamps a content type
  * from the key's extension so a published blob serves correctly as a static-website file.
  */
-declare class BlobContainerStore implements BlobStore {
+declare class BlobContainerStore implements BlobStore, ConditionalBlobStore {
     private readonly container;
     constructor(container: BlobContainer);
     get(key: string): Promise<Uint8Array | undefined>;
     put(key: string, bytes: Uint8Array, cacheControl?: string): Promise<void>;
     delete(key: string): Promise<void>;
+    getVersioned(key: string): Promise<{
+        bytes: Uint8Array;
+        version: string;
+    } | undefined>;
+    putConditional(key: string, bytes: Uint8Array, expected: string | null): Promise<string | undefined>;
 }
 
 /**
@@ -99,12 +135,13 @@ declare class BlobArtifactSink implements ArtifactSink {
 
 /**
  * A ready-made {@link Storage} over an Azure Blob container: get/put/delete (via
- * {@link BlobContainerStore}) plus `wipe` (delete every blob). Pass it to `createEditor`
+ * {@link BlobContainerStore}) plus `wipe` (delete every blob) and `prune` (delete every blob
+ * not in a keep set, the zero-downtime publish sweep). Pass it to `createEditor`
  * as `editorFiles` (the working container) and `website` (the published `$web` container).
  * For the working container, also pass `enumerate: () => container.list('')` so the editor
  * can reconcile its content index.
  */
-declare function azureStorage(container: BlobContainer): Storage;
+declare function azureStorage(container: BlobContainer): Storage & ConditionalBlobStore;
 
 /**
  * Pure path/name helper for the blob adapters. Blob storage is a *flat* namespace, a blob

package/dist/adapter-azure-blob.js

@@ -1,16 +1,26 @@
 import {
   contentTypeFor
-} from "./chunk-GFQT7BYP.js";
+} from "./chunk-P6NDWIKK.js";
 
 // ../../adapters/azure-blob/src/container.ts
 var InMemoryBlobContainer = class {
   blobs = /* @__PURE__ */ new Map();
   cacheControls = /* @__PURE__ */ new Map();
+  /** Per-blob version, bumped on every write, the in-memory stand-in for an ETag. */
+  versions = /* @__PURE__ */ new Map();
+  nextVersion = 1;
   constructor(seed = {}) {
     for (const [name, value] of Object.entries(seed)) {
-      this.blobs.set(name, typeof value === "string" ? new TextEncoder().encode(value) : value);
+      this.store(name, typeof value === "string" ? new TextEncoder().encode(value) : value);
     }
   }
+  store(name, bytes) {
+    this.blobs.set(name, bytes);
+    const version = this.nextVersion;
+    this.nextVersion += 1;
+    this.versions.set(name, version);
+    return version;
+  }
   async list(prefix) {
     const names = [];
     for (const name of this.blobs.keys()) {
@@ -23,11 +33,24 @@ var InMemoryBlobContainer = class {
   }
   async write(name, data, contentType, cacheControl) {
     void contentType;
-    this.blobs.set(name, data);
+    this.store(name, data);
     if (cacheControl !== void 0) this.cacheControls.set(name, cacheControl);
   }
   async remove(name) {
     this.blobs.delete(name);
+    this.versions.delete(name);
+  }
+  async readVersioned(name) {
+    const bytes = this.blobs.get(name);
+    if (bytes === void 0) return null;
+    return { bytes, version: String(this.versions.get(name)) };
+  }
+  async writeConditional(name, data, contentType, expected) {
+    void contentType;
+    const current = this.versions.get(name);
+    const currentTag = current === void 0 ? null : String(current);
+    if (currentTag !== expected) return void 0;
+    return String(this.store(name, data));
   }
   /** Test helper: the current blob names. */
   get names() {
@@ -41,8 +64,15 @@ var InMemoryBlobContainer = class {
 
 // ../../adapters/azure-blob/src/azure-container.ts
 import { BlobServiceClient } from "@azure/storage-blob";
+function statusCodeOf(error) {
+  return typeof error === "object" && error !== null && "statusCode" in error ? error.statusCode : void 0;
+}
 function isNotFound(error) {
-  return typeof error === "object" && error !== null && "statusCode" in error && error.statusCode === 404;
+  return statusCodeOf(error) === 404;
+}
+function isPreconditionFailure(error) {
+  const status = statusCodeOf(error);
+  return status === 412 || status === 409;
 }
 var AzureBlobContainer = class _AzureBlobContainer {
   constructor(client) {
@@ -85,7 +115,41 @@ var AzureBlobContainer = class _AzureBlobContainer {
   async remove(name) {
     await this.client.getBlockBlobClient(name).deleteIfExists();
   }
+  async readVersioned(name) {
+    try {
+      const response = await this.client.getBlockBlobClient(name).download();
+      const buffer = await streamToBuffer(response.readableStreamBody);
+      if (response.etag === void 0) {
+        throw new Error(`Azure blob ${name} returned no ETag on download`);
+      }
+      return { bytes: new Uint8Array(buffer), version: response.etag };
+    } catch (error) {
+      if (isNotFound(error)) return null;
+      throw error;
+    }
+  }
+  async writeConditional(name, data, contentType, expected) {
+    const conditions = expected === null ? { ifNoneMatch: "*" } : { ifMatch: expected };
+    try {
+      const response = await this.client.getBlockBlobClient(name).uploadData(Buffer.from(data), {
+        blobHTTPHeaders: { blobContentType: contentType },
+        conditions
+      });
+      return response.etag;
+    } catch (error) {
+      if (isPreconditionFailure(error)) return void 0;
+      throw error;
+    }
+  }
 };
+async function streamToBuffer(stream) {
+  if (stream === void 0) return Buffer.alloc(0);
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(chunk instanceof Buffer ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks);
+}
 
 // ../../adapters/azure-blob/src/paths.ts
 function normalizeBlobName(path) {
@@ -108,6 +172,13 @@ var BlobContainerStore = class {
   async delete(key) {
     await this.container.remove(normalizeBlobName(key));
   }
+  async getVersioned(key) {
+    return await this.container.readVersioned(normalizeBlobName(key)) ?? void 0;
+  }
+  async putConditional(key, bytes, expected) {
+    const name = normalizeBlobName(key);
+    return this.container.writeConditional(name, bytes, contentTypeFor(name), expected);
+  }
 };
 
 // ../../adapters/azure-blob/src/blob-sink.ts
@@ -138,8 +209,23 @@ function azureStorage(container) {
     // strips the publish Cache-Control before it reaches the blob.
     put: (key, bytes, cacheControl) => store.put(key, bytes, cacheControl),
     delete: (key) => store.delete(key),
+    // Optimistic-concurrency capability (DESIGN §11d): surfaced so a horizontally-scaled
+    // host's IndexedStore compare-and-sets the content index instead of blind-overwriting
+    // it, which is what stops two instances losing each other's updates
+    // (NANOESIS-MCP-ISSUES Issue 1). Azure blobs back this with native ETag conditions.
+    getVersioned: (key) => store.getVersioned(key),
+    putConditional: (key, bytes, expected) => store.putConditional(key, bytes, expected),
     wipe: async () => {
       for (const name of await container.list("")) await container.remove(name);
+    },
+    // Zero-downtime sweep (DESIGN §11): the publish overwrites every artifact in place, then
+    // calls this with the just-written path set so only orphaned blobs (pages the new publish
+    // did not emit) are removed. Every live URL keeps serving throughout, the old wipe-first
+    // path blanked the whole site for the upload window.
+    prune: async (keep) => {
+      for (const name of await container.list("")) {
+        if (!keep.has(name)) await container.remove(name);
+      }
     }
   };
 }

package/dist/{chunk-BCWZRKMF.js → chunk-C3QPGXG5.js}

@@ -18,7 +18,7 @@ import {
   renderReferenceMarkdown,
   validateSite,
   workingStoreRoundTripDiagnostic
-} from "./chunk-GFQT7BYP.js";
+} from "./chunk-P6NDWIKK.js";
 
 // ../editor-api/src/scaffold.ts
 var HOME_HTML = `<!doctype html>
@@ -559,7 +559,7 @@ async function dispatchApi(deps, req) {
       return json(422, {
         ok: false,
         errors: result.validation.errors.map((e) => e.message),
-        ...result.summary !== void 0 && { summary: result.summary }
+        ...result.summary !== void 0 && { wouldPublish: result.summary }
       });
     }
     case "/api/scaffold": {
@@ -949,12 +949,12 @@ function createEditor(config) {
     };
     try {
       const validation = await validateSite(working);
-      if (validation.ok && wipeBeforePublish && config.website.wipe !== void 0) {
+      if (validation.ok && wipeBeforePublish && config.website.prune === void 0 && config.website.wipe !== void 0) {
         await config.website.wipe();
       }
       const dir = config.users === void 0 ? void 0 : authorDirectory(await config.users());
       const prebuild = typeof config.prebuild === "function" ? await config.prebuild() : config.prebuild;
-      return await publishSite(working, sink, {
+      const result = await publishSite(working, sink, {
         ...config.images !== void 0 && { imageEncoder: config.images },
         ...config.purge !== void 0 && { purge: config.purge },
         ...config.baseUrl !== void 0 && { baseUrl: config.baseUrl },
@@ -962,6 +962,10 @@ function createEditor(config) {
         ...prebuild !== void 0 && { prebuild },
         onProgress: record
       });
+      if (result.ok && wipeBeforePublish && config.website.prune !== void 0) {
+        await config.website.prune(new Set(result.written));
+      }
+      return result;
     } finally {
       progressRunning = false;
     }
@@ -1170,6 +1174,12 @@ var TOOL_SPECS = [
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
     toRequest: (_args, token) => request("POST", "/api/publish", {}, void 0, token)
   },
+  {
+    name: "reconcile",
+    description: "Rebuild the content index from the files actually in storage, recovering any that drifted out of the index. Use this if `validate`, `list_dir`, or a `reference-missing` error reports a file as absent that `read_file` can still return: the file is stored but unenumerable, and reconcile makes it visible again without re-writing it. Idempotent and a no-op when nothing drifted. Returns the count added/removed and the new total. Reports an error on a host that cannot enumerate its store.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    toRequest: (_args, token) => request("POST", "/api/reconcile", {}, void 0, token)
+  },
   {
     name: "list_pending_migrations",
     description: "List content items whose JSON fields don't match their bound template's schema (orphan fields or missing required fields). Use this after a destructive template edit (you'll see a `stamped` record on write_file) to see what needs migrating, or any time to check site-wide drift.",