npm - @xtrable-ltd/nanoesis - Versions diffs - 0.1.25 → 0.1.27 - Mend

@xtrable-ltd/nanoesis 0.1.25 → 0.1.27

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (31) hide show

package/dist/adapter-azure-blob.js CHANGED Viewed

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

package/dist/{chunk-TEIQFPNO.js → chunk-CH4DCPNN.js} RENAMED Viewed

@@ -13,11 +13,12 @@ import {
   loadComponents,
   loadTemplate,
   pendingMigrations,
+  planPublish,
   publishSite,
   renderReferenceMarkdown,
   validateSite,
   workingStoreRoundTripDiagnostic
-} from "./chunk-H6ZHZWDJ.js";
+} from "./chunk-EGQLAHLP.js";
 // ../editor-api/src/scaffold.ts
 var HOME_HTML = `<!doctype html>
@@ -111,6 +112,46 @@ function json(status, data) {
 function methodNotAllowed() {
   return json(405, { ok: false, error: "POST only" });
 }
+var NDJSON = "application/x-ndjson";
+function streamingPublish(deps) {
+  const stream = async function* () {
+    const encoder = new TextEncoder();
+    const line = (event) => encoder.encode(`${JSON.stringify(event)}
+`);
+    const queue = [];
+    let wake;
+    let settled = false;
+    let thrown;
+    const onProgress = (event) => {
+      queue.push(event);
+      wake?.();
+    };
+    const running = deps.publish({ onProgress }).then(
+      () => void 0,
+      (error) => {
+        thrown = error;
+      }
+    ).finally(() => {
+      settled = true;
+      wake?.();
+    });
+    for (; ; ) {
+      if (queue.length === 0 && !settled) {
+        await new Promise((resolve2) => {
+          wake = resolve2;
+        });
+        wake = void 0;
+      }
+      while (queue.length > 0) yield line(queue.shift());
+      if (settled && queue.length === 0) break;
+    }
+    await running;
+    if (thrown !== void 0) {
+      yield line({ phase: "error", message: thrown instanceof Error ? thrown.message : String(thrown) });
+    }
+  };
+  return { status: 200, headers: { "content-type": NDJSON, "cache-control": "no-store" }, stream };
+}
 function withDefaultHeaders(response) {
   const headers = { ...response.headers ?? {} };
   if (headers["cache-control"] === void 0) {
@@ -531,8 +572,13 @@ async function dispatchApi(deps, req) {
       const status = result.reason === "exists" ? 409 : 404;
       return json(status, { ok: false, error: result.reason });
     }
+    case "/api/publish/plan": {
+      if (req.method !== "GET") return json(405, { ok: false, error: "GET only" });
+      return json(200, await planPublish(deps.store));
+    }
     case "/api/publish": {
       if (req.method !== "POST") return methodNotAllowed();
+      if ((req.getHeader("accept") ?? "").includes(NDJSON)) return streamingPublish(deps);
       const result = await deps.publish();
       if (result.ok) {
         return json(200, {
@@ -923,7 +969,7 @@ function createEditor(config) {
   const sink = asSink(config.website);
   const wipeBeforePublish = config.wipeBeforePublish ?? true;
   const reconcile = config.enumerate === void 0 ? void 0 : async () => working.reconcile([...await config.enumerate()]);
-  const publish = async () => {
+  const publish = async (options) => {
     const validation = await validateSite(working);
     if (validation.ok && wipeBeforePublish && config.website.wipe !== void 0) {
       await config.website.wipe();
@@ -935,7 +981,8 @@ function createEditor(config) {
       ...config.purge !== void 0 && { purge: config.purge },
       ...config.baseUrl !== void 0 && { baseUrl: config.baseUrl },
       ...dir !== void 0 && { authorDirectory: dir },
-      ...prebuild !== void 0 && { prebuild }
+      ...prebuild !== void 0 && { prebuild },
+      ...options?.onProgress !== void 0 && { onProgress: options.onProgress }
     });
   };
   const users = config.users;

package/dist/{chunk-H6ZHZWDJ.js → chunk-EGQLAHLP.js} RENAMED Viewed

@@ -2051,27 +2051,8 @@ function urlForItem(contentPath) {
 }
 // ../engine/src/compile/site.ts
-var DEFAULT_IMAGE_CONCURRENCY = 4;
-async function compileSite(source, options = {}) {
-  const [
-    tree,
-    components,
-    componentStyles,
-    componentScripts,
-    documentShell,
-    redirects,
-    siteConfig
-  ] = await Promise.all([
-    loadContentTree(source),
-    loadComponents(source),
-    loadComponentStyles(source),
-    loadComponentScripts(source),
-    loadDocumentShell(source),
-    loadRedirects(source),
-    loadSiteConfig(source)
-  ]);
-  const context = buildResolveContext(tree);
-  const baseUrl = options.baseUrl ?? siteConfig.baseUrl;
+var DEFAULT_IMAGE_CONCURRENCY = 16;
+async function planPages(tree, source, components) {
   const templateCache = /* @__PURE__ */ new Map();
   const getTemplate = async (name) => {
     const cached = templateCache.get(name);
@@ -2080,16 +2061,6 @@ async function compileSite(source, options = {}) {
     templateCache.set(name, loaded);
     return loaded;
   };
-  const styleCache = /* @__PURE__ */ new Map();
-  const scriptCache = /* @__PURE__ */ new Map();
-  const getStyle = async (name) => {
-    if (!styleCache.has(name)) styleCache.set(name, await loadTemplateStyle(source, name));
-    return styleCache.get(name);
-  };
-  const getScript = async (name) => {
-    if (!scriptCache.has(name)) scriptCache.set(name, await loadTemplateScript(source, name));
-    return scriptCache.get(name);
-  };
   const analysisCache = /* @__PURE__ */ new Map();
   const getAnalysis = (name, templateSource) => {
     const cached = analysisCache.get(name);
@@ -2098,8 +2069,7 @@ async function compileSite(source, options = {}) {
     analysisCache.set(name, analysis);
     return analysis;
   };
-  const artifacts = [];
-  const entries = [];
+  const plans = [];
   const walk = async (dir, inheritedTemplate) => {
     const dirTemplate = dir.defaultTemplate ?? inheritedTemplate;
     for (const child of dir.children) {
@@ -2116,34 +2086,126 @@ async function compileSite(source, options = {}) {
       }
       const template = await getTemplate(templateName);
       const analysis = getAnalysis(templateName, template);
-      const { media, mediaArtifacts } = await collectMedia(
-        source,
-        child,
-        analysis,
-        options.imageEncoder,
-        options.imageConcurrency ?? DEFAULT_IMAGE_CONCURRENCY
-      );
-      artifacts.push(...mediaArtifacts);
-      const templateStyle = await getStyle(templateName);
-      const templateScript = await getScript(templateName);
-      const contents = compileTemplate({
-        template,
-        scope: buildScope(child.item),
-        components,
-        context,
-        media,
-        componentStyles,
-        componentScripts,
-        ...options.authorDirectory !== void 0 && { authorDirectory: options.authorDirectory },
-        ...documentShell !== void 0 && { document: documentShell },
-        ...templateStyle !== void 0 && { templateStyle },
-        ...templateScript !== void 0 && { templateScript }
-      });
-      artifacts.push({ path: outputPathForItem(child.path), contents });
-      entries.push(toEntry(child));
+      plans.push({ node: child, templateName, template, refs: itemMediaRefs(child, analysis) });
     }
   };
   await walk(tree, void 0);
+  return plans;
+}
+function assetLabel(published) {
+  const slash = published.lastIndexOf("/");
+  return slash === -1 ? published : published.slice(slash + 1);
+}
+function buildPublishPlan(plans) {
+  const images = [];
+  const files = [];
+  const imageSeen = /* @__PURE__ */ new Set();
+  const fileSeen = /* @__PURE__ */ new Set();
+  for (const plan of plans) {
+    for (const { published } of plan.refs.images) {
+      if (imageSeen.has(published)) continue;
+      imageSeen.add(published);
+      images.push({ kind: "image", id: published, label: assetLabel(published) });
+    }
+    for (const { published } of plan.refs.files) {
+      if (fileSeen.has(published)) continue;
+      fileSeen.add(published);
+      files.push({ kind: "file", id: published, label: assetLabel(published) });
+    }
+  }
+  const pages = plans.map((plan) => ({
+    kind: "page",
+    id: outputPathForItem(plan.node.path),
+    label: plan.node.item.title
+  }));
+  return {
+    resources: [...images, ...files, ...pages],
+    images: images.length,
+    files: files.length,
+    pages: pages.length
+  };
+}
+async function planPublish(source) {
+  const [tree, components] = await Promise.all([loadContentTree(source), loadComponents(source)]);
+  return buildPublishPlan(await planPages(tree, source, components));
+}
+async function compileSite(source, options = {}) {
+  const [
+    tree,
+    components,
+    componentStyles,
+    componentScripts,
+    documentShell,
+    redirects,
+    siteConfig
+  ] = await Promise.all([
+    loadContentTree(source),
+    loadComponents(source),
+    loadComponentStyles(source),
+    loadComponentScripts(source),
+    loadDocumentShell(source),
+    loadRedirects(source),
+    loadSiteConfig(source)
+  ]);
+  const context = buildResolveContext(tree);
+  const baseUrl = options.baseUrl ?? siteConfig.baseUrl;
+  const styleCache = /* @__PURE__ */ new Map();
+  const scriptCache = /* @__PURE__ */ new Map();
+  const getStyle = async (name) => {
+    if (!styleCache.has(name)) styleCache.set(name, await loadTemplateStyle(source, name));
+    return styleCache.get(name);
+  };
+  const getScript = async (name) => {
+    if (!scriptCache.has(name)) scriptCache.set(name, await loadTemplateScript(source, name));
+    return scriptCache.get(name);
+  };
+  const artifacts = [];
+  const entries = [];
+  const plans = await planPages(tree, source, components);
+  const onProgress = options.onProgress;
+  let done = 0;
+  let resourceById;
+  if (onProgress !== void 0) {
+    const publishPlan = buildPublishPlan(plans);
+    resourceById = new Map(publishPlan.resources.map((resource) => [resource.id, resource]));
+    onProgress({ phase: "plan", plan: publishPlan });
+  }
+  const report = (id) => {
+    if (onProgress === void 0 || resourceById === void 0) return;
+    const resource = resourceById.get(id);
+    if (resource === void 0) return;
+    done += 1;
+    onProgress({ phase: "resource", resource, done, total: resourceById.size });
+  };
+  const { mediaArtifacts, imageInfoByPublished, fileUrlByPublished } = await collectSiteMedia(
+    source,
+    plans.map((p) => p.refs),
+    options.imageEncoder,
+    options.imageConcurrency ?? DEFAULT_IMAGE_CONCURRENCY,
+    onProgress === void 0 ? void 0 : (published) => report(published)
+  );
+  artifacts.push(...mediaArtifacts);
+  for (const { node, templateName, template, refs } of plans) {
+    const templateStyle = await getStyle(templateName);
+    const templateScript = await getScript(templateName);
+    const contents = compileTemplate({
+      template,
+      scope: buildScope(node.item),
+      components,
+      context,
+      media: resolverFor(refs, imageInfoByPublished, fileUrlByPublished),
+      componentStyles,
+      componentScripts,
+      ...options.authorDirectory !== void 0 && { authorDirectory: options.authorDirectory },
+      ...documentShell !== void 0 && { document: documentShell },
+      ...templateStyle !== void 0 && { templateStyle },
+      ...templateScript !== void 0 && { templateScript }
+    });
+    const outputPath = outputPathForItem(node.path);
+    artifacts.push({ path: outputPath, contents });
+    entries.push(toEntry(node));
+    report(outputPath);
+  }
   const redirectArtifact = buildRedirects(redirects, new Set(entries.map((entry) => entry.url)));
   if (redirectArtifact !== void 0) artifacts.push(redirectArtifact);
   if (options.contentIndex !== false) artifacts.push(buildContentIndex(entries));
@@ -2189,14 +2251,14 @@ async function compilePage(source, itemPath, options = {}) {
   if (options.media !== void 0) {
     media = options.media;
   } else {
-    const collected = await collectMedia(
+    const refs = itemMediaRefs(node, analysis);
+    const collected = await collectSiteMedia(
       source,
-      node,
-      analysis,
+      [refs],
       options.imageEncoder,
       DEFAULT_IMAGE_CONCURRENCY
     );
-    media = collected.media;
+    media = resolverFor(refs, collected.imageInfoByPublished, collected.fileUrlByPublished);
     mediaArtifacts = collected.mediaArtifacts;
   }
   const html = compileTemplate({
@@ -2244,48 +2306,91 @@ function inCollection(entry, collectionPath) {
   if (collection === "") return true;
   return entry.path === collection || entry.path.startsWith(`${collection}/`);
 }
-async function collectMedia(source, node, analysis, encoder, imageConcurrency) {
+function itemMediaRefs(node, analysis) {
   const itemDir = parentPath(node.path);
   const fields = node.item.fields;
-  const images = /* @__PURE__ */ new Map();
-  const files = /* @__PURE__ */ new Map();
-  const mediaArtifacts = [];
+  const files = [];
   for (const field of analysis.fileFields) {
     for (const ref of assetRefs(fields[field])) {
-      const published = joinAsset(itemDir, ref);
-      const bytes = await tryReadBytes(source, `content/${published}`);
-      if (bytes === void 0) continue;
-      mediaArtifacts.push({ path: published, contents: bytes });
-      files.set(ref, `/${published}`);
+      files.push({ ref, published: joinAsset(itemDir, ref) });
     }
   }
-  if (encoder !== void 0) {
-    const imageRefs = /* @__PURE__ */ new Set();
-    for (const field of analysis.imageFields) {
-      for (const ref of assetRefs(fields[field])) imageRefs.add(ref);
-    }
-    for (const field of analysis.richTextFields) {
-      const value = fields[field];
-      if (typeof value === "string") {
-        for (const ref of inlineImageRefs(value)) imageRefs.add(ref);
+  const images = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addImage = (ref) => {
+    if (seen.has(ref)) return;
+    seen.add(ref);
+    images.push({ ref, published: joinAsset(itemDir, ref) });
+  };
+  for (const field of analysis.imageFields) {
+    for (const ref of assetRefs(fields[field])) addImage(ref);
+  }
+  for (const field of analysis.richTextFields) {
+    const value = fields[field];
+    if (typeof value === "string") {
+      for (const ref of inlineImageRefs(value)) addImage(ref);
+    }
+  }
+  return { images, files };
+}
+async function collectSiteMedia(source, itemRefs, encoder, imageConcurrency, onAsset) {
+  const uniqueOrdered = (pick) => {
+    const seen = /* @__PURE__ */ new Set();
+    const order = [];
+    for (const refs of itemRefs) {
+      for (const { published } of pick(refs)) {
+        if (!seen.has(published)) {
+          seen.add(published);
+          order.push(published);
+        }
       }
     }
-    const encoded = await mapWithConcurrency([...imageRefs], imageConcurrency, async (ref) => {
-      const published = joinAsset(itemDir, ref);
+    return order;
+  };
+  const mediaArtifacts = [];
+  const filePaths = uniqueOrdered((r) => r.files);
+  const fileBytes = await mapWithConcurrency(filePaths, imageConcurrency, async (published) => {
+    const bytes = await tryReadBytes(source, `content/${published}`);
+    onAsset?.(published);
+    return bytes;
+  });
+  const fileUrlByPublished = /* @__PURE__ */ new Map();
+  filePaths.forEach((published, index) => {
+    const bytes = fileBytes[index];
+    if (bytes === void 0) return;
+    mediaArtifacts.push({ path: published, contents: bytes });
+    fileUrlByPublished.set(published, `/${published}`);
+  });
+  const imageInfoByPublished = /* @__PURE__ */ new Map();
+  if (encoder !== void 0) {
+    const imagePaths = uniqueOrdered((r) => r.images);
+    const encoded = await mapWithConcurrency(imagePaths, imageConcurrency, async (published) => {
       const bytes = await tryReadBytes(source, `content/${published}`);
-      if (bytes === void 0) return void 0;
-      return { ref, ...await processImage(bytes, published, encoder) };
+      const result = bytes === void 0 ? void 0 : await processImage(bytes, published, encoder);
+      onAsset?.(published);
+      return result;
     });
-    for (const result of encoded) {
-      if (result === void 0) continue;
+    imagePaths.forEach((published, index) => {
+      const result = encoded[index];
+      if (result === void 0) return;
       mediaArtifacts.push(...result.artifacts);
-      images.set(result.ref, result.info);
-    }
+      imageInfoByPublished.set(published, result.info);
+    });
   }
-  return {
-    media: { image: (ref) => images.get(ref), file: (ref) => files.get(ref) },
-    mediaArtifacts
-  };
+  return { mediaArtifacts, imageInfoByPublished, fileUrlByPublished };
+}
+function resolverFor(refs, imageInfoByPublished, fileUrlByPublished) {
+  const imageByRef = /* @__PURE__ */ new Map();
+  for (const { ref, published } of refs.images) {
+    const info = imageInfoByPublished.get(published);
+    if (info !== void 0) imageByRef.set(ref, info);
+  }
+  const fileByRef = /* @__PURE__ */ new Map();
+  for (const { ref, published } of refs.files) {
+    const url = fileUrlByPublished.get(published);
+    if (url !== void 0) fileByRef.set(ref, url);
+  }
+  return { image: (ref) => imageByRef.get(ref), file: (ref) => fileByRef.get(ref) };
 }
 async function tryReadBytes(source, path) {
   try {
@@ -3078,9 +3183,12 @@ var noopPurgeService = {
 // ../engine/src/publish/publish.ts
 var DEFAULT_WRITE_CONCURRENCY = 8;
 async function publishSite(source, sink, options = {}) {
+  const onProgress = options.onProgress;
+  onProgress?.({ phase: "validate" });
   const validation = await validateSite(source);
   const summary = summarizeTree(await loadContentTree(source));
   if (!validation.ok) {
+    onProgress?.({ phase: "blocked", errors: validation.errors.map((error) => error.message) });
     return { ok: false, validation, written: [], summary };
   }
   const {
@@ -3104,12 +3212,16 @@ async function publishSite(source, sink, options = {}) {
   );
   const byPath = /* @__PURE__ */ new Map();
   for (const artifact of [...stamped, ...passthrough]) byPath.set(artifact.path, artifact);
-  await mapWithConcurrency(
-    [...byPath.values()],
-    writeConcurrency,
-    (artifact) => sink.write(artifact.path, artifact.contents, cacheControlFor(artifact))
-  );
+  const uploadTotal = byPath.size;
+  let uploaded = 0;
+  await mapWithConcurrency([...byPath.values()], writeConcurrency, async (artifact) => {
+    await sink.write(artifact.path, artifact.contents, cacheControlFor(artifact));
+    uploaded += 1;
+    onProgress?.({ phase: "upload", written: uploaded, total: uploadTotal });
+  });
+  if (purge !== noopPurgeService) onProgress?.({ phase: "purge" });
   await purge.purgeAll();
+  onProgress?.({ phase: "done", written: uploadTotal, summary });
   return { ok: true, validation, written: [...byPath.keys()].sort(), summary };
 }
 function asBytes(contents) {
@@ -3420,6 +3532,7 @@ export {
   buildContentIndex,
   outputPathForItem,
   urlForItem,
+  planPublish,
   compileSite,
   compilePage,
   buildResolveContext,

package/dist/editor-api.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { WorkingStore, IdentityProvider, PublishResult, ReconcileResult, AuthEndpoints, UserAdminEndpoints, AuthorOption, DiagnosticRegistry, Storage, ImageEncoder, PurgeService, UserSummary, PreBuildHook, AuthorDirectory, Repair, DiagnosticCheck } from '@nanoesis/engine';
+import { WorkingStore, IdentityProvider, ProgressReporter, PublishResult, ReconcileResult, AuthEndpoints, UserAdminEndpoints, AuthorOption, DiagnosticRegistry, Storage, ImageEncoder, PurgeService, UserSummary, PreBuildHook, AuthorDirectory, Repair, DiagnosticCheck } from '@nanoesis/engine';
 export { Storage } from '@nanoesis/engine';
 /**
@@ -93,14 +93,28 @@ interface ApiResponse {
     readonly status: number;
     readonly headers?: Record<string, string>;
     readonly body?: string | Uint8Array;
+    /**
+     * A streaming body (DESIGN §11): when present, the host writes these chunks as they are
+     * produced instead of `body`, for the publish-progress NDJSON stream. A host that cannot
+     * stream may buffer the chunks and send them as one body, the client decodes the same
+     * NDJSON either way. `body` is ignored when `stream` is set.
+     */
+    readonly stream?: () => AsyncIterable<Uint8Array>;
 }
 interface ApiDeps {
     /** The editor working store (read + write/delete/rename), any {@link WorkingStore}. */
     readonly store: WorkingStore;
     /** Who is calling, gates every editing route (DESIGN §11). */
     readonly identity: IdentityProvider;
-    /** Run the publish pipeline (host binds source/sink/purge). */
-    readonly publish: () => Promise<PublishResult>;
+    /**
+     * Run the publish pipeline (host binds source/sink/purge). The optional `onProgress`
+     * callback receives {@link PublishProgress} events as the publish runs, so the streaming
+     * `/api/publish` route can relay a live timeline; a caller that ignores it (the MCP
+     * publish tool, tests) gets the same buffered {@link PublishResult}.
+     */
+    readonly publish: (options?: {
+        onProgress?: ProgressReporter;
+    }) => Promise<PublishResult>;
     /**
      * Optional index-reconcile (DESIGN §11d): rebuild the working store's content index
      * from the keys actually present, recovering files that arrived by a path that

package/dist/editor-api.js CHANGED Viewed

@@ -21,8 +21,8 @@ import {
   serveEditorAsset,
   templateSnapshotIntegrityDiagnostic,
   templateSuffixConflictDiagnostic
-} from "./chunk-TEIQFPNO.js";
-import "./chunk-H6ZHZWDJ.js";
+} from "./chunk-CH4DCPNN.js";
+import "./chunk-EGQLAHLP.js";
 export {
   FileBrandingStore,
   InMemoryBrandingStore,