@xtrable-ltd/nanoesis 0.1.7 → 0.1.9

package/dist/adapter-azure-blob.js

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

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

@@ -2560,6 +2560,171 @@ function canEdit(principal) {
   return hasRole(principal, "author") || hasRole(principal, "developer");
 }
 
+// ../engine/src/diagnose/registry.ts
+function createDiagnosticRegistry() {
+  const diagnostics = /* @__PURE__ */ new Map();
+  const repairs = /* @__PURE__ */ new Map();
+  const runAll = async (deps) => {
+    const out = [];
+    for (const diagnostic of diagnostics.values()) {
+      try {
+        const findings = await diagnostic.run(deps);
+        out.push(...findings);
+      } catch (error) {
+        out.push(crashFinding(diagnostic.id, error));
+      }
+    }
+    return out;
+  };
+  return {
+    add(diagnostic) {
+      if (diagnostics.has(diagnostic.id)) {
+        throw new Error(`Diagnostic id "${diagnostic.id}" is already registered`);
+      }
+      diagnostics.set(diagnostic.id, diagnostic);
+    },
+    addRepair(repair) {
+      if (repairs.has(repair.id)) {
+        throw new Error(`Repair id "${repair.id}" is already registered`);
+      }
+      repairs.set(repair.id, repair);
+    },
+    runAll,
+    async runRepair(id, deps) {
+      const repair = repairs.get(id);
+      if (repair === void 0) throw new Error(`Unknown repair id: ${id}`);
+      await repair.run(deps);
+      return runAll(deps);
+    }
+  };
+}
+function crashFinding(diagnosticId, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    id: `${diagnosticId}.crashed`,
+    source: "connectivity",
+    severity: "error",
+    title: `Diagnostic "${diagnosticId}" crashed`,
+    detail: `The diagnostic itself threw an error: ${message}`
+  };
+}
+
+// ../engine/src/diagnose/port-probes.ts
+var PROBE_PATH = "__nanoesis-diagnose-probe.tmp";
+var PROBE_CONTENT = "__nanoesis-diagnose-probe__";
+var DIAGNOSTIC_ID = "connectivity.working-store-roundtrip";
+var workingStoreRoundTripDiagnostic = {
+  id: DIAGNOSTIC_ID,
+  async run({ store }) {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    try {
+      await store.write(PROBE_PATH, encoder.encode(PROBE_CONTENT));
+    } catch (error) {
+      return [
+        finding(
+          "write-failed",
+          "Working store write failed",
+          `The diagnostics probe could not write a temporary file (${PROBE_PATH}). The store's adapter reported: ${describe(error)}`
+        )
+      ];
+    }
+    try {
+      const bytes = await store.readBytes(PROBE_PATH);
+      if (decoder.decode(bytes) !== PROBE_CONTENT) {
+        await silently(() => store.delete(PROBE_PATH));
+        return [
+          finding(
+            "read-mismatch",
+            "Working store wrote different bytes than were read back",
+            `The probe wrote ${PROBE_CONTENT.length} bytes but readBytes returned a different value. The store's writes are not durably persisting through reads.`
+          )
+        ];
+      }
+    } catch (error) {
+      await silently(() => store.delete(PROBE_PATH));
+      return [
+        finding(
+          "read-failed",
+          "Working store could not read its own probe write",
+          `The diagnostics probe wrote ${PROBE_PATH} but reading it back failed: ${describe(error)}. The write may have been silently dropped, or the store is partitioned (writes and reads going to different backends).`
+        )
+      ];
+    }
+    try {
+      const entries = await store.list("");
+      if (!entries.some((entry) => entry.name === PROBE_PATH)) {
+        await silently(() => store.delete(PROBE_PATH));
+        return [
+          finding(
+            "list-misses-probe",
+            "Working store cannot enumerate its own write",
+            `The probe at ${PROBE_PATH} read back successfully, but does not appear when the store lists its root. The store's enumeration is out of sync with what it stores \u2014 typically a content-index drift.`
+          )
+        ];
+      }
+    } catch (error) {
+      await silently(() => store.delete(PROBE_PATH));
+      return [
+        finding(
+          "list-failed",
+          "Working store list threw",
+          `Enumeration of the store root failed: ${describe(error)}.`
+        )
+      ];
+    }
+    try {
+      await store.delete(PROBE_PATH);
+    } catch (error) {
+      return [
+        finding(
+          "delete-failed",
+          "Working store delete threw",
+          `The probe could not be cleaned up: ${describe(error)}. A file named ${PROBE_PATH} may remain in the store.`
+        )
+      ];
+    }
+    try {
+      if (await store.exists(PROBE_PATH)) {
+        return [
+          finding(
+            "delete-ineffective",
+            "Working store delete did not remove the probe",
+            `After deleting ${PROBE_PATH} the store still reports it exists. Deletes are not taking effect \u2014 typically a soft-delete configuration that hides items instead of removing them.`
+          )
+        ];
+      }
+    } catch (error) {
+      return [
+        finding(
+          "exists-failed",
+          "Working store exists() threw on the probe",
+          `After the probe was deleted, exists() threw rather than returning false: ${describe(error)}.`
+        )
+      ];
+    }
+    return [];
+  }
+};
+function finding(suffix, title, detail) {
+  return {
+    id: `${DIAGNOSTIC_ID}.${suffix}`,
+    source: "connectivity",
+    severity: "error",
+    title,
+    detail
+  };
+}
+function describe(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function silently(work) {
+  try {
+    await work();
+  } catch {
+  }
+}
+
 export {
   slugify,
   humanize,
@@ -2622,5 +2787,7 @@ export {
   publishSite,
   InMemoryArtifactSink,
   hasRole,
-  canEdit
+  canEdit,
+  createDiagnosticRegistry,
+  workingStoreRoundTripDiagnostic
 };

package/dist/editor-api.d.ts

@@ -1,4 +1,4 @@
-import { WorkingStore, IdentityProvider, PublishResult, ReconcileResult, AuthEndpoints, UserAdminEndpoints, AuthorOption, UserSummary, AuthorDirectory } from '@nanoesis/engine';
+import { WorkingStore, IdentityProvider, PublishResult, ReconcileResult, AuthEndpoints, UserAdminEndpoints, AuthorOption, DiagnosticRegistry, UserSummary, AuthorDirectory, DiagnosticCheck, Repair } from '@nanoesis/engine';
 
 /**
  * Editor white-labelling storage (DESIGN §11, Phase B). This is the *editor app's*
@@ -139,6 +139,16 @@ interface ApiDeps {
      * store and feeds the *same* users to the compiler's `authorDirectory` at publish.
      */
     readonly authors?: () => Promise<readonly AuthorOption[]>;
+    /**
+     * Optional diagnostics + self-heal registry. When present, the router mounts the
+     * admin-only `GET /api/admin/diagnostics` (run all probes, return findings) and
+     * `POST /api/admin/diagnostics/repair` (run a named repair, return refreshed findings).
+     * The registry is port-agnostic: it depends only on the engine's port contracts, so
+     * adopters using their own adapters get the same diagnostics with no per-host wiring.
+     * Hosts typically supply {@link buildDefaultDiagnostics}; omit on a deployment that
+     * has no admin operator (an embedded read-only host).
+     */
+    readonly diagnostics?: DiagnosticRegistry;
 }
 /**
  * Dispatch one API request. The editor is private, so every route requires an editing
@@ -241,4 +251,39 @@ declare function readMcpResource(uri: string): {
  */
 declare const SCAFFOLD_FILES: Readonly<Record<string, string>>;
 
-export { type ApiDeps, type ApiRequest, type ApiResponse, type BrandingLogo, type BrandingLogoMeta, type BrandingState, type BrandingStore, FileBrandingStore, InMemoryBrandingStore, MCP_RESOURCES, MCP_TOOLS, type McpCallOptions, type McpResourceDef, type McpToolDef, type McpToolResult, SCAFFOLD_FILES, authorDirectory, authorOptions, callMcpTool, handleApi, readMcpResource };
+/**
+ * The default {@link DiagnosticRegistry} the host mounts behind `/api/admin/diagnostics`.
+ * Combines the engine's port-agnostic round-trip probe (works against any adapter) with
+ * the scaffold-aware content checks that need to know what a "home template" is. The
+ * editor-api layer is the right home for the latter: the engine has no opinion on what
+ * paths matter, while the scaffold is bundled here as pure data (so MCP and every host
+ * see the same set; see scaffold.ts).
+ *
+ * Returned registry is mutable — a host that needs site-specific checks can call `add` /
+ * `addRepair` before mounting it.
+ */
+declare function buildDefaultDiagnostics(): DiagnosticRegistry;
+/**
+ * `templates/home.html` is the locked path the editor refuses to rename, move, or delete,
+ * and the scaffold guarantees it on first run. A missing home template means the site has
+ * no home page and no template to fall back to; restoring the bundled scaffold version is
+ * a one-click fix (the page is just the user's content again, the template is what was
+ * deleted out from under them — typically by a direct blob-store edit).
+ */
+declare const homeTemplateMissingDiagnostic: DiagnosticCheck;
+/**
+ * Restore `templates/home.html` from the bundled scaffold. Idempotent: if a customised
+ * home template already exists this is a no-op, so a stale UI re-firing the repair never
+ * silently overwrites real work. The home template is the only file the scaffold owns
+ * as "the locked, blessed copy", so reset semantics are correct here.
+ */
+declare const recreateHomeTemplateRepair: Repair;
+/**
+ * A site with zero `isPublished: true` items publishes nothing — a common confused-user
+ * state. We surface it as a warning (the publish still completes, just empty), not an
+ * error, because the situation is legitimate during early authoring. No auto-repair: the
+ * user picks what to publish; we only point out that nothing is.
+ */
+declare const noPublishedContentDiagnostic: DiagnosticCheck;
+
+export { type ApiDeps, type ApiRequest, type ApiResponse, type BrandingLogo, type BrandingLogoMeta, type BrandingState, type BrandingStore, FileBrandingStore, InMemoryBrandingStore, MCP_RESOURCES, MCP_TOOLS, type McpCallOptions, type McpResourceDef, type McpToolDef, type McpToolResult, SCAFFOLD_FILES, authorDirectory, authorOptions, buildDefaultDiagnostics, callMcpTool, handleApi, homeTemplateMissingDiagnostic, noPublishedContentDiagnostic, readMcpResource, recreateHomeTemplateRepair };

package/dist/editor-api.js

@@ -2,13 +2,15 @@ import {
   buildAuthoringReference,
   canEdit,
   contentTypeFor,
+  createDiagnosticRegistry,
   deriveFields,
   hasRole,
   loadComponents,
   loadTemplate,
   renderReferenceMarkdown,
-  validateSite
-} from "./chunk-Y7PUOM5I.js";
+  validateSite,
+  workingStoreRoundTripDiagnostic
+} from "./chunk-J6VYOB47.js";
 
 // ../editor-api/src/scaffold.ts
 var HOME_HTML = `<!doctype html>
@@ -227,6 +229,31 @@ async function handleUserAdminRoute(deps, req, caller) {
   }
   return json(404, { ok: false, error: `Unknown API route: ${req.path}` });
 }
+async function handleDiagnosticsRoute(deps, req, caller) {
+  const registry = deps.diagnostics;
+  if (registry === void 0) {
+    return json(404, { ok: false, error: "diagnostics are not available on this host" });
+  }
+  if (!hasRole(caller, "admin")) {
+    return json(403, { ok: false, error: "admin role required" });
+  }
+  if (req.path === "/api/admin/diagnostics") {
+    if (req.method !== "GET") return json(405, { ok: false, error: "method not allowed" });
+    const findings = await registry.runAll({ store: deps.store });
+    return json(200, { findings });
+  }
+  if (req.method !== "POST") return json(405, { ok: false, error: "method not allowed" });
+  const body = await parseJsonBody(req);
+  if (!isObject(body) || typeof body["id"] !== "string") {
+    return json(400, { ok: false, error: "JSON body with repair id required" });
+  }
+  try {
+    const findings = await registry.runRepair(body["id"], { store: deps.store });
+    return json(200, { findings });
+  } catch (error) {
+    return json(400, { ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+}
 async function handleBrandingRoute(deps, req) {
   if (req.path !== "/api/branding" && req.path !== "/api/branding/logo") return void 0;
   const store = deps.branding;
@@ -292,6 +319,9 @@ async function dispatchApi(deps, req) {
   if (req.path === "/api/users" || req.path.startsWith("/api/users/")) {
     return handleUserAdminRoute(deps, req, principal);
   }
+  if (req.path === "/api/admin/diagnostics" || req.path === "/api/admin/diagnostics/repair") {
+    return handleDiagnosticsRoute(deps, req, principal);
+  }
   const get = (key) => req.query.get(key) ?? "";
   switch (req.path) {
     case "/api/list": {
@@ -610,6 +640,82 @@ function readMcpResource(uri) {
   return void 0;
 }
 
+// ../editor-api/src/diagnose.ts
+function buildDefaultDiagnostics() {
+  const registry = createDiagnosticRegistry();
+  registry.add(workingStoreRoundTripDiagnostic);
+  registry.add(homeTemplateMissingDiagnostic);
+  registry.add(noPublishedContentDiagnostic);
+  registry.addRepair(recreateHomeTemplateRepair);
+  return registry;
+}
+var HOME_PATH = "templates/home.html";
+var homeTemplateMissingDiagnostic = {
+  id: "content.home-template",
+  async run({ store }) {
+    if (await store.exists(HOME_PATH)) return [];
+    return [
+      {
+        id: "content.home-template.missing",
+        source: "content",
+        severity: "error",
+        title: "Home template is missing",
+        detail: `The locked path ${HOME_PATH} does not exist. Without it, the editor cannot render the home page and publishing will fail to compile the index. Recreate it from the bundled scaffold to restore the working state.`,
+        repair: { id: "content.home-template.recreate", label: "Recreate home template" }
+      }
+    ];
+  }
+};
+var recreateHomeTemplateRepair = {
+  id: "content.home-template.recreate",
+  async run({ store }) {
+    if (await store.exists(HOME_PATH)) return;
+    const bytes = new TextEncoder().encode(SCAFFOLD_FILES[HOME_PATH]);
+    await store.write(HOME_PATH, bytes);
+  }
+};
+var noPublishedContentDiagnostic = {
+  id: "content.no-published-content",
+  async run({ store }) {
+    const published = await anyPublishedContentItem(store);
+    if (published) return [];
+    return [
+      {
+        id: "content.no-published-content",
+        source: "content",
+        severity: "warning",
+        title: "Nothing is published",
+        detail: "No content item has isPublished: true, so a publish would produce no pages. Open a content item and toggle Published, then publish again."
+      }
+    ];
+  }
+};
+async function anyPublishedContentItem(store, dir = "content") {
+  let entries;
+  try {
+    entries = await store.list(dir);
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    const path = dir === "" ? entry.name : `${dir}/${entry.name}`;
+    if (entry.kind === "dir") {
+      if (await anyPublishedContentItem(store, path)) return true;
+      continue;
+    }
+    if (!entry.name.endsWith(".json")) continue;
+    try {
+      const text = await store.readText(path);
+      const data = JSON.parse(text);
+      if (typeof data === "object" && data !== null && data.isPublished === true) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+
 // ../editor-api/src/branding.ts
 import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
 import { dirname, join } from "path";
@@ -714,7 +820,11 @@ export {
   SCAFFOLD_FILES,
   authorDirectory,
   authorOptions,
+  buildDefaultDiagnostics,
   callMcpTool,
   handleApi,
-  readMcpResource
+  homeTemplateMissingDiagnostic,
+  noPublishedContentDiagnostic,
+  readMcpResource,
+  recreateHomeTemplateRepair
 };

package/dist/index.d.ts

@@ -919,18 +919,18 @@ declare function analyzeTemplate(source: string, components?: ComponentMap): Tem
  * are returned as data (not thrown), so a host can present the clear list a user
  * needs (CLAUDE.md §2: "3 things would break: …").
  */
-type Severity = 'error' | 'warning';
-interface Diagnostic {
-    readonly severity: Severity;
+type Severity$1 = 'error' | 'warning';
+interface Diagnostic$1 {
+    readonly severity: Severity$1;
     readonly code: string;
     readonly message: string;
     /** Content path of the item/dir the diagnostic concerns, when applicable. */
     readonly path?: string;
 }
 interface ValidationResult {
-    readonly diagnostics: readonly Diagnostic[];
-    readonly errors: readonly Diagnostic[];
-    readonly warnings: readonly Diagnostic[];
+    readonly diagnostics: readonly Diagnostic$1[];
+    readonly errors: readonly Diagnostic$1[];
+    readonly warnings: readonly Diagnostic$1[];
     /** True when there are no errors, i.e. a publish may proceed. */
     readonly ok: boolean;
 }
@@ -1302,4 +1302,93 @@ declare function escapeJsonStringContent(value: string): string;
  */
 declare function sanitizeUrl(url: string): string;
 
-export { type Artifact, type ArtifactSink, type AuthEndpoints, type AuthResult, type AuthorDirectory, type AuthorEntry, type AuthorOption, type AuthorRef, type AuthoringReference, type BlobStore, type BoundItem, type ChangePasswordRequest, type ChangePasswordSuccess, type CollectionConfig, type CollectionQuery, type CompileInput, type CompilePageOptions, type CompileSiteOptions, type CompiledPage, type ComponentMap, type ContentIndex, type ContentItem, ContentParseError, type ContentSource, type CreateTokenSuccess, type CreateUserRequest, DEFAULT_DIRS, DOCUMENT_SHELL, type DerivedField, type Diagnostic, type DirEntry, type DirNode, type EncodeRequest, type EncodedImage, type EncodedVariant, type EntryKind, FIELD_TYPES, type FieldPrimitive, type FieldRecord, type FieldType, type FieldTypeDef, type FieldValue, type IdentityProvider, type ImageEncoder, type ImageFormat, type ImageInfo, InMemoryArtifactSink, InMemoryBlobStore, InMemoryContentSource, IndexedStore, type ItemNode, type LengthConstraints, type LoginRequest, type LoginSuccess, type MediaResolver, type PageEntry, type PreBuildHook, type Principal, type PublishOptions, type PublishResult, type PublishSummary, type PurgeService, RESERVED_PREFIX, type ReconcileResult, type RedirectRule, type ReferenceContext, type ReferenceEntry, type ReferenceSection, type RefreshSuccess, type RenameResult, type ResetPasswordRequest, type ResolveContext, type Role, type RssOptions, type Scope, type Severity, type SiteConfig, type SortFile, type TemplateAnalysis, type TokenContext, type TokenRef, type TreeNode, type UpdateUserRequest, type UserAdminEndpoints, type UserSummary, type ValidationResult, type ValueKind, type WorkingStore, analyzeTemplate, buildAuthoringReference, buildContentIndex, buildPictureMarkup, buildRedirects, buildResolveContext, buildRss, buildSitemap, canEdit, compilePage, compileSite, compileTemplate, contentHash, contentTypeFor, deriveFields, emptyIndex, escapeHtmlAttribute, escapeHtmlText, escapeJsonStringContent, findTokens, hasRole, humanize, inferControl, isFieldType, joinAuthors, loadComponentScripts, loadComponentStyles, loadComponents, loadContentTree, loadDocumentShell, loadIndex, loadRedirects, loadSiteConfig, loadTemplate, noopPurgeService, outputPathForItem, parseContentItem, parseRedirects, parseSortFile, processImage, publishSite, reconcileIndex, renderAuthors, renderReferenceMarkdown, sanitizeUrl, saveIndex, slugify, textContent, toAuthorRefs, urlForItem, validateSite, valueKindOf, wholeValueToken };
+/**
+ * The diagnostics + self-heal feature (CLAUDE.md §2: expected failures are data, not
+ * exceptions; we generalise the validation gate's shape from "is this content
+ * publishable?" to "is this whole installation healthy?"). A diagnostic is a port-agnostic
+ * probe that returns {@link Finding}s; a repair is an idempotent fix that runs through the
+ * same ports. Both layers know nothing of any specific host or adapter: when an adapter
+ * fails a round-trip probe, the surfacing detail is whatever that adapter put in its
+ * thrown error's message. Adapter authors who want richer detail write richer errors,
+ * not a new interface on the engine.
+ */
+type Severity = 'error' | 'warning' | 'info';
+/**
+ * What broad area of the system a finding concerns; UI groups by this. Deliberately
+ * coarse and stable — adding adapter-specific categories ("kv", "cloudflare", …) would
+ * couple the engine to specific cloud concepts, which is what we are avoiding.
+ */
+type Source = 'content' | 'index' | 'auth' | 'connectivity';
+/**
+ * One thing the diagnostics gate found wrong (or noteworthy). Shape mirrors the
+ * validation gate's {@link Diagnostic} type so a future merger is one step.
+ */
+interface Finding {
+    /** Stable across runs of the same diagnostic, so the UI can dedupe and target repairs. */
+    readonly id: string;
+    readonly source: Source;
+    readonly severity: Severity;
+    /** Short human-readable headline ("Home template is missing"). */
+    readonly title: string;
+    /** Full prose explaining what's wrong and where it was detected. */
+    readonly detail: string;
+    /** Present iff the engine can fix this in-place. Manual fixes go in `detail` text. */
+    readonly repair?: {
+        readonly id: string;
+        readonly label: string;
+    };
+}
+/**
+ * The ports a diagnostic is allowed to depend on. Just the working store today, the
+ * port the editor's content API already binds (DESIGN §11c). Round-trip probes exercise
+ * `write`/`list`/`exists`/`readBytes`/`delete`; content checks just read. Anything beyond
+ * those (a `PurgeService`, a `BlobStore`, …) is added here as a new optional field, never
+ * a host- or adapter-specific surface.
+ */
+interface DiagnoseDeps {
+    readonly store: WorkingStore;
+}
+/**
+ * One probe. `id` is stable and used to namespace the finding ids it emits. `run` returns
+ * the {@link Finding}s it generated (empty array when there's nothing to report).
+ */
+interface Diagnostic {
+    readonly id: string;
+    run(deps: DiagnoseDeps): Promise<readonly Finding[]>;
+}
+/**
+ * One in-place fix. Idempotent: calling `run` twice does not double-write. The host
+ * re-runs the diagnostic set after a repair to refresh the UI, so repairs don't have to
+ * return findings themselves.
+ */
+interface Repair {
+    readonly id: string;
+    run(deps: DiagnoseDeps): Promise<void>;
+}
+
+/**
+ * The diagnostic registry: an in-process collection of {@link Diagnostic}s and
+ * {@link Repair}s the host's `/api/admin/diagnostics` route runs. A buggy diagnostic does
+ * not take down the page — its thrown error is caught and surfaced as a finding with
+ * `id` "<diagnostic-id>.crashed", so the user sees the failure exactly the way they see
+ * every other finding. (CLAUDE.md §2 spirit: failures are data, not exceptions, even when
+ * the failure is the probe itself.)
+ *
+ * Ids are unique per registry; registering a duplicate throws, since that is a
+ * programmer error, not user-visible data.
+ */
+interface DiagnosticRegistry {
+    /** Register a diagnostic. Throws if its id is already in the registry. */
+    add(diagnostic: Diagnostic): void;
+    /** Register a repair. Throws if its id is already in the registry. */
+    addRepair(repair: Repair): void;
+    /** Run every registered diagnostic in order; concatenate their findings. */
+    runAll(deps: DiagnoseDeps): Promise<readonly Finding[]>;
+    /** Run the named repair, then return a fresh `runAll` so the UI re-renders. */
+    runRepair(id: string, deps: DiagnoseDeps): Promise<readonly Finding[]>;
+}
+declare function createDiagnosticRegistry(): DiagnosticRegistry;
+
+declare const workingStoreRoundTripDiagnostic: Diagnostic;
+
+export { type Artifact, type ArtifactSink, type AuthEndpoints, type AuthResult, type AuthorDirectory, type AuthorEntry, type AuthorOption, type AuthorRef, type AuthoringReference, type BlobStore, type BoundItem, type ChangePasswordRequest, type ChangePasswordSuccess, type CollectionConfig, type CollectionQuery, type CompileInput, type CompilePageOptions, type CompileSiteOptions, type CompiledPage, type ComponentMap, type ContentIndex, type ContentItem, ContentParseError, type ContentSource, type CreateTokenSuccess, type CreateUserRequest, DEFAULT_DIRS, DOCUMENT_SHELL, type DerivedField, type DiagnoseDeps, type Severity as DiagnoseSeverity, type Source as DiagnoseSource, type Diagnostic$1 as Diagnostic, type Diagnostic as DiagnosticCheck, type DiagnosticRegistry, type DirEntry, type DirNode, type EncodeRequest, type EncodedImage, type EncodedVariant, type EntryKind, FIELD_TYPES, type FieldPrimitive, type FieldRecord, type FieldType, type FieldTypeDef, type FieldValue, type Finding, type IdentityProvider, type ImageEncoder, type ImageFormat, type ImageInfo, InMemoryArtifactSink, InMemoryBlobStore, InMemoryContentSource, IndexedStore, type ItemNode, type LengthConstraints, type LoginRequest, type LoginSuccess, type MediaResolver, type PageEntry, type PreBuildHook, type Principal, type PublishOptions, type PublishResult, type PublishSummary, type PurgeService, RESERVED_PREFIX, type ReconcileResult, type RedirectRule, type ReferenceContext, type ReferenceEntry, type ReferenceSection, type RefreshSuccess, type RenameResult, type Repair, type ResetPasswordRequest, type ResolveContext, type Role, type RssOptions, type Scope, type Severity$1 as Severity, type SiteConfig, type SortFile, type TemplateAnalysis, type TokenContext, type TokenRef, type TreeNode, type UpdateUserRequest, type UserAdminEndpoints, type UserSummary, type ValidationResult, type ValueKind, type WorkingStore, analyzeTemplate, buildAuthoringReference, buildContentIndex, buildPictureMarkup, buildRedirects, buildResolveContext, buildRss, buildSitemap, canEdit, compilePage, compileSite, compileTemplate, contentHash, contentTypeFor, createDiagnosticRegistry, deriveFields, emptyIndex, escapeHtmlAttribute, escapeHtmlText, escapeJsonStringContent, findTokens, hasRole, humanize, inferControl, isFieldType, joinAuthors, loadComponentScripts, loadComponentStyles, loadComponents, loadContentTree, loadDocumentShell, loadIndex, loadRedirects, loadSiteConfig, loadTemplate, noopPurgeService, outputPathForItem, parseContentItem, parseRedirects, parseSortFile, processImage, publishSite, reconcileIndex, renderAuthors, renderReferenceMarkdown, sanitizeUrl, saveIndex, slugify, textContent, toAuthorRefs, urlForItem, validateSite, valueKindOf, wholeValueToken, workingStoreRoundTripDiagnostic };

package/dist/index.js

@@ -22,6 +22,7 @@ import {
   compileTemplate,
   contentHash,
   contentTypeFor,
+  createDiagnosticRegistry,
   deriveFields,
   emptyIndex,
   escapeHtmlAttribute,
@@ -60,8 +61,9 @@ import {
   urlForItem,
   validateSite,
   valueKindOf,
-  wholeValueToken
-} from "./chunk-Y7PUOM5I.js";
+  wholeValueToken,
+  workingStoreRoundTripDiagnostic
+} from "./chunk-J6VYOB47.js";
 export {
   ContentParseError,
   DEFAULT_DIRS,
@@ -86,6 +88,7 @@ export {
   compileTemplate,
   contentHash,
   contentTypeFor,
+  createDiagnosticRegistry,
   deriveFields,
   emptyIndex,
   escapeHtmlAttribute,
@@ -124,5 +127,6 @@ export {
   urlForItem,
   validateSite,
   valueKindOf,
-  wholeValueToken
+  wholeValueToken,
+  workingStoreRoundTripDiagnostic
 };