@tokenoftrust/storefront-runner 2.4.27 → 2.4.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokenoftrust/storefront-runner",
-  "version": "2.4.27",
+  "version": "2.4.29",
   "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,145 @@ 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) || ".",
+  };
+}
+
+/**
+ * Route changed workspace files to the repository that ships them. Paths are relative to the
+ * root checkout (a space's files as `spaces/<id>/...`). Each file lands in its owning space's
+ * group; a root file whose URL a mounted space owns is ALSO named as misrouted (it ships with the
+ * root and still never reaches a visitor); a file under `spaces/` naming no declared space is
+ * unowned. Pure.
+ * @param {Topology} topology
+ * @param {string[]} files
+ * @returns {{ groups: Array<{ space: TopologySpace, files: string[] }>,
+ *   misrouted: Array<{ file: string, owner: TopologySpace }>, unowned: string[] }}
+ */
+export function routeWorkspaceChanges(topology, files) {
+  const root = rootSpace(topology);
+  /** @type {Map<string, string[]>} */
+  const byId = new Map(topology.spaces.map((space) => [space.id, []]));
+  const misrouted = [];
+  const unowned = [];
+  for (const file of files) {
+    const owner = spaceForWorkspaceFile(topology, file);
+    if (!owner) { unowned.push(file); continue; }
+    /** @type {string[]} */ (byId.get(owner.space.id)).push(file);
+    if (owner.space.mount === "/") {
+      const urlPath = rootFileUrlPath(root, file);
+      const served = urlPath ? owningSpace(topology, urlPath) : null;
+      if (served?.space && served.space.mount !== "/") misrouted.push({ file, owner: served.space });
+    }
+  }
+  return {
+    groups: topology.spaces.map((space) => ({ space, files: /** @type {string[]} */ (byId.get(space.id)) })),
+    misrouted,
+    unowned,
+  };
+}
+
+/**
+ * Parse `git status --porcelain=v1 -z` into changed paths (a rename yields its new path). Pure.
+ * @param {string} out
+ * @returns {string[]}
+ */
+export function parsePorcelainZ(out) {
+  const parts = String(out).split("\0");
+  const paths = [];
+  for (let i = 0; i < parts.length; i++) {
+    const entry = parts[i];
+    if (!entry || entry.length < 4) continue;
+    const status = entry.slice(0, 2);
+    paths.push(entry.slice(3));
+    if (status[0] === "R" || status[0] === "C") i++; // the next field is the rename's source
+  }
+  return paths;
+}
+
+/**
+ * Every changed file in a workspace, relative to the root checkout: the root repository's own
+ * changes plus each cloned space's (`spaces/<id>/...`). `git(dir, args)` runs git in `dir`.
+ * @param {string} workspace
+ * @param {Topology} topology
+ * @param {(dir: string, args: string[]) => string} git
+ * @returns {string[]}
+ */
+export function workspaceChangedFiles(workspace, topology, git) {
+  const files = parsePorcelainZ(git(workspace, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]));
+  for (const space of mountedSpaces(topology)) {
+    const dir = join(workspace, spaceDir(space));
+    if (!existsSync(join(dir, ".git"))) continue;
+    for (const file of parsePorcelainZ(git(dir, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]))) {
+      files.push(`${spaceDir(space)}/${file}`);
+    }
+  }
+  return files;
+}