@saastro/studio 0.7.1 → 0.9.0

package/dist/richtext/index.d.ts

@@ -0,0 +1,142 @@
+// Inlined from @saastro/studio-core (private) at build time — see scripts/inline-doctor-dts.mjs
+import { z } from 'zod';
+
+/**
+ * Rich spans — the structured inline-emphasis value for i18n leaves.
+ *
+ * An i18n leaf can be either a plain string or an array of spans:
+ *
+ *   [{ text: 'Crece tu ' }, { text: 'negocio', marks: ['accent'] }]
+ *
+ * Marks come from a CLOSED whitelist (grow it only on real content demand —
+ * every new mark costs an editor widget, a doctor case and a renderer case).
+ * Marks map to presentation in the component renderer (`RichText.astro` in
+ * @saastro/studio: accent → the theme's semantic `ac` class, bold →
+ * <strong>); markup NEVER travels inside the content itself.
+ *
+ * Sanity/Vercel-style invariants the rest of the pipeline relies on:
+ *  - The stega encoder registers ONLY the concatenated span text as a
+ *    matchable value — never the `marks` literals (`'accent'`/`'bold'` are
+ *    short enough to substring-match arbitrary page text).
+ *  - Live-preview patches build DOM programmatically from this whitelist —
+ *    never innerHTML.
+ *  - A key holding spans in one locale must hold spans in every locale
+ *    (atomic migration; enforced by the spans doctor check).
+ */
+
+/**
+ * Simple (parameterless) marks. Owner decisions 2026-07-06: accent + bold
+ * first; italic + tokenized color/size/font added the same day (marks v2).
+ */
+declare const SPAN_MARKS: readonly ["accent", "bold", "italic"];
+type SimpleSpanMark = (typeof SPAN_MARKS)[number];
+/**
+ * Tokenized marks (marks v2) — the value part is always a SEMANTIC name,
+ * never a raw CSS value:
+ *
+ *   c:<token>   color — the site's own CSS custom property name (without
+ *               the leading --), e.g. `c:accent-300`, `c:brand-jcenlo`.
+ *               Renders as `color: var(--<token>)`, so it resolves against
+ *               whatever the site's palette declares.
+ *   s:sm|lg|xl  font size — closed 3-step scale relative to the element
+ *               (0.85em / 1.15em / 1.35em). No arbitrary sizes.
+ *   f:display|body|code  font family — the site's semantic font slots
+ *               (`var(--font-display)` / `var(--font-body)` / `var(--code)`).
+ *               Arbitrary families stay theme-editor territory.
+ */
+declare const COLOR_MARK_RE: RegExp;
+declare const SIZE_MARK_RE: RegExp;
+declare const FONT_MARK_RE: RegExp;
+type SpanMark = string;
+declare function isValidMark(mark: unknown): mark is SpanMark;
+declare const spanMarkSchema: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+declare const richSpanSchema: z.ZodObject<{
+    text: z.ZodString;
+    marks: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>>;
+}, z.core.$strip>;
+type RichSpan = z.infer<typeof richSpanSchema>;
+/** A spans value is a non-empty array of spans. */
+declare const richSpansValueSchema: z.ZodArray<z.ZodObject<{
+    text: z.ZodString;
+    marks: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>>;
+}, z.core.$strip>>;
+type RichSpansValue = z.infer<typeof richSpansValueSchema>;
+/**
+ * Structural guard for the spans GRAMMAR only. Deliberately strict: every
+ * element must be a plain object whose `text` is a string and whose
+ * `marks`, if present, only contains whitelisted marks. It does NOT decide
+ * whether the value IS rich spans — see `isSpansValue`. Editors use this
+ * to keep round-tripping a value mid-edit (a run whose last mark was just
+ * toggled off is still grammar-valid), and message validators use it to
+ * accept an unmark action crossing the postMessage boundary.
+ */
+declare function isSpansShape(value: unknown): value is RichSpansValue;
+/** True when at least one span carries a non-empty mark list. */
+declare function spansHasMarks(value: RichSpansValue): boolean;
+/**
+ * "Spans iff marked" — the canonical rich-spans detector (audit E2 #28).
+ *
+ * A value is rich spans ONLY when it satisfies the grammar AND at least one
+ * span actually carries a mark. A `[{text}, {text}]` array with no marks
+ * anywhere is indistinguishable from a legitimate generic content array
+ * (testimonials/quotes/ticker items with a single `text` key), so it must
+ * keep flowing through the generic array code paths — the stega encoder
+ * registers its items per-path, the panel renders a FieldArray, etc.
+ * Writers enforce the complementary invariant: a spans value whose last
+ * mark is removed is normalised back to the plain string
+ * (`spansToPlainText`) before staging, so unmarked spans never persist.
+ */
+declare function isSpansValue(value: unknown): value is RichSpansValue;
+/** Flatten a spans value to its visible plain text (marks dropped). */
+declare function spansToPlainText(value: RichSpansValue): string;
+/**
+ * Plain-text view of a dual leaf. Use anywhere a string is required
+ * (summaries, stega visible text, graceful degradation).
+ */
+declare function leafToPlainText(value: string | RichSpansValue): string;
+declare const SIZE_MARK_EM: Record<string, string>;
+declare const FONT_MARK_VAR: Record<string, string>;
+/**
+ * CSS declarations for the tokenized marks of a span (color/size/font).
+ * Returns '' when none apply. `accent`/`bold`/`italic` are NOT covered
+ * here — they map to class/element (`.ac`, <strong>, <em>) renderer-side.
+ */
+declare function marksToInlineStyle(marks: readonly SpanMark[] | undefined): string;
+/** Serialized form for the lossless round-trip attribute (data-saastro-marks). */
+declare function marksToAttr(marks: readonly SpanMark[] | undefined): string;
+/** Parse the round-trip attribute back to a validated, sorted mark list. */
+declare function marksFromAttr(attr: string | null | undefined): SpanMark[];
+/**
+ * Exclusivity group of a mark. Tokenized marks are EXCLUSIVE within their
+ * group — one color, one size, one font per run — and `accent` shares the
+ * color group with `c:<token>` (both paint the run's text color).
+ */
+declare function markGroupPrefix(mark: SpanMark): 'color' | 'size' | 'font' | null;
+/** True when both marks belong to the same (non-null) exclusivity group. */
+declare function sameMarkGroup(a: SpanMark, b: SpanMark): boolean;
+/** Normalise: sort marks, merge adjacent equal-mark spans, drop empties, never []. */
+declare function normalizeSpans(spans: readonly RichSpan[]): RichSpansValue;
+/**
+ * Toggle `mark` across the [start, end) character range of the flattened
+ * text — the familiar bold-button semantics: if every character in the
+ * range already carries the mark it is removed, otherwise it is added.
+ * Adding a grouped mark (color/size/font — see `markGroupPrefix`) evicts
+ * its group siblings from the range so a run never accumulates e.g.
+ * `accent` + `c:<token>` (audit E2 #38/#40 — this eviction is canonical;
+ * the overlay's `toggleSpansMark` mirrors it).
+ */
+declare function toggleMarkOnRange(spans: RichSpansValue, start: number, end: number, mark: SpanMark): RichSpansValue;
+/**
+ * Deep-flatten every spans-SHAPED leaf of a translations tree to its
+ * concatenated plain text. This is the universal degradation a site's
+ * `getTranslations` applies so every `{t.x.y}` interpolation keeps
+ * rendering strings — never `[object Object]` (Astro) or a hooks crash
+ * (React islands). Rich rendering opts in per call site via <RichText>
+ * fed from the UN-flattened tree (`getRichTranslations`).
+ *
+ * Uses `isSpansShape` (structure only): unmarked spans-shaped arrays
+ * flatten too — content-wise they ARE plain text.
+ */
+declare function flattenSpansDeep<T>(value: T): T;
+
+export { COLOR_MARK_RE, FONT_MARK_RE, FONT_MARK_VAR, type RichSpan, type RichSpansValue, SIZE_MARK_EM, SIZE_MARK_RE, SPAN_MARKS, type SimpleSpanMark, type SpanMark, flattenSpansDeep, isSpansShape, isSpansValue, isValidMark, leafToPlainText, markGroupPrefix, marksFromAttr, marksToAttr, marksToInlineStyle, normalizeSpans, richSpanSchema, richSpansValueSchema, sameMarkGroup, spanMarkSchema, spansHasMarks, spansToPlainText, toggleMarkOnRange };

package/dist/richtext/index.js

@@ -0,0 +1,40 @@
+import {
+  COLOR_MARK_RE,
+  FONT_MARK_RE,
+  FONT_MARK_VAR,
+  SIZE_MARK_EM,
+  SIZE_MARK_RE,
+  SPAN_MARKS,
+  flattenSpansDeep,
+  isSpansShape,
+  isSpansValue,
+  isValidMark,
+  leafToPlainText,
+  marksFromAttr,
+  marksToAttr,
+  marksToInlineStyle,
+  richSpanSchema,
+  richSpansValueSchema,
+  spansToPlainText
+} from "../chunk-T3ZZAM65.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  COLOR_MARK_RE,
+  FONT_MARK_RE,
+  FONT_MARK_VAR,
+  SIZE_MARK_EM,
+  SIZE_MARK_RE,
+  SPAN_MARKS,
+  flattenSpansDeep,
+  isSpansShape,
+  isSpansValue,
+  isValidMark,
+  leafToPlainText,
+  marksFromAttr,
+  marksToAttr,
+  marksToInlineStyle,
+  richSpanSchema,
+  richSpansValueSchema,
+  spansToPlainText
+};
+//# sourceMappingURL=index.js.map

package/dist/richtext/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/vite/index.js

@@ -1,8 +1,9 @@
 import {
   studioAutoWrap
-} from "../chunk-7U2GMTVW.js";
-import "../chunk-5QZN4IGF.js";
+} from "../chunk-G3MUVKWX.js";
+import "../chunk-TU7VF6SY.js";
 import "../chunk-PKDMKMD6.js";
+import "../chunk-PZ5AY32C.js";
 export {
   studioAutoWrap as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saastro/studio",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "Build-time instrumentation for Saastro Studio — Vite plugin + editable helpers for Astro sites managed by Saastro Hub",
   "license": "MIT",
   "author": "SAASTRO",
@@ -46,12 +46,27 @@
       "types": "./dist/doctor.d.ts",
       "import": "./dist/doctor.js"
     },
-    "./Img.astro": "./src/Img.astro"
+    "./richtext": {
+      "types": "./dist/richtext/index.d.ts",
+      "import": "./dist/richtext/index.js"
+    },
+    "./Img.astro": "./src/Img.astro",
+    "./RichText.astro": "./src/RichText.astro"
   },
   "files": [
     "dist",
-    "src/Img.astro"
+    "src/Img.astro",
+    "src/RichText.astro"
   ],
+  "scripts": {
+    "build": "tsup && node scripts/inline-doctor-dts.mjs",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "pnpm run build"
+  },
   "peerDependencies": {
     "astro": "^5.0.0 || ^6.0.0 || ^7.0.0",
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
@@ -65,18 +80,10 @@
     "ts-morph": "^25.0.1"
   },
   "devDependencies": {
+    "@saastro/studio-core": "workspace:*",
     "tsup": "^8.5.1",
     "typescript": "^5.8.3",
     "vite": "^7.0.0",
-    "vitest": "^3.2.4",
-    "@saastro/studio-core": "0.0.1"
-  },
-  "scripts": {
-    "build": "tsup && node scripts/inline-doctor-dts.mjs",
-    "dev": "tsup --watch",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "clean": "rm -rf dist"
+    "vitest": "^3.2.4"
   }
-}
+}

package/src/RichText.astro

@@ -0,0 +1,93 @@
+---
+/**
+ * <RichText> — renders a dual i18n leaf (plain string | rich spans).
+ *
+ * Usage in a section component:
+ *
+ *   <h2 data-saastro-field="title"><RichText value={t.hero.title} /></h2>
+ *
+ * - Plain string → emitted as-is (text interpolation, auto-escaped).
+ * - Rich spans (`[{text, marks?}]`) → per span:
+ *     accent        → class `ac` (the theme's semantic accent class;
+ *                     override via `accentClass`)
+ *     bold / italic → nested <strong> / <em>
+ *     c:<token>     → `color: var(--<token>)` (site palette token)
+ *     s:sm|lg|xl    → relative font-size step
+ *     f:display|body|code → the site's semantic font-slot vars
+ *   Marked spans carry `data-saastro-marks` so the Studio canvas can
+ *   serialize the element back to the exact spans value (lossless
+ *   round-trip). All presentation derives from the SHARED mapping in
+ *   @saastro/studio/richtext — token names are regex-validated, raw CSS
+ *   values never travel in content, and set:html is never used.
+ * - Anything else (a malformed value) degrades to its concatenated plain
+ *   text when possible, never `[object Object]`.
+ *
+ * Ships with @saastro/studio (consumed via the `./RichText.astro` export).
+ */
+import {
+  isSpansValue,
+  leafToPlainText,
+  marksToAttr,
+  marksToInlineStyle,
+} from '@saastro/studio/richtext'
+
+interface Props {
+  /** The i18n leaf: plain string or rich spans array. */
+  value: unknown
+  /** Class applied to accent spans; defaults to the theme's semantic `ac`. */
+  accentClass?: string
+}
+
+const { value, accentClass = 'ac' } = Astro.props
+
+const spans = isSpansValue(value)
+  ? value.map(s => {
+      const marks = s.marks ?? []
+      const style = marksToInlineStyle(marks)
+      return {
+        text: s.text,
+        bold: marks.includes('bold'),
+        italic: marks.includes('italic'),
+        accent: marks.includes('accent'),
+        style: style.length > 0 ? style : undefined,
+        attr: marksToAttr(marks),
+      }
+    })
+  : null
+
+const plain = spans
+  ? null
+  : typeof value === 'string'
+    ? value
+    : Array.isArray(value)
+      ? leafToPlainText(value.filter(s => typeof (s as { text?: unknown })?.text === 'string') as never)
+      : value == null
+        ? ''
+        : String(value)
+---
+
+{
+  spans
+    ? spans.map(s =>
+        s.attr ? (
+          <span
+            class={s.accent ? accentClass : undefined}
+            style={s.style}
+            data-saastro-marks={s.attr}
+          >
+            {s.bold && s.italic ? (
+              <strong><em>{s.text}</em></strong>
+            ) : s.bold ? (
+              <strong>{s.text}</strong>
+            ) : s.italic ? (
+              <em>{s.text}</em>
+            ) : (
+              s.text
+            )}
+          </span>
+        ) : (
+          s.text
+        ),
+      )
+    : plain
+}

package/dist/chunk-5QZN4IGF.js

@@ -1,71 +0,0 @@
-// src/vite/meta-tag.ts
-var STUDIO_PROTOCOL_VERSION = "2";
-var PACKAGE_VERSION = "0.7.1".length > 0 ? "0.7.1" : "0.0.0+unknown";
-var META_TAGS = [
-  `<meta name="saastro:studio-version" content="${STUDIO_PROTOCOL_VERSION}">`,
-  `<meta name="saastro:studio-package" content="${PACKAGE_VERSION}">`
-].join("\n  ");
-function injectVersionMetaTag(html) {
-  if (html.includes("saastro:studio-version")) return html;
-  return html.replace(/<head([^>]*)>/i, `<head$1>
-  ${META_TAGS}`);
-}
-
-// src/visibility-css.ts
-var CONFIG_FILENAME = "studio.config.json";
-var STYLE_ID = "saastro-studio-hidden";
-function readVisibilityConfigSync(projectRoot = ".") {
-  try {
-    const req = globalThis.require;
-    if (typeof req !== "function") return {};
-    const fs = req("node:fs");
-    const path = req("node:path");
-    const raw = fs.readFileSync(path.resolve(projectRoot, CONFIG_FILENAME), "utf8");
-    if (!raw.trim()) return {};
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object") return parsed;
-    return {};
-  } catch {
-    return {};
-  }
-}
-function collectHiddenFieldPrefixes(config) {
-  const set = /* @__PURE__ */ new Set();
-  for (const prefixes of Object.values(config.hidden ?? {})) {
-    if (!Array.isArray(prefixes)) continue;
-    for (const p of prefixes) {
-      if (typeof p === "string" && p.length > 0) set.add(p);
-    }
-  }
-  return Array.from(set).sort();
-}
-function buildVisibilityStyleTag(config) {
-  const prefixes = collectHiddenFieldPrefixes(config);
-  if (prefixes.length === 0) return "";
-  const rules = prefixes.map((fp) => {
-    const safe = `sec:${fp}`.replace(/["\\]/g, "\\$&");
-    return `[data-saastro="${safe}"]{display:none !important}`;
-  }).join("");
-  return `<style id="${STYLE_ID}">${rules}</style>`;
-}
-function injectVisibilityStyle(html, _projectRoot = ".") {
-  if (html.includes(`id="${STYLE_ID}"`)) return html;
-  let tag = "";
-  try {
-    if (typeof __SAASTRO_STUDIO_HIDDEN_TAG__ === "string") {
-      tag = __SAASTRO_STUDIO_HIDDEN_TAG__;
-    }
-  } catch {
-  }
-  if (!tag) return html;
-  return html.replace(/<head([^>]*)>/i, `<head$1>
-  ${tag}`);
-}
-
-export {
-  injectVersionMetaTag,
-  readVisibilityConfigSync,
-  buildVisibilityStyleTag,
-  injectVisibilityStyle
-};
-//# sourceMappingURL=chunk-5QZN4IGF.js.map

package/dist/chunk-5QZN4IGF.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/vite/meta-tag.ts","../src/visibility-css.ts"],"sourcesContent":["/**\n * Injects two meta tags into the HTML <head>:\n *   - <meta name=\"saastro:studio-version\" content=\"2\">       — protocol version\n *   - <meta name=\"saastro:studio-package\" content=\"X.Y.Z\">  — npm package version\n *\n * B8 — spec v5.3 §2 bumps the postMessage protocol number to \"2\". The\n * `studio-version` field reads as the PROTOCOL version (the contract Hub\n * relies on when wiring overlay <-> host messages), not the npm package\n * version of `@saastro/studio`. The package version still ships in a\n * separate `saastro:studio-package` tag for telemetry.\n *\n * The package version comes from a tsup `define` substitution\n * (`__SAASTRO_STUDIO_VERSION__`) injected at build time. The previous\n * implementation used `createRequire(import.meta.url)` to read\n * `package.json` at runtime, but tsup's chunked output places dist\n * files at `dist/chunk-XXX.js` and `../../package.json` resolves\n * OUTSIDE the package — the require always threw and the catch fell\n * back to a hardcoded `'0.1.0'`. Build-time substitution is bullet-\n * proof regardless of how tsup chunks the bundle.\n *\n * This is separate from the auto-wrap transform hook —\n * transformIndexHtml runs on rendered HTML output, not on .astro\n * source files.\n */\n\n/**\n * postMessage protocol version. Bumped to \"2\" in spec v5.3 to add\n * `studio:sections:enumerate` + `studio:select:section` exchanges.\n * Increment when adding/changing the iframe⇄host wire format.\n */\nconst STUDIO_PROTOCOL_VERSION = '2'\n\ndeclare const __SAASTRO_STUDIO_VERSION__: string | undefined\n\nconst PACKAGE_VERSION =\n  typeof __SAASTRO_STUDIO_VERSION__ === 'string' && __SAASTRO_STUDIO_VERSION__.length > 0\n    ? __SAASTRO_STUDIO_VERSION__\n    : '0.0.0+unknown'\n\nconst META_TAGS = [\n  `<meta name=\"saastro:studio-version\" content=\"${STUDIO_PROTOCOL_VERSION}\">`,\n  `<meta name=\"saastro:studio-package\" content=\"${PACKAGE_VERSION}\">`,\n].join('\\n  ')\n\n/**\n * Inject the two studio meta tags into the HTML head. Idempotent —\n * skips injection if the protocol-version tag is already present\n * (matches both the new shape and the legacy single-tag shape, so\n * customer sites with old metadata aren't double-tagged on rebuild).\n */\nexport function injectVersionMetaTag(html: string): string {\n  if (html.includes('saastro:studio-version')) return html\n  return html.replace(/<head([^>]*)>/i, `<head$1>\\n  ${META_TAGS}`)\n}\n","/**\n * Read `studio.config.json` from a project root and build the\n * `<style>` block that hides sections flagged as `hidden`.\n *\n * The config shape is the one written by the Studio Hub at publish time:\n *\n *   {\n *     \"hidden\": {\n *       \"<pageFile>\": [\"<fieldPrefix>\", ...]\n *     }\n *   }\n *\n * The CSS targets the `data-saastro=\"sec:<fieldPrefix>\"` markers the\n * auto-wrap plugin emits — so hiding is \"exactly the section root,\n * nothing more\". Selectors are flattened across all `pageFile` entries:\n * Studio's `fieldPrefix` naming convention is `<sectionName>.<pageName>`\n * which keeps them unique site-wide, so this loses no precision.\n *\n * Both the Vite `transformIndexHtml` hook (static-build sites) and the\n * Astro middleware (SSR routes) call into the same helpers so the\n * injected CSS is identical regardless of render mode.\n */\n\n// **CRITICAL — DO NOT add static node:fs / node:path imports here.**\n// This module is loaded by `@saastro/studio/middleware`, which runs\n// inside Cloudflare Workers at SSR boot. CF Workers does not support\n// `node:fs` even with the `nodejs_compat` flag (sync fs I/O is\n// fundamentally incompatible with the worker model) — a top-level\n// `import { readFileSync } from 'node:fs'` causes the module to fail\n// to load with `Error: No such module \"node:fs\"`, which breaks the\n// entire middleware chain and makes Astro return 500 on every SSR\n// route.\n//\n// The `node:fs` fallback (used by `astro dev` in Node) loads via\n// dynamic import inside `readVisibilityConfig`, wrapped in try/catch.\n// Workers never reaches that path because the build-time `define`\n// (`__SAASTRO_STUDIO_HIDDEN_TAG__`) short-circuits the readFileSync\n// call entirely.\n\nconst CONFIG_FILENAME = 'studio.config.json'\nconst STYLE_ID = 'saastro-studio-hidden'\n\n/**\n * Compile-time constant injected by the `@saastro/studio` Vite plugin\n * (see `config()` hook in `vite/index.ts`). esbuild substitutes the\n * identifier at customer-bundle time with a JSON string of the\n * full `<style>` tag (or an empty string when nothing is hidden), so\n * the middleware doesn't need filesystem access at runtime — a\n * hard requirement on Cloudflare Workers, where `node:fs` is a no-op.\n *\n * Declared as a free variable on the global scope so esbuild's\n * `define` substitution recognises it as a literal-replacement\n * target. When the plugin isn't installed, the identifier remains\n * undefined and the middleware falls back to the readFileSync path\n * (works in node-based deployments).\n */\ndeclare const __SAASTRO_STUDIO_HIDDEN_TAG__: string | undefined\n\ninterface StudioConfig {\n  hidden?: Record<string, string[]>\n}\n\n/**\n * Read studio.config.json from `projectRoot`. Returns an empty config\n * if the file is missing or malformed — a publish that hasn't written\n * the config yet behaves like \"nothing hidden\".\n *\n * Defaulting `projectRoot` to `'.'` lets callers omit it when they\n * cannot easily determine the resolved Vite root — `node:path.resolve`\n * resolves relative to the current working directory, which is the\n * project root in every realistic deployment of the middleware.\n */\n/**\n * Build-time-only helper. Imports `node:fs` lazily so this module\n * stays loadable on CF Workers (where `node:fs` is not available).\n * The Vite plugin (`vite/index.ts`, runs in Node) calls this during\n * `config()` to inline the visibility tag as a `define` constant.\n * The runtime middleware (`middleware/index.ts`, runs in Workers)\n * never calls it — it reads the inlined define directly.\n *\n * Returns `{}` when the file isn't there, isn't readable, or when\n * `node:fs` simply isn't available (e.g. bundled into a non-Node\n * runtime that somehow reached this branch).\n */\nexport async function readVisibilityConfig(\n  projectRoot: string = '.',\n): Promise<StudioConfig> {\n  try {\n    const [{ readFileSync }, { resolve }] = await Promise.all([\n      import('node:fs'),\n      import('node:path'),\n    ])\n    const raw = readFileSync(resolve(projectRoot, CONFIG_FILENAME), 'utf8')\n    if (!raw.trim()) return {}\n    const parsed = JSON.parse(raw) as unknown\n    if (parsed && typeof parsed === 'object') return parsed as StudioConfig\n    return {}\n  } catch {\n    return {}\n  }\n}\n\n/**\n * Synchronous variant kept for back-compat with callers that can't\n * await (e.g. test fixtures, legacy plugin hooks). Same lazy node:fs\n * import via `require` — works in Node CJS contexts, returns `{}`\n * on CF Workers / pure-ESM environments where `require` is undefined.\n *\n * The dynamic `globalThis.require` lookup avoids esbuild bundling the\n * module reference, which means CF Workers never throws\n * \"No such module 'node:fs'\" at import time.\n */\nexport function readVisibilityConfigSync(projectRoot: string = '.'): StudioConfig {\n  try {\n    const req = (globalThis as { require?: (id: string) => unknown }).require\n    if (typeof req !== 'function') return {}\n    const fs = req('node:fs') as { readFileSync: (p: string, e: string) => string }\n    const path = req('node:path') as { resolve: (...parts: string[]) => string }\n    const raw = fs.readFileSync(path.resolve(projectRoot, CONFIG_FILENAME), 'utf8')\n    if (!raw.trim()) return {}\n    const parsed = JSON.parse(raw) as unknown\n    if (parsed && typeof parsed === 'object') return parsed as StudioConfig\n    return {}\n  } catch {\n    return {}\n  }\n}\n\n/**\n * Collect every fieldPrefix flagged as hidden across all pageFile\n * entries. Deduplicates so a prefix that appears under multiple\n * pageFiles only emits one selector.\n */\nexport function collectHiddenFieldPrefixes(config: StudioConfig): string[] {\n  const set = new Set<string>()\n  for (const prefixes of Object.values(config.hidden ?? {})) {\n    if (!Array.isArray(prefixes)) continue\n    for (const p of prefixes) {\n      if (typeof p === 'string' && p.length > 0) set.add(p)\n    }\n  }\n  return Array.from(set).sort()\n}\n\n/**\n * Build the `<style>` block. Returns an empty string when there's\n * nothing to hide so callers can no-op without conditional branching.\n */\nexport function buildVisibilityStyleTag(config: StudioConfig): string {\n  const prefixes = collectHiddenFieldPrefixes(config)\n  if (prefixes.length === 0) return ''\n  const rules = prefixes\n    .map(fp => {\n      // CSS attribute-selector grammar: only `\\` and `\"` need escaping\n      // inside `[attr=\"...\"]`. fieldPrefix is conventionally\n      // `[a-zA-Z0-9._-]+` so this is belt-and-braces.\n      const safe = `sec:${fp}`.replace(/[\"\\\\]/g, '\\\\$&')\n      return `[data-saastro=\"${safe}\"]{display:none !important}`\n    })\n    .join('')\n  return `<style id=\"${STYLE_ID}\">${rules}</style>`\n}\n\n/**\n * Inject the visibility `<style>` into an HTML document's `<head>`.\n * Idempotent: a page that already carries a `${STYLE_ID}` style is\n * returned unchanged.\n */\nexport function injectVisibilityStyle(html: string, _projectRoot: string = '.'): string {\n  if (html.includes(`id=\"${STYLE_ID}\"`)) return html\n  // Prefer the build-time-injected tag when the customer's Vite build\n  // populated `__SAASTRO_STUDIO_HIDDEN_TAG__` via the plugin's `config`\n  // hook. This is the only path that works on Cloudflare Workers, where\n  // `node:fs` is a no-op. The readFileSync fallback handles node-based\n  // deployments (or local `astro dev` before the plugin's define lands).\n  let tag = ''\n  try {\n    if (typeof __SAASTRO_STUDIO_HIDDEN_TAG__ === 'string') {\n      tag = __SAASTRO_STUDIO_HIDDEN_TAG__\n    }\n  } catch {\n    // ReferenceError swallowed — identifier wasn't substituted.\n  }\n  // No `readFileSync` fallback in this runtime path — that branch\n  // only worked on Node and breaks CF Workers (`node:fs` import\n  // throws \"No such module\"). When the build-time define isn't\n  // populated (e.g. someone uses the middleware without the Vite\n  // plugin), the visibility CSS just isn't injected — graceful\n  // degradation, the meta tag still works.\n  if (!tag) return html\n  return html.replace(/<head([^>]*)>/i, `<head$1>\\n  ${tag}`)\n}\n"],"mappings":";AA8BA,IAAM,0BAA0B;AAIhC,IAAM,kBAC8C,QAA2B,SAAS,IAClF,UACA;AAEN,IAAM,YAAY;AAAA,EAChB,gDAAgD,uBAAuB;AAAA,EACvE,gDAAgD,eAAe;AACjE,EAAE,KAAK,MAAM;AAQN,SAAS,qBAAqB,MAAsB;AACzD,MAAI,KAAK,SAAS,wBAAwB,EAAG,QAAO;AACpD,SAAO,KAAK,QAAQ,kBAAkB;AAAA,IAAe,SAAS,EAAE;AAClE;;;ACdA,IAAM,kBAAkB;AACxB,IAAM,WAAW;AAwEV,SAAS,yBAAyB,cAAsB,KAAmB;AAChF,MAAI;AACF,UAAM,MAAO,WAAqD;AAClE,QAAI,OAAO,QAAQ,WAAY,QAAO,CAAC;AACvC,UAAM,KAAK,IAAI,SAAS;AACxB,UAAM,OAAO,IAAI,WAAW;AAC5B,UAAM,MAAM,GAAG,aAAa,KAAK,QAAQ,aAAa,eAAe,GAAG,MAAM;AAC9E,QAAI,CAAC,IAAI,KAAK,EAAG,QAAO,CAAC;AACzB,UAAM,SAAS,KAAK,MAAM,GAAG;AAC7B,QAAI,UAAU,OAAO,WAAW,SAAU,QAAO;AACjD,WAAO,CAAC;AAAA,EACV,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;AAOO,SAAS,2BAA2B,QAAgC;AACzE,QAAM,MAAM,oBAAI,IAAY;AAC5B,aAAW,YAAY,OAAO,OAAO,OAAO,UAAU,CAAC,CAAC,GAAG;AACzD,QAAI,CAAC,MAAM,QAAQ,QAAQ,EAAG;AAC9B,eAAW,KAAK,UAAU;AACxB,UAAI,OAAO,MAAM,YAAY,EAAE,SAAS,EAAG,KAAI,IAAI,CAAC;AAAA,IACtD;AAAA,EACF;AACA,SAAO,MAAM,KAAK,GAAG,EAAE,KAAK;AAC9B;AAMO,SAAS,wBAAwB,QAA8B;AACpE,QAAM,WAAW,2BAA2B,MAAM;AAClD,MAAI,SAAS,WAAW,EAAG,QAAO;AAClC,QAAM,QAAQ,SACX,IAAI,QAAM;AAIT,UAAM,OAAO,OAAO,EAAE,GAAG,QAAQ,UAAU,MAAM;AACjD,WAAO,kBAAkB,IAAI;AAAA,EAC/B,CAAC,EACA,KAAK,EAAE;AACV,SAAO,cAAc,QAAQ,KAAK,KAAK;AACzC;AAOO,SAAS,sBAAsB,MAAc,eAAuB,KAAa;AACtF,MAAI,KAAK,SAAS,OAAO,QAAQ,GAAG,EAAG,QAAO;AAM9C,MAAI,MAAM;AACV,MAAI;AACF,QAAI,OAAO,kCAAkC,UAAU;AACrD,YAAM;AAAA,IACR;AAAA,EACF,QAAQ;AAAA,EAER;AAOA,MAAI,CAAC,IAAK,QAAO;AACjB,SAAO,KAAK,QAAQ,kBAAkB;AAAA,IAAe,GAAG,EAAE;AAC5D;","names":[]}