@tokenoftrust/storefront-runner 2.4.27 → 2.4.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokenoftrust/storefront-runner",
-  "version": "2.4.27",
+  "version": "2.4.28",
   "license": "SEE LICENSE IN LICENSE",
   "description": "World-shareable storefront runner: multi-tenant renderer on Astro/Cloudflare. No control plane.",
   "packageManager": "pnpm@11.9.0",

package/packages/cli/src/publication-spaces.mjs

@@ -24,6 +24,18 @@ export const SPACES_DIR = "spaces";
 export const TOPOLOGY_FILE = ".tot/publication-spaces.json";
 export const TOPOLOGY_VERSION = 1;
 
+/**
+ * Platform-owned paths no space serves (packages/public-runtime PUBLICATION_SPACE_RESERVED_MOUNTS;
+ * the ownership parity test holds the two equal).
+ */
+export const PLATFORM_PATHS = Object.freeze([
+  "/.well-known", "/__evidence", "/__preview", "/_a", "/_astro", "/_style-guide", "/admin", "/api",
+  "/apps", "/assets", "/auth", "/brand", "/capabilities", "/cockpit", "/dashboard", "/dev",
+  "/favicon.svg", "/health", "/js", "/feed.json", "/llms.txt", "/publication-discovery",
+  "/search-index.json", "/sitemap.xml", "/platform", "/preview", "/products", "/collections",
+  "/search", "/saved", "/robots.txt", "/shared", "/style-guide", "/tenants",
+]);
+
 const SPACE_ID = /^[a-z0-9](?:[a-z0-9._-]{0,126}[a-z0-9])?$/;
 const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
 
@@ -145,15 +157,17 @@ export function mountedSpaces(topology) {
 }
 
 /**
- * Which space owns a URL path: the longest canonical mount (or alias) that owns it, else the root.
- * Returns null for a path that cannot be read as a URL path.
+ * Which space owns a URL path: none for a platform path (`/api`, `/admin`, ...), else the longest
+ * canonical mount (or alias) that owns it, else the root. Null for a path that cannot be read as one.
  * @param {Topology} topology
  * @param {string} urlPath
- * @returns {{ space: TopologySpace, via: "mount"|"alias"|"root" } | null}
+ * @returns {{ space: TopologySpace, via: "mount"|"alias"|"root" } | { space: null, via: "platform" } | null}
  */
 export function owningSpace(topology, urlPath) {
   const path = normalizeRequestPath(urlPath);
   if (path === null) return null;
+  const folded = path.toLowerCase();
+  if (PLATFORM_PATHS.some((reserved) => mountMatchesPath(reserved, folded))) return { space: null, via: "platform" };
   /** @type {{ space: TopologySpace, via: "mount"|"alias", mount: string } | null} */
   let best = null;
   for (const space of topology.spaces) {
@@ -221,3 +235,73 @@ export function excludeFromRootRepo(workspace, patterns) {
   if (!missing.length) return;
   appendFileSync(file, `${current && !current.endsWith("\n") ? "\n" : ""}${missing.join("\n")}\n`);
 }
+
+/** The post collections a space can carry; each is served under its base path (default: its name). */
+export const COLLECTIONS = ["blog", "the-build"];
+
+/**
+ * The URL path a ROOT checkout file renders at, for the files whose URL the layout fixes:
+ * `content/pages-html/<slug>.html` and `content/pages/<slug>.json` at `/<slug>`, a collection's
+ * files under its base path. Null for files with no URL of their own (theme, chrome, assets).
+ * @param {TopologySpace} root
+ * @param {string} relPath  path relative to the root checkout
+ */
+export function rootFileUrlPath(root, relPath) {
+  const rel = String(relPath).replace(/\\/g, "/");
+  let m = /^content\/pages-html\/(.+)\.html$/.exec(rel) ?? /^content\/pages\/(.+)\.json$/.exec(rel);
+  if (m) return `/${m[1]}`;
+  m = /^content\/([^/]+)\//.exec(rel);
+  if (m && COLLECTIONS.includes(m[1])) {
+    const base = root.collections?.[m[1]] ?? m[1];
+    return base ? `/${base.replace(/^\/+|\/+$/g, "")}` : null;
+  }
+  return null;
+}
+
+/**
+ * Root files whose URL a mounted space owns. Visitors get the space's page at that URL, never the
+ * root's, so the file is dead weight in the root and a change to it ships nowhere.
+ * @param {Topology} topology
+ * @param {string[]} rootFiles  paths relative to the root checkout
+ * @returns {Array<{ level: "warn", rule: string, file: string, message: string, fix: string }>}
+ */
+export function rootFilesOwnedByMounts(topology, rootFiles) {
+  const root = rootSpace(topology);
+  const findings = [];
+  for (const file of rootFiles) {
+    const urlPath = rootFileUrlPath(root, file);
+    if (!urlPath) continue;
+    const owner = owningSpace(topology, urlPath);
+    if (!owner || !owner.space || owner.space.mount === "/") continue;
+    findings.push({
+      level: /** @type {"warn"} */ ("warn"),
+      rule: "publication-space-owns-url",
+      file,
+      message: `${urlPath} is served by the mounted space "${owner.space.id}" (${owner.space.source.forge}:${owner.space.source.repo}, mount ${owner.space.mount}), so this root file never reaches a visitor.`,
+      fix: `move it into ${spaceDir(owner.space)}/ (the "${owner.space.id}" repository), or delete it from the root`,
+    });
+  }
+  return findings;
+}
+
+/**
+ * Who owns a URL path. `spaceId` is null for a platform path, which no repository serves.
+ * @param {Topology} topology @param {string} urlPath
+ * @returns {{ path: string, spaceId: string|null, mount: string|null, via: string, repo: string|null, dir: string|null } | null}
+ */
+export function describeOwner(topology, urlPath) {
+  const owner = owningSpace(topology, urlPath);
+  if (!owner) return null;
+  const { space, via } = owner;
+  if (!space) {
+    return { path: /** @type {string} */ (normalizeRequestPath(urlPath)), spaceId: null, mount: null, via, repo: null, dir: null };
+  }
+  return {
+    path: /** @type {string} */ (normalizeRequestPath(urlPath)),
+    spaceId: space.id,
+    mount: space.mount,
+    via,
+    repo: `${space.source.forge}:${space.source.repo}`,
+    dir: spaceDir(space) || ".",
+  };
+}