astroidjs 0.12.1 → 0.14.0

package/dist/schema/collections.js

@@ -3,12 +3,12 @@
 // Astroid → Louise content mapping. This is the opinionated seam: given an
 // Astroid project config, derive the Louise `CollectionConfig`(s) a site needs.
 // Astroid decides WHICH collections and fields exist (its opinions); Louise's
-// codegen decides HOW they become D1 tables. Dependency flows one way — this
+// codegen decides HOW they become D1 tables. Dependency flows one way—this
 // imports `louise-toolkit/content`, never the reverse.
 // `content/define` and `content/sections` rather than the `content` barrel: the
 // barrel eagerly pulls the codegen/localApi/validation chunks, and those import
-// drizzle-orm for real — an *optional* peer of louise-toolkit, so importing it
-// here would force a package on consumers who only DESCRIBE content (e.g.
+// drizzle-orm for real—an *optional* peer of louise-toolkit, so importing it
+// here would force a package on consumers who only DESCRIBE content (for example,
 // create-astroid's schema generators, which call this function but never run the
 // beforeChange hook below). Both entries are drizzle-free: `content/define` for
 // the config types/builders, and `content/sections` for the write-time section
@@ -18,23 +18,23 @@
 // drizzle-free.
 //
 // Note the entry named here is the PUBLIC subpath. Astroid must never reach into
-// `louise-toolkit/src/...` — that resolves only because the workspace aliases the
+// `louise-toolkit/src/...`—that resolves only because the workspace aliases the
 // package to its source, and would break the moment astroid consumes a published
 // tarball (#327).
 import { defineCollection, } from "louise-toolkit/content/define";
 import { assertValidSections, sanitizeSectionsRichText } from "louise-toolkit/content/sections";
 import { sanitizeRichHtml } from "louise-toolkit/security";
-// The catalog is the single declaration of what a section IS — the same object
+// The catalog is the single declaration of what a section IS—the same object
 // the on-canvas editor mounts with and this hook validates against. It lives
 // beside the components (it ships as source for them) and is imported here so
 // the two can't drift.
 import { astroidSectionCatalog } from "../components/sections.js";
 /**
- * The opinionated `pages` collection — the EDITABLE page fields, versioned
+ * The opinionated `pages` collection—the EDITABLE page fields, versioned
  * drafts, and full-text search. Keyed to the same names as Louise's `pagesColumns`
  * so a publish's `.set()` maps straight onto the physical columns; bookkeeping
  * columns (`id`/`status`/timestamps/`publishedVersionId`) live on the table via
- * `pagesColumns`, never here — matching the site's `pages-collection.ts`.
+ * `pagesColumns`, never here—matching the site's `pages-collection.ts`.
  *
  * Validated by `defineCollection` at build time, so a malformed field shape throws
  * here rather than at codegen.
@@ -58,21 +58,21 @@ function resolveSectionCatalog(config) {
  * declaring a `blocks` policy, no block is ever reached.
  *
  * It is NOT optional once a site does declare one. Unlike the section catalog
- * there's no built-in fallback to borrow — block types are wholly site-defined —
- * so an unset catalog means every block `_type` reads as unknown and the write
- * 422s, and block rich text goes unsanitized because its def can't be resolved.
+ * there's no built-in fallback to borrow—block types are wholly site-defined—so
+ * an unset catalog means every block `_type` reads as unknown and the write
+ * returns 422, and block rich text goes unsanitized because its def can't be resolved.
  */
 function resolveBlockCatalog(config) {
     return config.blockCatalog ?? {};
 }
 /**
  * Return a copy of a `pages` write payload with its `sections` rich-text fields
- * sanitized against the project media base — a no-op when the write carries no
+ * sanitized against the project media base—a no-op when the write carries no
  * `sections`. Pure; leaves every other field (and a partial PATCH's absent ones)
  * untouched.
  *
  * Exported because two write paths need it: the collection's `beforeChange` hook
- * below, AND the raw `pagesRoute` (which does not run collection hooks — see
+ * below, AND the raw `pagesRoute` (which does not run collection hooks—see
  * {@link astroidPagesWriteHooks}).
  */
 export function sanitizeAstroidPageSections(config, data) {
@@ -84,7 +84,7 @@ export function sanitizeAstroidPageSections(config, data) {
 }
 /**
  * Validate the (already-sanitized) `sections` of a `pages` write against the
- * catalog, throwing `LouiseValidationError` — an unknown `_type`, a field of the
+ * catalog, throwing `LouiseValidationError`—an unknown `_type`, a field of the
  * wrong shape, or a setting outside its declared options is rejected with a 422
  * carrying the per-field violations. A no-op when the write carries no
  * `sections`, so a partial PATCH of other fields isn't spuriously validated.
@@ -99,47 +99,48 @@ export async function assertAstroidPageSections(config, data, operation = "updat
     });
 }
 /**
- * The write-time hooks the raw `pagesRoute` (louise-toolkit/editor) needs to
- * enforce the same section contract as the draft path.
- *
- * `pagesRoute` writes straight to the table and — unlike `versionsRoute` — takes
- * no collection config, so it never runs the `beforeChange` hook below. Left
- * bare (as it was), a direct `POST` / `PATCH /api/louise/pages/:id` persists an
- * unknown section `_type`, a setting outside its options, or unsanitized section
- * rich text: exactly what the hook exists to stop, silently missing from the one
- * route the on-canvas *structural* edits flow through. `<Sections>` then skips
- * the bad `_type`, so the section just vanishes with no error anywhere.
- *
- * These wire the SAME sanitize + validate the hook uses into `pagesRoute`'s
- * `sanitize` / `transform` / `validate` seams, so both write paths enforce one
- * contract. Spread into the route config:
- *
- *   pagesRoute({ table: pages, resolveEditor, fields, ...astroidPagesWriteHooks(config) })
+ * Slugs no page may take, on any site. Each one is a path Astro, Cloudflare,
+ * or Astroid serves before the catch-all page route, so a page saved under it
+ * would be unreachable, and nothing would say why. `pagesRoute` refuses them
+ * with a 422 instead.
  */
-export function astroidPagesWriteHooks(config) {
+export const ASTROID_RESERVED_SLUGS = [
+    "404",
+    "_astro",
+    "api",
+    "cdn-cgi",
+    "robots.txt",
+    "sitemap.xml",
+];
+export function astroidPagesWriteHooks(config, site = {}) {
     const mediaBase = pageMediaBase(config);
     return {
-        // `body` is a richField, so it goes through pagesRoute's own sanitize seam —
-        // with the project media base, matching the hook rather than the toolkit
+        // `body` is a richField, so it goes through pagesRoute's own sanitize seam—with
+        // the project media base, matching the hook rather than the toolkit
         // default sanitizer that knows no media base.
         sanitize: (html) => sanitizeRichHtml(html, { mediaBase }),
         // `sections` is not a richField, so it's sanitized here in the transform,
-        // which pagesRoute runs BEFORE validate — the hook's sanitize-then-validate
-        // order.
-        transform: (data) => sanitizeAstroidPageSections(config, data),
-        validate: (data, ctx) => assertAstroidPageSections(config, data, ctx.operation),
+        // which pagesRoute runs BEFORE validate—the hook's sanitize-then-validate
+        // order. The site's own transform runs first, so Astroid's sanitize sees
+        // the value the site is about to store.
+        transform: async (data, ctx) => sanitizeAstroidPageSections(config, site.transform ? await site.transform(data, ctx) : data),
+        validate: async (data, ctx) => {
+            await site.validate?.(data, ctx);
+            await assertAstroidPageSections(config, data, ctx.operation);
+        },
+        reservedSlugs: [...ASTROID_RESERVED_SLUGS, ...(site.reservedSlugs ?? [])],
     };
 }
 export function astroidPagesCollection(config) {
     // The `body` is rich HTML edited in place (`<Editable type="richtext">`) and
-    // staged as a draft, so sanitize it on every write — never store raw HTML. A
+    // staged as a draft, so sanitize it on every write—never store raw HTML. A
     // pasted `<img>` pointing off-origin (a hotlink) is dropped: body images must
     // live in the media library. Mirrors the reference site's pages-collection hook.
     const mediaBase = pageMediaBase(config);
     const fields = {};
     fields.slug = { type: "text", required: true };
     fields.title = { type: "text", required: true };
-    // Sanitized rich HTML (a string), not TipTap JSON — matches `pagesColumns.body`.
+    // Sanitized rich HTML (a string), not TipTap JSON—matches `pagesColumns.body`.
     fields.body = { type: "text" };
     fields.seoTitle = { type: "text" };
     fields.seoDescription = { type: "text" };
@@ -147,7 +148,7 @@ export function astroidPagesCollection(config) {
     fields.noindex = { type: "checkbox" };
     fields.sortOrder = { type: "number" };
     // Structured page-builder blocks (the editable home), deep-validated against
-    // the section catalog on write — see the beforeChange hook below.
+    // the section catalog on write—see the beforeChange hook below.
     fields.sections = { type: "json" };
     return defineCollection({
         slug: "pages",
@@ -163,7 +164,7 @@ export function astroidPagesCollection(config) {
                     // validating the raw value would pass content the sanitizer is about
                     // to change. Same order as the body above. Both steps are shared with
                     // the raw pagesRoute (see astroidPagesWriteHooks) so the two write
-                    // paths can't diverge — the sanitize throws nothing, the assert throws
+                    // paths can't diverge—the sanitize throws nothing, the assert throws
                     // LouiseValidationError → 422 with per-field violations.
                     next = sanitizeAstroidPageSections(config, next);
                     await assertAstroidPageSections(config, next, "update");
@@ -177,8 +178,8 @@ export function astroidPagesCollection(config) {
 }
 /**
  * The Louise `ContentConfig` for an Astroid project. Today: the `pages`
- * collection. Archetype- and module-specific collections (e.g. a portfolio
- * `gallery`) layer in here as they land — this is the single place that maps
+ * collection. Archetype- and module-specific collections (for example, a portfolio
+ * `gallery`) layer in here as they land—this is the single place that maps
  * brand config down to Louise content.
  */
 export function astroidContentConfig(config) {

package/dist/schema/framework.d.ts

@@ -1,7 +1,7 @@
 import type { AstroidConfig } from "../config.js";
 /** A ready-made table Astroid re-exports from `louise-toolkit/db`. */
 export type AstroidFrameworkTable = "inquiries" | "media" | "siteSettings";
-/** True when the site captures inquiries — a contact section or a
+/** True when the site captures inquiries—a contact section or a
  *  wholesale-inquiry module. Shared by table selection (here) and route selection
  *  (the worker route plan). */
 export declare function capturesInquiries(config: AstroidConfig): boolean;

package/dist/schema/framework.js

@@ -5,11 +5,11 @@
 // tables never drift from Louise. `media` and `siteSettings` are universal;
 // `inquiries` is pulled in only when a brand actually captures inquiries (a
 // contact section, or a wholesale-inquiry module).
-/** True when the site captures inquiries — a contact section or a
+/** True when the site captures inquiries—a contact section or a
  *  wholesale-inquiry module. Shared by table selection (here) and route selection
  *  (the worker route plan). */
 export function capturesInquiries(config) {
-    // Explicit override wins — a site whose inquiry surface is a bespoke section
+    // Explicit override wins—a site whose inquiry surface is a bespoke section
     // (coracle's custom `contactForm`) can't be detected from the built-in
     // vocabulary, so it says so directly.
     if (typeof config.inquiries === "boolean")

package/dist/schema/generate.js

@@ -1,6 +1,6 @@
 // Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
 //
-// generateAstroidSchema — emit the Drizzle schema source (a site's `schema.ts`)
+// generateAstroidSchema—emit the Drizzle schema source (a site's `schema.ts`)
 // from an Astroid config. This is the boilerplate every Louise site hand-writes:
 // compose the framework `pagesColumns` into a `pages` table, add the versions
 // table + publish pointer, and re-export the ready-made framework tables. Astroid
@@ -24,14 +24,14 @@ export function generateAstroidSchema(config) {
     // One import brings them all in (matching the site) so nothing is unused.
     const dbImports = [...framework, "pagesColumns"].sort();
     const catalog = generateCatalogTable(config);
-    // Only import the column builders the emitted source actually uses — an
+    // Only import the column builders the emitted source actually uses—an
     // unused import is a lint error in the project we're generating into, and a
     // missing one (`real`, from the catalog's price/sortOrder) is a type error.
     const drizzleImports = ["integer", "sqliteTable", "text"];
     if (catalog?.includes("real("))
         drizzleImports.push("real");
     return [
-        "// Generated by astroidjs — do not hand-edit.",
+        "// Generated by astroidjs—do not hand-edit.",
         "// Source: your defineAstroid config.",
         `import { ${drizzleImports.sort().join(", ")} } from "drizzle-orm/sqlite-core";`,
         'import { collectionVersionsTable, type JsonValue } from "louise-toolkit/content";',
@@ -46,8 +46,8 @@ export function generateAstroidSchema(config) {
         '  publishedVersionId: integer("published_version_id"),',
         "});",
         "",
-        "// Version snapshots for pages. Field-independent — each saved version is one",
-        "// JSON blob — so the table only needs the slug.",
+        "// Version snapshots for pages. Field-independent—each saved version is one",
+        "// JSON blob—so the table only needs the slug.",
         'export const pagesVersions = collectionVersionsTable({ slug: "pages", fields: {} });',
         "",
         ...(catalog ? [catalog] : []),
@@ -56,7 +56,7 @@ export function generateAstroidSchema(config) {
         "// Site-owned tables (the ones Astroid doesn't manage): a project declares",
         "// its own Drizzle tables in src/schema.site.ts and they're re-exported here",
         "// so drizzle-kit sees them and the generated worker can import them. The file",
-        "// is scaffold-once — empty until a project adds a table — so this re-export is",
+        "// is scaffold-once—empty until a project adds a table—so this re-export is",
         "// always safe.",
         'export * from "./schema.site.js";',
         "",

package/dist/schema/index.js

@@ -1,6 +1,6 @@
 // Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
 //
-// Schema generation — config → Louise content config → Drizzle schema source.
+// Schema generation—config → Louise content config → Drizzle schema source.
 export * from "./collections.js";
 export * from "./framework.js";
 export * from "./generate.js";

package/dist/secrets.d.ts

@@ -2,7 +2,7 @@ import { type SecretSource } from "louise-toolkit/security";
 export type { SecretSource };
 /**
  * The placeholder every Astroid scaffold seeds its unprovisioned secrets with.
- * Reading it back means "not configured yet", never a credential — the value is
+ * Reading it back means "not configured yet", never a credential—the value is
  * deliberately loud so it is obvious in a Secrets Store listing or a log line.
  *
  * It matches the sentinel `louise-toolkit`'s Turnstile gate already recognizes,
@@ -11,7 +11,7 @@ export type { SecretSource };
 export declare const ASTROID_SECRET_PLACEHOLDER = "DUMMY_REPLACE_ME";
 /**
  * Read one secret under the Astroid convention: `null` unless it holds a real,
- * non-placeholder value. Thin by design — the reason to call this rather than
+ * non-placeholder value. Thin by design—the reason to call this rather than
  * `readSecret` directly is that it binds Astroid's sentinel for you.
  */
 export declare function readModuleSecret(source: SecretSource): Promise<string | null>;
@@ -19,14 +19,14 @@ export declare function readModuleSecret(source: SecretSource): Promise<string |
 export interface ModuleSecrets<K extends string> {
     /**
      * True when EVERY secret the module declared resolved to a real value. The
-     * module's `isConfigured()` should be exactly this — partial provisioning is
+     * module's `isConfigured()` should be exactly this—partial provisioning is
      * treated as dormant, since a half-configured integration fails at the worst
      * possible moment (mid-checkout) rather than at boot.
      */
     configured: boolean;
     /** Each declared secret's resolved value, or `null` where unprovisioned. */
     values: Record<K, string | null>;
-    /** The still-unprovisioned names, in declaration order — the "why not" list. */
+    /** The still-unprovisioned names, in declaration order—the "why not" list. */
     missing: K[];
 }
 /**
@@ -46,9 +46,9 @@ export interface ModuleSecrets<K extends string> {
  */
 export declare function resolveModuleSecrets<K extends string>(sources: Record<K, SecretSource>): Promise<ModuleSecrets<K>>;
 /**
- * A one-line, human-readable status for a module — what `astroid doctor`, a dev
+ * A one-line, human-readable status for a module—what `astroid doctor`, a dev
  * server banner, or a health endpoint should print. Naming the missing secrets
  * is the whole point: "commerce is off" sends someone reading source, "commerce
- * is dormant — set SQUARE_ACCESS_TOKEN" does not.
+ * is dormant—set SQUARE_ACCESS_TOKEN" does not.
  */
 export declare function describeModuleStatus<K extends string>(module: string, status: ModuleSecrets<K>): string;

package/dist/secrets.js

@@ -5,7 +5,7 @@
 // Astroid's optional modules are opt-in at the CONFIG level but not at the
 // account level: switching `commerce` on in `defineAstroid` must not require a
 // Square account before `pnpm dev` will boot. So every module here follows one
-// rule — a module whose secrets are unprovisioned is DORMANT: it renders, it
+// rule—a module whose secrets are unprovisioned is DORMANT: it renders, it
 // serves, it says out loud that it is simulated, and it never calls upstream
 // with a dummy credential.
 //
@@ -13,7 +13,7 @@
 // absent / unreadable / empty / a placeholder reads as `null`). What lives here
 // is the *convention* over it, which is Astroid's opinion, not the toolkit's:
 //
-//   1. ONE sentinel — `ASTROID_SECRET_PLACEHOLDER` — seeded by `create-astroid`
+//   1. ONE sentinel—`ASTROID_SECRET_PLACEHOLDER`—seeded by `create-astroid`
 //      into every secret a scaffold declares, so a fresh clone has a complete,
 //      valid binding set and zero real credentials.
 //   2. `resolveModuleSecrets` collapses a module's whole secret set into one
@@ -24,7 +24,7 @@
 import { readSecret } from "louise-toolkit/security";
 /**
  * The placeholder every Astroid scaffold seeds its unprovisioned secrets with.
- * Reading it back means "not configured yet", never a credential — the value is
+ * Reading it back means "not configured yet", never a credential—the value is
  * deliberately loud so it is obvious in a Secrets Store listing or a log line.
  *
  * It matches the sentinel `louise-toolkit`'s Turnstile gate already recognizes,
@@ -33,7 +33,7 @@ import { readSecret } from "louise-toolkit/security";
 export const ASTROID_SECRET_PLACEHOLDER = "DUMMY_REPLACE_ME";
 /**
  * Read one secret under the Astroid convention: `null` unless it holds a real,
- * non-placeholder value. Thin by design — the reason to call this rather than
+ * non-placeholder value. Thin by design—the reason to call this rather than
  * `readSecret` directly is that it binds Astroid's sentinel for you.
  */
 export function readModuleSecret(source) {
@@ -68,10 +68,10 @@ export async function resolveModuleSecrets(sources) {
     return { configured: missing.length === 0, values, missing };
 }
 /**
- * A one-line, human-readable status for a module — what `astroid doctor`, a dev
+ * A one-line, human-readable status for a module—what `astroid doctor`, a dev
  * server banner, or a health endpoint should print. Naming the missing secrets
  * is the whole point: "commerce is off" sends someone reading source, "commerce
- * is dormant — set SQUARE_ACCESS_TOKEN" does not.
+ * is dormant—set SQUARE_ACCESS_TOKEN" does not.
  */
 export function describeModuleStatus(module, status) {
     if (status.configured)

package/dist/security/csp-origins.d.ts

@@ -11,6 +11,6 @@ export declare function astroidCspOrigins(config: AstroidConfig): Required<CspOr
  * `'unsafe-inline'` is required (Louise's data-driven `style=""` carriers and
  * the editor's runtime `<style>`), which is why Astro can't own this directive:
  * per spec a single hash here voids `'unsafe-inline'`. Module and config
- * `style` origins ride along, e.g. the Square SDK's own stylesheet.
+ * `style` origins ride along, for example, the Square SDK's own stylesheet.
  */
 export declare function astroidCspStyleSrc(config: AstroidConfig): string;

package/dist/security/csp-origins.js

@@ -31,11 +31,11 @@ const COMMERCE_ORIGINS = {
 };
 // Turnstile. Always allowed, not gated on the captcha being configured: the
 // scaffold ships the widget dormant (see the dormant-until-provisioned
-// convention) and it must not need a rebuild to switch on — CSP is baked at
+// convention) and it must not need a rebuild to switch on—CSP is baked at
 // build time, the secret is a runtime value.
 const TURNSTILE = turnstileCsp();
 // The map module. MapLibre spins its tile-decoding workers up from blob: URLs,
-// so `worker-src blob:` is not optional — without it the map renders an empty
+// so `worker-src blob:` is not optional—without it the map renders an empty
 // canvas and the console fills with worker-construction errors.
 //
 // Nothing else is needed, and that's the whole argument for the self-hosted
@@ -69,7 +69,7 @@ export function astroidCspOrigins(config) {
  * `'unsafe-inline'` is required (Louise's data-driven `style=""` carriers and
  * the editor's runtime `<style>`), which is why Astro can't own this directive:
  * per spec a single hash here voids `'unsafe-inline'`. Module and config
- * `style` origins ride along, e.g. the Square SDK's own stylesheet.
+ * `style` origins ride along, for example, the Square SDK's own stylesheet.
  */
 export function astroidCspStyleSrc(config) {
     return ["'self'", "'unsafe-inline'", ...astroidCspOrigins(config).style].join(" ");

package/dist/security/rate-rules.d.ts

@@ -2,7 +2,7 @@ import type { RateRule } from "louise-toolkit/security";
 import type { AstroidConfig } from "../config.js";
 export type { RateRule };
 /**
- * Base path the customer/portal Better Auth instance mounts at — its own
+ * Base path the customer/portal Better Auth instance mounts at—its own
  * handler, separate from the editor's `/api/auth`. Fixed by Astroid so the rate
  * rules, the middleware, and the portal routes can't drift apart.
  */
@@ -15,7 +15,7 @@ export declare const ASTROID_CHECKOUT_PATH = "/api/checkout";
  * checkout when commerce is configured.
  *
  * Rules are matched first-wins, and `security.rateRules` from the config are
- * placed FIRST — so a site tightens or loosens any default by declaring its own
+ * placed FIRST—so a site tightens or loosens any default by declaring its own
  * rule for that path, rather than losing the whole set to override one budget.
  */
 export declare function astroidRateRules(config: AstroidConfig): RateRule[];

package/dist/security/rate-rules.js

@@ -5,26 +5,26 @@
 // The limiter mechanism lives in `louise-toolkit/security` and is deliberately
 // unopinionated: which routes, and which budgets, are policy. But the policy
 // turned out not to vary. All three consuming sites independently wrote the same
-// `RateRule[]` — the same public POST surfaces, the same 10-minute windows,
-// budgets within a factor of one of each other — differing only where the site
+// `RateRule[]`—the same public POST surfaces, the same 10-minute windows,
+// budgets within a factor of one of each other—differing only where the site
 // had a surface the others didn't (a portal, a checkout). That is a default, not
 // a per-site decision, so Astroid derives the whole set from the config.
 //
 // What's in scope: the public, UNAUTHENTICATED POST surfaces. Editor endpoints
-// (`/api/louise/*`) are session-gated and stay out on purpose — a limiter that
+// (`/api/louise/*`) are session-gated and stay out on purpose—a limiter that
 // can lock the owner out of their own studio is worse than the abuse it stops.
 // The contact form is also absent by design: it's a worker route with its own
 // per-form limiter, and worker routes are matched before Astro's middleware ever
 // runs, so a rule here would never fire.
 /**
- * Base path the customer/portal Better Auth instance mounts at — its own
+ * Base path the customer/portal Better Auth instance mounts at—its own
  * handler, separate from the editor's `/api/auth`. Fixed by Astroid so the rate
  * rules, the middleware, and the portal routes can't drift apart.
  */
 export const ASTROID_PORTAL_BASE_PATH = "/api/portal-auth";
 /** Path the commerce module's checkout POSTs to. */
 export const ASTROID_CHECKOUT_PATH = "/api/checkout";
-/** Ten minutes. Every default budget uses this window — long enough that a
+/** Ten minutes. Every default budget uses this window—long enough that a
  *  burst can't wait it out, short enough that a false positive self-heals. */
 const WINDOW = 600;
 const exact = (path) => (p) => p === path;
@@ -34,7 +34,7 @@ const exact = (path) => (p) => p === path;
  * checkout when commerce is configured.
  *
  * Rules are matched first-wins, and `security.rateRules` from the config are
- * placed FIRST — so a site tightens or loosens any default by declaring its own
+ * placed FIRST—so a site tightens or loosens any default by declaring its own
  * rule for that path, rather than losing the whole set to override one budget.
  */
 export function astroidRateRules(config) {
@@ -62,9 +62,9 @@ export function astroidRateRules(config) {
     if (config.portal?.enabled) {
         // The portal's mount is configurable (a site may already ship a second
         // instance at its own path), so the credential-surface rules must track the
-        // resolved base path, not the default constant — mirrors `astroidPortal`.
+        // resolved base path, not the default constant—mirrors `astroidPortal`.
         const base = config.portal.basePath ?? ASTROID_PORTAL_BASE_PATH;
-        // Customer credentials, unlike the editor's, are password-based — so these
+        // Customer credentials, unlike the editor's, are password-based—so these
         // guard credential stuffing and enumeration, not just mail volume.
         rules.push({
             name: "portal-signup",

package/dist/seo/resolve.d.ts

@@ -8,7 +8,7 @@ export interface AstroidSeoSettings {
     tagline?: string | null;
     metaDescription?: string | null;
     defaultOgImageUrl?: string | null;
-    /** Site-wide kill switch — noindex every page (staging, pre-launch). */
+    /** Site-wide kill switch—noindex every page (staging, pre-launch). */
     disableIndexing?: boolean | null;
 }
 /** Per-page SEO: an editor's overrides, or a built-in page's own defaults. */
@@ -24,7 +24,7 @@ export interface PageSeoInput {
     noindex?: boolean | null;
 }
 export interface AstroidSeoOptions {
-    /** Canonical URL of the page being rendered — absolute. */
+    /** Canonical URL of the page being rendered—absolute. */
     canonical: string;
     /**
      * Title template, `%s` standing in for the page title. Applied ONLY when the
@@ -33,15 +33,15 @@ export interface AstroidSeoOptions {
     titleTemplate?: string;
     /** `@<handle>` for Twitter/X card attribution. */
     twitterHandle?: string;
-    /** OG locale, e.g. `"en_US"`. */
+    /** OG locale, for example, `"en_US"`. */
     locale?: string;
 }
 /** Everything a `<head>` needs, fully resolved and absolute. */
 export interface ResolvedSeo {
-    /** Final `<title>` — templated when the page supplied one. */
+    /** Final `<title>`—templated when the page supplied one. */
     title: string;
     /** Untemplated page title, for OG/Twitter (which shouldn't carry the site
-     *  suffix twice — the OG `site_name` already says it). */
+     *  suffix twice—the OG `site_name` already says it). */
     bareTitle: string;
     description?: string;
     canonical: string;

package/dist/seo/resolve.js

@@ -1,6 +1,6 @@
 // Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
 //
-// SEO resolution — settings defaults + per-page overrides, collapsed into the
+// SEO resolution—settings defaults + per-page overrides, collapsed into the
 // exact set of values a `<head>` needs.
 //
 // Both sites that hand-built this layer converged on the same three-level
@@ -14,7 +14,7 @@
 // Kept as a pure function rather than baked into the component so it can be
 // unit-tested, and so a route that isn't rendering a page (an OG-image endpoint,
 // a feed) can resolve the same values.
-/** Trimmed value, or undefined — an empty/whitespace string counts as unset. */
+/** Trimmed value, or undefined—an empty/whitespace string counts as unset. */
 const clean = (value) => {
     const trimmed = value?.trim();
     return trimmed ? trimmed : undefined;

package/dist/seo/routes.d.ts

@@ -4,14 +4,14 @@ import type { AstroidConfig } from "../config.js";
  * API always, plus the portal's account + auth surfaces and checkout when those
  * are enabled.
  *
- * These are *prefixes* — `robots.txt` matches by prefix, so `/api/` covers every
+ * These are *prefixes*—`robots.txt` matches by prefix, so `/api/` covers every
  * endpoint beneath it.
  */
 export declare function astroidNoindexPaths(config: AstroidConfig): string[];
 export interface RobotsOptions {
-    /** Serving origin, e.g. `new URL(request.url).origin`. */
+    /** Serving origin, for example, `new URL(request.url).origin`. */
     origin: string;
-    /** Paths to disallow — defaults to {@link astroidNoindexPaths}. */
+    /** Paths to disallow—defaults to {@link astroidNoindexPaths}. */
     disallow?: string[];
     /**
      * Disallow the entire site. Pass `settings.disableIndexing` so the same
@@ -25,7 +25,7 @@ export declare function astroidRobotsTxt(config: AstroidConfig, options: RobotsO
 export interface SitemapEntry {
     /** Site-root-relative path (`"/shop/beans"`) or an absolute URL. */
     path: string;
-    /** Last modified — a Date or an ISO string. */
+    /** Last modified—a Date or an ISO string. */
     lastmod?: Date | string;
 }
 export interface SitemapOptions {
@@ -38,7 +38,7 @@ export interface SitemapOptions {
  *
  * Entries are de-duplicated and sorted (a stable document diffs cleanly and
  * caches predictably), excluded paths are dropped by prefix, and every `loc` is
- * XML-escaped — a slug containing `&` would otherwise produce a malformed
+ * XML-escaped—a slug containing `&` would otherwise produce a malformed
  * document that search engines reject wholesale.
  */
 export declare function astroidSitemapXml(config: AstroidConfig, entries: (SitemapEntry | string)[], options: SitemapOptions): string;

package/dist/seo/routes.js

@@ -18,7 +18,7 @@ import { ASTROID_PORTAL_BASE_PATH } from "../security/rate-rules.js";
  * API always, plus the portal's account + auth surfaces and checkout when those
  * are enabled.
  *
- * These are *prefixes* — `robots.txt` matches by prefix, so `/api/` covers every
+ * These are *prefixes*—`robots.txt` matches by prefix, so `/api/` covers every
  * endpoint beneath it.
  */
 export function astroidNoindexPaths(config) {
@@ -32,7 +32,7 @@ export function astroidNoindexPaths(config) {
         paths.push(ASTROID_PORTAL_BASE_PATH, "/account", "/login", "/register", "/reset-password");
     }
     if (config.commerce) {
-        // The checkout PAGE, not `ASTROID_CHECKOUT_PATH` — that's the POST endpoint,
+        // The checkout PAGE, not `ASTROID_CHECKOUT_PATH`—that's the POST endpoint,
         // already covered by the `/api/` prefix. What a crawler would actually reach
         // is the UI route.
         paths.push("/checkout", "/cart");
@@ -68,7 +68,7 @@ const escapeXml = (value) => value.replace(/[&<>"']/g, (c) => XML_ESCAPES[c] ??
  *
  * Entries are de-duplicated and sorted (a stable document diffs cleanly and
  * caches predictably), excluded paths are dropped by prefix, and every `loc` is
- * XML-escaped — a slug containing `&` would otherwise produce a malformed
+ * XML-escaped—a slug containing `&` would otherwise produce a malformed
  * document that search engines reject wholesale.
  */
 export function astroidSitemapXml(config, entries, options) {

package/dist/seo/structured-data.d.ts

@@ -6,7 +6,7 @@ export type JsonLdNode = Record<string, unknown>;
  * The schema.org `@type` each archetype describes its owner with. These are
  * intentionally the broad parent types: pick a subtype (`CafeOrCoffeeShop`,
  * `ArtGallery`, `HomeAndConstructionBusiness`) via `seo.businessType` when you
- * know one — a more specific type is strictly better for rich results.
+ * know one—a more specific type is strictly better for rich results.
  */
 export declare const ARCHETYPE_BUSINESS_TYPE: Record<Archetype, string>;
 export interface StructuredDataInput {
@@ -22,7 +22,7 @@ export interface StructuredDataInput {
     /** Absolute origin serving this page (the canonical host). */
     siteUrl: string;
     /**
-     * An extra node for the thing this page is *about* — a Product, a
+     * An extra node for the thing this page is *about*—a Product, a
      * VisualArtwork, an Article. Joined into the same `@graph` so crawlers see
      * one connected description rather than three unrelated blobs.
      */
@@ -32,8 +32,8 @@ export interface StructuredDataInput {
  * Build the JSON-LD `@graph` for a page: the business node, a `WebSite` node,
  * and the page's own entity when there is one.
  *
- * The business gets a stable `@id` (`<origin>/#business`) so other nodes — a
- * product's `seller`, a future `Article` author — can reference it by id
+ * The business gets a stable `@id` (`<origin>/#business`) so other nodes—a
+ * product's `seller`, a future `Article` author—can reference it by id
  * instead of restating it.
  */
 export declare function astroidStructuredData(input: StructuredDataInput): JsonLdNode;
@@ -42,8 +42,8 @@ export declare function astroidStructuredData(input: StructuredDataInput): JsonL
  *
  * `application/ld+json` is data, not executable script, so `script-src` doesn't
  * govern it and no CSP hash is needed. But `JSON.stringify` does **not** escape
- * `<`, so any value folded into the graph that contains a literal `</script>` —
- * a product description, an artist statement, anything editor-authored — would
+ * `<`, so any value folded into the graph that contains a literal `</script>`—a
+ * product description, an artist statement, anything editor-authored—would
  * close the tag early and inject markup straight into `<head>`. Escaping the
  * HTML-significant characters as `\uXXXX` keeps the payload valid JSON while
  * making it impossible to break out of the element.