npm - @xtrable-ltd/nanoesis - Versions diffs - 0.1.26 → 0.1.28 - Mend

@xtrable-ltd/nanoesis 0.1.26 → 0.1.28

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-GFQT7BYP.js";
 // ../../adapters/azure-blob/src/container.ts
 var InMemoryBlobContainer = class {

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

@@ -13,11 +13,12 @@ import {
   loadComponents,
   loadTemplate,
   pendingMigrations,
+  planPublish,
   publishSite,
   renderReferenceMarkdown,
   validateSite,
   workingStoreRoundTripDiagnostic
-} from "./chunk-H6ZHZWDJ.js";
+} from "./chunk-GFQT7BYP.js";
 // ../editor-api/src/scaffold.ts
 var HOME_HTML = `<!doctype html>
@@ -531,6 +532,20 @@ 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/progress": {
+      if (req.method !== "GET") return json(405, { ok: false, error: "GET only" });
+      const since = Number.parseInt(get("since"), 10);
+      const snapshot = deps.publishProgress?.(Number.isFinite(since) ? since : 0) ?? {
+        running: false,
+        total: 0,
+        events: []
+      };
+      return json(200, snapshot);
+    }
     case "/api/publish": {
       if (req.method !== "POST") return methodNotAllowed();
       const result = await deps.publish();
@@ -923,26 +938,45 @@ 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 validation = await validateSite(working);
-    if (validation.ok && wipeBeforePublish && config.website.wipe !== void 0) {
-      await config.website.wipe();
+  let progressEvents = [];
+  let progressRunning = false;
+  const publish = async (options) => {
+    progressEvents = [];
+    progressRunning = true;
+    const record = (event) => {
+      progressEvents.push(event);
+      options?.onProgress?.(event);
+    };
+    try {
+      const validation = await validateSite(working);
+      if (validation.ok && wipeBeforePublish && 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, {
+        ...config.images !== void 0 && { imageEncoder: config.images },
+        ...config.purge !== void 0 && { purge: config.purge },
+        ...config.baseUrl !== void 0 && { baseUrl: config.baseUrl },
+        ...dir !== void 0 && { authorDirectory: dir },
+        ...prebuild !== void 0 && { prebuild },
+        onProgress: record
+      });
+    } finally {
+      progressRunning = false;
     }
-    const dir = config.users === void 0 ? void 0 : authorDirectory(await config.users());
-    const prebuild = typeof config.prebuild === "function" ? await config.prebuild() : config.prebuild;
-    return publishSite(working, sink, {
-      ...config.images !== void 0 && { imageEncoder: config.images },
-      ...config.purge !== void 0 && { purge: config.purge },
-      ...config.baseUrl !== void 0 && { baseUrl: config.baseUrl },
-      ...dir !== void 0 && { authorDirectory: dir },
-      ...prebuild !== void 0 && { prebuild }
-    });
   };
+  const publishProgress = (since) => ({
+    running: progressRunning,
+    total: progressEvents.length,
+    events: progressEvents.slice(Math.max(0, since))
+  });
   const users = config.users;
   const deps = {
     store: working,
     identity: config.login,
     publish,
+    publishProgress,
     diagnostics: config.diagnostics ?? buildDefaultDiagnostics(),
     ...reconcile !== void 0 && { reconcile },
     ...config.authEndpoints !== void 0 && { authEndpoints: config.authEndpoints },

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

@@ -2052,26 +2052,7 @@ 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;
+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, PublishProgress, ReconcileResult, AuthEndpoints, UserAdminEndpoints, AuthorOption, DiagnosticRegistry, Storage, ImageEncoder, PurgeService, UserSummary, PreBuildHook, AuthorDirectory, Repair, DiagnosticCheck } from '@nanoesis/engine';
 export { Storage } from '@nanoesis/engine';
 /**
@@ -94,13 +94,39 @@ interface ApiResponse {
     readonly headers?: Record<string, string>;
     readonly body?: string | Uint8Array;
 }
+/**
+ * A snapshot of the publish progress log from a cursor (DESIGN §11): the events a poller
+ * has not seen yet (`events`, those at index `since` onward), the running total so the
+ * client can advance its cursor, and whether a publish is still in flight. The editor polls
+ * `GET /api/publish/progress` for this and folds the events into its timeline. This is the
+ * progress transport for hosts that cannot stream an HTTP response (Azure Consumption).
+ */
+interface PublishProgressLog {
+    readonly running: boolean;
+    readonly total: number;
+    readonly events: readonly PublishProgress[];
+}
 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; a caller that
+     * ignores it (the MCP publish tool, tests) still gets the buffered {@link PublishResult}.
+     */
+    readonly publish: (options?: {
+        onProgress?: ProgressReporter;
+    }) => Promise<PublishResult>;
+    /**
+     * Optional live-progress snapshot for the editor's publish timeline (DESIGN §11). The
+     * running publish records its events; `GET /api/publish/progress?since=N` returns the
+     * events from cursor `N` plus whether it is still running, so the client polls instead of
+     * relying on HTTP streaming (which Azure Consumption does not support). Omitted on a host
+     * that does not track progress; the route then reports an idle log.
+     */
+    readonly publishProgress?: (since: number) => PublishProgressLog;
     /**
      * 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-BCWZRKMF.js";
+import "./chunk-GFQT7BYP.js";
 export {
   FileBrandingStore,
   InMemoryBrandingStore,