fimo 2.6.0 → 2.7.0-experimental.1

package/assets/skills/fimo-migration/scripts/check-rendered-guardrails.mjs

@@ -0,0 +1,500 @@
+#!/usr/bin/env node
+// @ts-check
+// Evaluates the migration guardrail inventory against the final rendered
+// application. Inputs are rendered HTML observations (browser/HTTP captures or
+// a running local server), never the target's source files: once copy moves
+// into Fimo, a source grep proves nothing about what visitors see.
+//
+// The check fails closed. An empty inventory, a route with no rendered text,
+// or a rule that ends up evaluated against zero observations is a failure, not
+// a pass.
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+/**
+ * Shipped as plain JavaScript so a migration target needs only Node.
+ * Checked with its subprocess tests by tsconfig.guardrails.json.
+ * @typedef {{projectRoot?: string, inventory?: string, captures?: string, baseUrl?: string, output?: string}} Args
+ * @typedef {{id: string, kind: string, source?: string, text?: string | string[], href?: string, routes?: string[], allow?: string[]}} Rule
+ * @typedef {{routes: string[], rules: Rule[]}} Inventory
+ * @typedef {{route: string, source: string, url: string, baseUrl: string, html: string | null, text: string, links: string[], passed: boolean, reason: string}} Observation
+ * @typedef {{id: string, kind: string, passed: boolean, observed: number, failures: string[], extra: string | null}} Result
+ */
+
+const USAGE =
+  'Usage: node check-rendered-guardrails.mjs [project-root] [--inventory .fimo/migration/guardrails.json] ' +
+  '(--captures <dir> | --base-url <http://localhost:port>) [--output .fimo/migration/guardrails-report.md]';
+
+const RULE_KINDS = ['required-text', 'forbidden-text', 'required-link', 'links-resolve'];
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const projectRoot = path.resolve(args.projectRoot ?? process.cwd());
+  const inventoryPath = path.resolve(projectRoot, args.inventory ?? '.fimo/migration/guardrails.json');
+  const inventory = loadInventory(inventoryPath);
+
+  if (!args.captures && !args.baseUrl) fail(`Provide --captures <dir> or --base-url <url>.\n${USAGE}`);
+  if (args.captures && args.baseUrl) fail('Provide either --captures or --base-url, not both.');
+
+  const observations = args.baseUrl
+    ? await fetchObservations(inventory.routes, args.baseUrl)
+    : readCaptures(inventory.routes, path.resolve(projectRoot, args.captures ?? ''));
+  const results = evaluateRules(inventory, observations);
+  const passed = observations.every((item) => item.passed) && results.every((item) => item.passed);
+
+  const report = buildReport({
+    inventoryPath: toPosix(path.relative(projectRoot, inventoryPath)),
+    inventory,
+    source: args.baseUrl
+      ? `fetched from ${args.baseUrl}`
+      : `captures in ${toPosix(path.relative(projectRoot, path.resolve(projectRoot, args.captures ?? '')))}`,
+    observations,
+    results,
+    passed,
+  });
+
+  if (args.output) {
+    const outputPath = path.resolve(projectRoot, args.output);
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, report, 'utf8');
+  }
+  console.log(report);
+  if (!passed) process.exitCode = 1;
+}
+
+/** @param {string[]} argv */
+function parseArgs(argv) {
+  /** @type {Args} */
+  const args = {};
+  /** @type {Record<string, keyof Args>} */
+  const valueFlags = {
+    '--inventory': 'inventory',
+    '--captures': 'captures',
+    '--base-url': 'baseUrl',
+    '--output': 'output',
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h') {
+      console.log(USAGE);
+      process.exit(0);
+    }
+    const [flag, inlineValue] = arg.includes('=')
+      ? [arg.slice(0, arg.indexOf('=')), arg.slice(arg.indexOf('=') + 1)]
+      : [arg, undefined];
+    if (valueFlags[flag]) {
+      const value = inlineValue ?? argv[++i];
+      if (!value || value.startsWith('--')) fail(`Missing value for ${flag}.\n${USAGE}`);
+      args[valueFlags[flag]] = value;
+      continue;
+    }
+    if (!arg.startsWith('--') && !args.projectRoot) {
+      args.projectRoot = arg;
+      continue;
+    }
+    fail(`Unknown argument: ${arg}\n${USAGE}`);
+  }
+  return args;
+}
+
+// The inventory is the explicit acceptance contract. It must name the route
+// surface and at least one rule; the script never infers either from the
+// target, so a migration cannot pass by declaring nothing.
+/** @param {string} inventoryPath @returns {Inventory} */
+function loadInventory(inventoryPath) {
+  if (!fs.existsSync(inventoryPath)) fail(`Guardrail inventory not found: ${inventoryPath}`);
+  /** @type {unknown} */
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(inventoryPath, 'utf8'));
+  } catch (error) {
+    fail(`Could not parse ${inventoryPath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isRecord(raw) || !Array.isArray(raw.routes) || !Array.isArray(raw.rules)) {
+    fail('Invalid guardrail inventory: expected an object with routes and rules arrays.');
+  }
+  if (!raw.routes.every(isNonEmptyString)) fail('Invalid guardrail inventory: routes must be non-empty strings.');
+  // Keep trailing slashes for document-relative URL resolution during fetches.
+  const routes = uniqueArray(
+    raw.routes.map(
+      (route) => normalizePath(route) + (route.trim().endsWith('/') && normalizePath(route) !== '/' ? '/' : '')
+    )
+  );
+  const rules = raw.rules;
+  if (routes.length === 0)
+    fail(
+      `Empty guardrail inventory: ${inventoryPath} lists no routes. Inventory every rendered route the migration must prove.`
+    );
+  if (rules.length === 0)
+    fail(
+      `Empty guardrail inventory: ${inventoryPath} lists no rules. Add the brand, legal/compliance, and navigation rules the source imposes.`
+    );
+  rules.forEach((rule, index) => {
+    if (!isRecord(rule)) fail(`Rule #${index + 1} must be an object.`);
+    if (!isNonEmptyString(rule.id)) fail(`Rule #${index + 1} has no id.`);
+    if (typeof rule.kind !== 'string' || !RULE_KINDS.includes(rule.kind))
+      fail(`Rule ${rule.id} has unknown kind "${rule.kind}". Use one of: ${RULE_KINDS.join(', ')}.`);
+    if (
+      ['required-text', 'forbidden-text'].includes(String(rule.kind)) &&
+      (asArray(rule.text).length === 0 || !asArray(rule.text).every(isNonEmptyString))
+    ) {
+      fail(`Rule ${rule.id} (${rule.kind}) needs a non-empty "text".`);
+    }
+    if (rule.kind === 'required-link' && !isNonEmptyString(rule.href))
+      fail(`Rule ${rule.id} (required-link) needs an "href".`);
+    if (rule.kind === 'required-link' && /^(?!https?:)[a-z][a-z0-9+.-]*:/i.test(String(rule.href))) {
+      fail(`Rule ${rule.id} (required-link) supports paths and http(s) URLs; prove ${rule.href} in the browser pass.`);
+    }
+    for (const field of ['routes', 'allow']) {
+      if (rule[field] !== undefined && (!Array.isArray(rule[field]) || !rule[field].every(isNonEmptyString))) {
+        fail(`Rule ${rule.id} (${field}) needs an array of non-empty strings.`);
+      }
+    }
+    if (!isNonEmptyString(rule.source))
+      fail(`Rule ${rule.id} needs "source": cite the original page, file, or owner decision that imposes it.`);
+    const unknownScope = asArray(rule.routes)
+      .filter(isNonEmptyString)
+      .map(normalizePath)
+      .filter((route) => !routes.some((item) => normalizePath(item) === route));
+    if (unknownScope.length > 0) {
+      fail(
+        `Rule ${rule.id} is scoped to routes missing from the inventory: ${unknownScope.join(', ')}. A rule cannot be proven on a route that is never rendered.`
+      );
+    }
+  });
+  return { routes, rules: /** @type {Rule[]} */ (rules) };
+}
+
+/** @param {string[]} routes @param {string} capturesDir */
+function readCaptures(routes, capturesDir) {
+  return routes.map((route) => {
+    const name = captureFileName(route);
+    const file = path.join(capturesDir, name);
+    if (!fs.existsSync(file)) return observation(route, `capture missing: ${name}`, null);
+    // Status must come from the navigation response, never from HTML content.
+    try {
+      /** @type {unknown} */
+      const metadata = JSON.parse(fs.readFileSync(`${file}.json`, 'utf8'));
+      if (!isRecord(metadata) || metadata.status !== 200 || metadata.error != null) {
+        return observation(route, `capture rejected: ${name}.json must record status 200 and no error`, null);
+      }
+      if (!isNonEmptyString(metadata.url) || !/^https?:\/\//i.test(metadata.url)) {
+        return observation(route, `capture rejected: ${name}.json needs the final HTTP(S) document URL`, null);
+      }
+      const finalUrl = new URL(metadata.url).href;
+      const finalPath = normalizePath(new URL(finalUrl).pathname);
+      if (finalPath !== normalizePath(route)) {
+        return observation(
+          route,
+          `capture rejected: ${name}.json records ${finalPath}, not ${normalizePath(route)}`,
+          null
+        );
+      }
+      return observation(route, `capture ${name}`, fs.readFileSync(file, 'utf8'), finalUrl);
+    } catch (error) {
+      return observation(
+        route,
+        `capture evidence unreadable: ${name}.json: ${error instanceof Error ? error.message : String(error)}`,
+        null
+      );
+    }
+  });
+}
+
+// `/` -> index.html, `/legal/privacy` -> legal/privacy.html. The validator saves
+// the hydrated document under these names when it captures with a browser.
+/** @param {string} route */
+function captureFileName(route) {
+  route = normalizePath(route);
+  return route === '/' ? 'index.html' : `${route.replace(/^\//, '')}.html`;
+}
+
+/** @param {string[]} routes @param {string} baseUrl */
+async function fetchObservations(routes, baseUrl) {
+  const base = baseUrl.replace(/\/$/, '');
+  return Promise.all(
+    routes.map(async (route) => {
+      try {
+        const response = await fetch(`${base}${route}`, { redirect: 'follow' });
+        const body = await response.text();
+        if (response.status !== 200) {
+          return observation(route, `HTTP ${response.status} from ${base}${route}`, null);
+        }
+        const finalPath = normalizePath(new URL(response.url).pathname);
+        if (finalPath !== normalizePath(route)) {
+          return observation(
+            route,
+            `redirected to ${finalPath}: the route surface is not preserved`,
+            null,
+            response.url
+          );
+        }
+        return observation(route, `HTTP 200 from ${base}${route}`, body, response.url);
+      } catch (error) {
+        return observation(route, `request failed: ${error instanceof Error ? error.message : String(error)}`, null);
+      }
+    })
+  );
+}
+
+/** @param {string} route @param {string} source @param {string | null} html @param {string} [url] @returns {Observation} */
+function observation(route, source, html, url = '') {
+  const context = { route, source, url, baseUrl: url };
+  if (html === null) {
+    return { ...context, html: null, text: '', links: [], passed: false, reason: source };
+  }
+  const text = visibleText(html);
+  const links = extractLinks(html);
+  const baseHref = html
+    .replace(/<!--[^]*?-->/g, '')
+    .replace(/<(script|style|template)\b[^>]*>[^]*?<\/\1\s*>/gi, ' ')
+    .match(/<base\b[^>]*\s+href\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/i);
+  if (baseHref) context.baseUrl = new URL(decodeEntities(baseHref[1] ?? baseHref[2] ?? baseHref[3]), url).href;
+  if (text.length === 0) {
+    return {
+      ...context,
+      html,
+      text,
+      links,
+      passed: false,
+      reason:
+        'rendered HTML has no visible text (an empty client-rendered root is not a page; capture after hydration)',
+    };
+  }
+  return {
+    ...context,
+    html,
+    text,
+    links,
+    passed: true,
+    reason: `${text.length} visible characters, ${links.length} links`,
+  };
+}
+
+// Visible text is body text plus the attributes a visitor or crawler reads:
+// alt, title, aria-label, placeholder, and meta content. Scripts, styles, and
+// comments are excluded on purpose: a brand string inside a bundle or JSON
+// payload is source presence, not a rendered observation.
+/** @param {string} html */
+function visibleText(html) {
+  const stripped = html
+    .replace(/<(script|style|noscript|template)\b[^>]*>[\s\S]*?<\/\1\s*>/gi, ' ')
+    .replace(/<!--[\s\S]*?-->/g, ' ');
+  const attributeText = [
+    ...stripped.matchAll(/\b(?:alt|title|aria-label|placeholder|content)\s*=\s*(?:"([^"]*)"|'([^']*)')/gi),
+  ].map((match) => match[1] ?? match[2] ?? '');
+  const bodyText = stripped.replace(/<[^>]+>/g, ' ');
+  return decodeEntities([bodyText, ...attributeText].join(' '))
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+/** @param {string} html */
+function extractLinks(html) {
+  const withoutHidden = html
+    .replace(/<(script|style|noscript|template)\b[^>]*>[\s\S]*?<\/\1\s*>/gi, ' ')
+    .replace(/<!--[\s\S]*?-->/g, ' ');
+  return [...withoutHidden.matchAll(/<a\b[^>]*\s+href\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/gi)].map((match) =>
+    decodeEntities(match[1] ?? match[2] ?? match[3] ?? '').trim()
+  );
+}
+
+/** @param {Inventory} inventory @param {Observation[]} observations */
+function evaluateRules(inventory, observations) {
+  const rendered = observations.filter((item) => item.passed);
+  return inventory.rules.map((rule) => {
+    const scope = rule.routes?.length ? rule.routes.map(normalizePath) : inventory.routes.map(normalizePath);
+    const observed = rendered.filter((item) => scope.includes(normalizePath(item.route)));
+    if (observed.length === 0) {
+      return result(rule, false, 0, [`vacuous: evaluated against 0 rendered routes (scope: ${scope.join(', ')})`]);
+    }
+    switch (rule.kind) {
+      case 'required-text':
+        return textRule(rule, observed, (haystack, phrase) => !haystack.includes(phrase), 'missing');
+      case 'forbidden-text':
+        return textRule(rule, observed, (haystack, phrase) => haystack.includes(phrase), 'found');
+      case 'required-link':
+        return linkRule(rule, observed);
+      case 'links-resolve':
+        return linksResolveRule(rule, inventory, observed);
+      default:
+        return result(rule, false, observed.length, [`unknown rule kind ${rule.kind}`]);
+    }
+  });
+}
+
+/** @param {Rule} rule @param {Observation[]} observed @param {(haystack: string, phrase: string) => boolean} isFailure @param {string} verb */
+function textRule(rule, observed, isFailure, verb) {
+  const failures = [];
+  for (const item of observed) {
+    const haystack = item.text.toLowerCase();
+    for (const phrase of phrases(rule)) {
+      const needle = phrase.toLowerCase();
+      if (isFailure(haystack, needle)) {
+        failures.push(
+          `"${phrase}" ${verb} on ${item.route}${verb === 'found' ? `: ${snippet(item.text, phrase)}` : ''}`
+        );
+      }
+    }
+  }
+  return result(rule, failures.length === 0, observed.length, failures);
+}
+
+/** @param {Rule} rule @param {Observation[]} observed */
+function linkRule(rule, observed) {
+  const failures = observed
+    .filter((item) => {
+      const target = linkTarget(rule.href ?? '', item, false);
+      return !target || !item.links.some((href) => linkTarget(href, item, false) === target);
+    })
+    .map((item) => `no <a href="${rule.href}"> rendered on ${item.route} (${item.links.length} links collected)`);
+  return result(rule, failures.length === 0, observed.length, failures);
+}
+
+// Every internal link rendered on the observed routes must point at a route
+// the inventory proves, or at an explicitly allowed path prefix. Collecting
+// zero links is a failure: a navigation check over nothing checks nothing.
+/** @param {Rule} rule @param {Inventory} inventory @param {Observation[]} observed */
+function linksResolveRule(rule, inventory, observed) {
+  const allow = asArray(rule.allow).filter(isNonEmptyString).map(normalizePath);
+  const internal = [];
+  for (const item of observed) {
+    for (const href of item.links) {
+      const target = linkTarget(href, item);
+      if (target !== null) internal.push({ route: item.route, href, target });
+    }
+  }
+  if (internal.length === 0) {
+    return result(rule, false, observed.length, [
+      `vacuous: 0 internal links collected across ${observed.length} rendered routes`,
+    ]);
+  }
+  const failures = uniqueArray(
+    internal
+      .filter(
+        ({ target }) =>
+          !inventory.routes.some((route) => normalizePath(route) === target) &&
+          !allow.some((prefix) => target === prefix || target.startsWith(`${prefix}/`))
+      )
+      .map(({ route, href }) => `${href} on ${route} resolves to no inventoried route`)
+  );
+  return result(rule, failures.length === 0, observed.length, failures, `${internal.length} internal links`);
+}
+
+/** @param {Rule} rule @param {boolean} passed @param {number} observed @param {string[]} failures @param {string} [extra] @returns {Result} */
+function result(rule, passed, observed, failures, extra) {
+  return { id: rule.id, kind: rule.kind, passed, observed, failures, extra: extra ?? null };
+}
+
+/** @param {{inventoryPath: string, inventory: Inventory, source: string, observations: Observation[], results: Result[], passed: boolean}} report */
+function buildReport({ inventoryPath, inventory, source, observations, results, passed }) {
+  const lines = [
+    '## Guardrails',
+    '',
+    `- Inventory: ${inventoryPath} (${inventory.routes.length} routes, ${inventory.rules.length} rules)`,
+    `- Observations: ${source}`,
+    '',
+    '### Rendered routes',
+    '',
+    ...observations.map((item) => `- ${box(item.passed)} ${item.route}: ${item.reason}`),
+    '',
+    '### Rules',
+    '',
+    ...results.flatMap((item) => [
+      `- ${box(item.passed)} ${item.id} (${item.kind}) observed on ${item.observed} routes${item.extra ? `, ${item.extra}` : ''}`,
+      ...item.failures.map((failure) => `  - ${failure}`),
+    ]),
+    '',
+    `Result: ${passed ? 'passed' : 'failed'}`,
+    '',
+  ];
+  return lines.join('\n');
+}
+
+/** @param {Rule} rule */
+function phrases(rule) {
+  return asArray(rule.text ?? []).filter(isNonEmptyString);
+}
+
+/** @param {string} text @param {string} phrase */
+function snippet(text, phrase) {
+  const index = text.toLowerCase().indexOf(phrase.toLowerCase());
+  const start = Math.max(0, index - 40);
+  const end = Math.min(text.length, index + phrase.length + 40);
+  return `"${start > 0 ? '…' : ''}${text.slice(start, end)}${end < text.length ? '…' : ''}"`;
+}
+
+// Queries and fragments address the same route. Absolute and protocol-relative
+// URLs are internal only when their origin matches the observed document.
+/** @param {string} href @param {Observation} item @param {boolean} [internalOnly] @returns {string | null} */
+function linkTarget(href, item, internalOnly = true) {
+  try {
+    const url = new URL(href, item.baseUrl);
+    if (!['http:', 'https:'].includes(url.protocol)) return null;
+    if (url.origin !== new URL(item.url).origin)
+      return internalOnly ? null : `${url.origin}${normalizePath(url.pathname)}`;
+    return normalizePath(url.pathname);
+  } catch {
+    return ''; // Invalid URLs cannot match an inventoried route.
+  }
+}
+
+/** @param {string} value */
+function normalizePath(value) {
+  const trimmed = value.trim();
+  if (trimmed === '' || trimmed === '/') return '/';
+  return `/${trimmed.replace(/^\/+/, '').replace(/\/+$/, '')}`;
+}
+
+/** @param {string} value */
+function decodeEntities(value) {
+  return value
+    .replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code)))
+    .replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCodePoint(Number.parseInt(code, 16)))
+    .replace(
+      /&(amp|lt|gt|quot|apos|nbsp);/g,
+      (_, name) =>
+        /** @type {Record<string, string>} */ ({ amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ' })[name]
+    );
+}
+
+/** @param {boolean} passed */
+function box(passed) {
+  return passed ? '[x]' : '[ ]';
+}
+
+/** @template T @param {T | T[]} value @returns {T[]} */
+function asArray(value) {
+  if (Array.isArray(value)) return value;
+  if (value === undefined || value === null) return [];
+  return [value];
+}
+
+/** @template T @param {T[]} items */
+function uniqueArray(items) {
+  return [...new Set(items)];
+}
+
+/** @param {unknown} value @returns {value is string} */
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+/** @param {unknown} value @returns {value is Record<string, unknown>} */
+function isRecord(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/** @param {string} value */
+function toPosix(value) {
+  return value.split(path.sep).join('/');
+}
+
+/** @param {string} message @returns {never} */
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+await main();

package/assets/skills/fimo-studio/SKILL.md

@@ -33,6 +33,7 @@ Read the relevant reference file when the user's question matches a topic.
 | ------------------------ | --------------------------------------- | ----------------------------------------------------- |
 | Command Palette          | references/command-palette.md           | "What can I open with Cmd+K?", "Quick actions"        |
 | Publish & Deploy         | references/publish-and-deploy.md        | "How do I publish?", "How do I make my site live?"    |
+| Analytics                | references/analytics.md                 | "Is tracking working?", "Why are analytics empty?"    |
 | Custom Domains           | references/custom-domains.md            | "How do I use my own domain?", "DNS setup"            |
 | Content Management (CMS) | references/cms.md                       | "How does the CMS work?", "How do I add blog posts?"  |
 | Media Library            | references/media-library.md             | "How do I upload images?", "Where are my files?"      |

package/assets/skills/fimo-studio/references/analytics.md

@@ -0,0 +1,28 @@
+# Analytics
+
+Open **Analytics** in the project's workspace navigation. It may be inside
+**More** at narrower desktop widths. This workspace reports the published site,
+regardless of the editing branch currently selected.
+
+Publishing alone does not confirm pageview tracking. Before publication, the
+page offers setup guidance without an **Open site** link.
+
+For a published site:
+
+- **Waiting for the first pageview** means no pageviews are stored for it.
+  **Open site** lets the user visit the published address. **Set up tracking**
+  opens the installation guide. A visit must run a configured tracker to count.
+- **Pageviews received** shows the last pageview timestamp across available
+  history. Changing the chart's date range or device filter does not reset it.
+  Earlier traffic proves tracking worked then, not that a later deployment
+  still sends events.
+- **Tracking status unavailable** means the status could not be checked.
+  **Check again** retries it. Do not interpret this as an uninstalled tracker.
+  Charts that loaded successfully remain visible.
+
+Studio checks every 15 seconds while waiting in a visible tab. The first
+pageview refreshes the charts automatically. Processing may take longer than
+one check. Do not diagnose a missing tracker from zero chart counts alone.
+
+Users need analytics viewing permission. Date ranges and grouping apply to the
+charts; available history depends on the organization's analytics access.

package/assets/skills/fimo-studio/references/publish-and-deploy.md

@@ -31,6 +31,7 @@ The header **Publish** button itself only shows the label "Publish" (or a spinne
 - **"Publishing"** — Publishing is in progress. A spinner and a **Publishing** status badge show while it builds, and the button is disabled.
 - **"Published"** — Your site is live. A **Published** status badge appears, your live URL is listed under a **Published site** heading as a clickable link, and a **Last published** date and time is shown.
 - **"Couldn't publish · N issues"** — Project validation found issues that must be fixed first. Choose **Fix with Fimo** to send the safe issue list to the project chat and ask Fimo to repair it.
+- **"Latest update failed"** — The newest publication did not finish. The panel says what went wrong and, for a site that was published before, that the previous version remains the active release — so it can appear beside **Published**. It stays until a newer publication finishes. **View details** opens the reader's Inbox item about the failure, which offers **Open publishing** and **Contact support**. Studio never shows the build output; read it with `fimo publish logs <id>`, taking the id from `fimo publish list`. The person who published and the project's managers get that Inbox item, plus an email unless they turned off **Publication failures** in Account settings → Notifications.
 
 ## Key Concepts
 

package/dist/cli/bundle.json

@@ -1,7 +1,7 @@
 {
   "bundled": true,
   "bundler": "esbuild",
-  "bundledAt": "2026-09-09T18:25:01.506Z",
+  "bundledAt": "2026-09-29T12:38:55.114Z",
   "cliVersion": "2.6.0",
   "external": [
     "oxc-parser",