@sonordev/contracts 1.0.0 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,81 @@
 # Changelog
 
+## 2.1.0
+
+A minor release: one new entry, `@sonordev/contracts/voice`. Every other entry is unchanged.
+
+- **New entry `@sonordev/contracts/voice`**: the house voice's contraction rule, so every app that checks or rewrites copy agrees on it.
+  - `findUncontracted(text, options?)` finds full forms that should be
+    contractions ("do not" to "don't", "it is" to "it's", "let us look" to
+    "let's look") and returns each one with its position, the matched text and
+    the suggestion, first-letter case kept.
+  - It leaves alone what can't contract where it stands: a clause-final "it
+    is" or "we are" (negations skip that guard, so "We do not." still becomes
+    "We don't."), "what it is and why", "can not only", a "what is" question, a
+    heading that opens with "What Is" (when `titleLike` is set), and "let us
+    know" and "let us help". "let us" only contracts at the start of a sentence and
+    before look, start, begin, consider, turn, see, review, compare, break,
+    dig, recap, unpack, explore, examine, revisit, focus, go, talk, move, "get
+    started", "step back" or "zoom out". "have" and "has" on their own are
+    never touched, though "have not" and "has not" still contract.
+  - `contractText(text, options?)` applies those findings and returns the new
+    text.
+  - `findContracted(text, options?)` is the reverse rule for question-form
+    headings and FAQ questions: it finds contractions ("What's") and suggests
+    the full form ("What is").
+  - `VOICE_MASK` is the one character that stands in for text the rule must
+    not touch.
+- **Options**: `titleLike` marks a heading or title. `protectedRanges` takes
+  half-open `[start, end)` ranges (code, quotations, link destinations) that
+  are never rewritten and never read as a clause end, except a protected line
+  break, which still ends its line. An infinite bound means
+  "from the start" or "to the end". A malformed range (NaN, not a number,
+  start after end), or a truthy value that isn't an array, protects the whole
+  text, so a bad range can never cause code to be rewritten.
+- **Lines**: multi-line text is read one line at a time. Nothing matches
+  across a line break, and the end of a line ends a clause. A "\r" before a
+  "\n" or at the very end of the text is part of the line ending. Hits carry
+  offsets into the whole string.
+- **Known limits**: the rule is deliberately plain. "must not only" and "will
+  not only" contract, "need not" contracts even where "need" is a noun, "let
+  us" is read by its position and next word rather than its meaning, a
+  decimal, a domain or an initial hides a "what is" question, a straight
+  apostrophe doesn't end a clause, only spaces and tabs join the words of a
+  pair, all-caps input gets a mixed-case suggestion, and `findContracted`
+  always expands "'s" to "is" and "'d" to "would" and expands "ain't" like any
+  other "n't" word ("ai not"). The README lists each one with an example.
+- Anything that isn't a string is read as no text, so a stray number or object
+  can't throw.
+- No new dependencies, and CommonJS and ESM builds like every other entry.
+
+## 2.0.0
+
+A major for one entry, `slots`, plus three new entries; every other entry is unchanged.
+
+- **Slots contract v2**: `rich`, `link` and `list` content types beside
+  `text`, with a structured `value` that the signature now covers.
+  `SLOTS_CONTRACT_VERSION` is 2 and `signSlotContent` / `verifySlotContent`
+  default to v2. Pass `1` as the version to keep signing and verifying the
+  pre-v2 text-only form, which older site-kit releases verify.
+- **`normalizeSlotValue(type, { content, value })`**: the one rule for what
+  a valid slot of each type is, returning the canonical content and value to
+  store and sign.
+- **`parseSlotRichText(markdown)`**: the rich-text subset (paragraphs, line
+  breaks, bold, italic, safe links, lists) as a small AST to render as
+  elements, never HTML.
+- **New entry `@sonordev/contracts/slot-content`**: the pure half of the
+  slots contract (types, `normalizeSlotValue`, `isSafeSlotHref`,
+  `parseSlotRichText`) with no `crypto`, so a browser can import it.
+  `slots` re-exports all of it.
+- **New entry `@sonordev/contracts/site-cache`**: how Sonor refreshes a
+  site's cached pages. `SITE_CACHE_TAGS` (the tag names site-kit's fetches
+  carry and sonor-api expires), `SITE_REVALIDATE_PATH`, the webhook payload
+  and its `ping`, and `isSiteRevalidatePong`.
+- **New entry `@sonordev/contracts/site-edit`**: Sonor's Edit on page. The
+  messages between a framed site and the dashboard, which origins may drive
+  the overlay (`isSonorAppOrigin`), and `slotNeedles`, the visible text used
+  to find a slot on the page.
+
 ## 1.0.0
 
 First release. The rules site-kit 6.x published as `@sonordev/site-kit/*/contract`

package/README.md

@@ -17,8 +17,123 @@ pnpm add @sonordev/contracts
 | `@sonordev/contracts/llms` | llms.txt sanitizers and contract version | site-kit, sonor-api, Signal's schema validation |
 | `@sonordev/contracts/forms` | The honeypot policy | site-kit forms, sonor-api intake |
 | `@sonordev/contracts/fleet` | The fleet heartbeat's wire shape | site-kit, sonor-api |
-| `@sonordev/contracts/slots` | Slot payload signing (HMAC; Node only) | sonor-api, site-kit on the server |
+| `@sonordev/contracts/slots` | Slot payload signing, contract v2 (HMAC; Node only). Signs and verifies v1 for older site-kit releases | sonor-api, site-kit on the server |
+| `@sonordev/contracts/slot-content` | What a slot of each kind may hold (`normalizeSlotValue`), safe links, the rich-text parser. No `crypto`, so browsers can import it | sonor-api, site-kit, the dashboard editor |
+| `@sonordev/contracts/site-cache` | The cache tags a site's Sonor fetches carry and the revalidation route's path, payload and ping | site-kit tags and serves the route, sonor-api calls it |
+| `@sonordev/contracts/site-edit` | Edit on page: the messages between a framed site and the dashboard, trusted origins, how a slot is found on the page | site-kit's overlay, the dashboard's visual editor |
 | `@sonordev/contracts/portfolio` | Where a portfolio number comes from and which may headline; the live-frame message | sonor-api, Signal, agency-site-kit |
+| `@sonordev/contracts/voice` | The house voice's contraction rule. `findUncontracted` and `contractText` find and apply full forms that should be contractions; `findContracted` finds the contractions a question-form heading should expand | anything that checks or rewrites copy: Sonor's APIs and dashboard |
+
+## The voice contract
+
+`voice` is the contraction rule for written copy, so every app that checks or
+rewrites it agrees. It's the rule Sonor's article checker has always applied,
+moved here so it exists once.
+
+- **What it finds.** Full forms that should be contractions: "do not" becomes
+  "don't", "it is" becomes "it's", "let us look" becomes "let's look". The
+  first letter's case is kept ("DO NOT" gives "Don't"), and the suggestion
+  always uses a straight apostrophe. There are 36 pairs, and a negation wins
+  an overlap ("we would not" gives "we wouldn't", not "we'd not").
+- **What it leaves alone.** A pronoun and verb ("it is", "we are", "you will")
+  at the end of a clause ("until it is."), or before "and", "or", "but" or
+  "nor" ("what it is and why"). Negations skip that guard: "We do not." still
+  becomes "We don't.". "can not" before "only" ("it can not only save time").
+  "what is" when the next ".", "!" or "?" after it turns out to be a "?", and
+  "What Is" at the start of a line when you mark the text as a heading.
+  "let us" unless it starts a sentence and the next word is one of
+  look, start, begin, consider, turn, see, review, compare, break, dig, recap,
+  unpack, explore, examine, revisit, focus, go, talk, move, "get started",
+  "step back" or "zoom out" ("let us know" and "let us help" mean "allow us").
+  "have" and "has" on their own ("we have a team") are never touched, though
+  "have not" and "has not" still contract ("haven't", "hasn't").
+- **Lines.** Text is read one line at a time: split on "\n". A "\r" right
+  before a "\n", or at the very end of the text, is part of the line ending;
+  any other "\r" is ordinary text. If you've already split the text into lines
+  yourself and a line keeps a final "\r" you want read as text, replace it with
+  `VOICE_MASK` first.
+  Nothing matches across a line break, and the end of a line ends a clause.
+  Every hit's `index` is an offset into the whole string you passed in.
+- **The other direction.** `findContracted` finds the contractions a
+  question-form heading or FAQ question should spell out ("What's" becomes
+  "What is"). It only reports; whether a text is a
+  question is the caller's call, and a caller shouldn't apply these blindly.
+
+What the caller does:
+
+- **Mask what isn't prose.** Code, quotations and link destinations shouldn't
+  be rewritten. Pass their `[start, end)` positions as `protectedRanges`, or
+  replace them with `VOICE_MASK` yourself. Every protected character is masked
+  except "\n" and "\r", which stay as they are, so a protected line break still
+  ends its line. A masked span separates
+  words, can't sit inside a phrase, and counts as text that follows. Ranges
+  can arrive in any order, and overlap or touch. An infinite bound clamps to
+  the start or end of the text, and an empty or out-of-text range is ignored.
+  A malformed range (NaN, not a number, start after end), or a truthy value
+  that isn't an array, protects the whole text, so a bad range never causes
+  code to be rewritten. A falsy value means no ranges.
+- **Pass a string.** Anything else (a number, an object, `null`) is read as no
+  text: nothing is found and `contractText` hands it back unchanged.
+- **Pass a bare heading.** Set `titleLike` for a heading or title, with the `#`
+  and list markers already blanked to spaces.
+
+```ts
+import { contractText, findUncontracted } from '@sonordev/contracts/voice'
+
+contractText('We do not ship on Sundays.')
+// "We don't ship on Sundays."
+
+findUncontracted('We do not ship on Sundays.')
+// [{ index: 3, length: 6, match: 'do not', suggestion: "don't" }]
+```
+
+### Known limits
+
+The rule is plain on purpose, and these are what it does today. Each one is
+pinned by a test, so changing it later is a visible change.
+
+- **"not" before "only".** Only "can not only" stays full. "You must not only
+  wait" becomes "You mustn't only wait", "will not only rise" becomes "won't
+  only rise", and "cannot only" becomes "can't only", which reads differently.
+- **"need" as a noun.** "The need not being met" becomes "The needn't being
+  met", and "must not" and "need not" contract wherever they appear.
+- **"let us" by position, not meaning.** "Let us look at your account, please"
+  becomes "Let's look at your account, please". "Let us try again", "let us
+  walk through the plan" and any sentence that opens with a bracket, a quote
+  or a dash ("(Let us look at it.)") stay full.
+- **Question detection is the first "." "!" or "?" on the line.** A decimal, a
+  domain or an initial hides the "?": "what is 3.5 percent?" becomes "what's
+  3.5 percent?". Only "what is" has a question guard: "Who is on the team?"
+  becomes "Who's on the team?". A question that wraps onto the next line isn't
+  seen.
+- **A line break ends a clause.** In a hard-wrapped paragraph, "we think it is"
+  at the end of a line stays full.
+- **A clause end is an inventory of characters.** ".", ",", ";", ":", "!", "?",
+  ")", "]", "}", a straight double quote, a curly closing double or single
+  quote, an ellipsis, an em dash, an en dash and "-" end a clause; a straight
+  apostrophe doesn't, so "Say 'it is' now." becomes "Say 'it's' now.", and a
+  hyphen inside a word counts ("it is-fine" stays full).
+- **A masked "]" reads as text that follows.** A link whose anchor text ends a
+  clause is contracted when you protect the whole "](destination)": "Meet [who
+  we are](/about)." becomes "Meet [who we're](/about).".
+- **Only spaces and tabs join the words of a pair.** A non-breaking space
+  between "do" and "not", or a line break, keeps the pair from matching.
+- **The other direction is plain suffix rules.** `findContracted` always
+  expands "'s" to "is" ("It's been" suggests "It is", not "It has"), "'d" to
+  "would" ("She'd left" suggests "She would", not "She had"), and "ain't"
+  like any other "n't" word ("ai not"). Only the first letter's case carries
+  over ("WHY IT'S" suggests "IT is"). Treat its suggestions as prompts for a
+  person, not as edits to apply.
+- **Case.** Only the first letter's case carries over: "IT IS FINE." becomes
+  "It's FINE.".
+- **The heading rule is first-on-the-line.** "What Is" keeps its form only
+  when nothing but spaces, "*", "_" and masked text comes before it on its
+  line, and only when `titleLike` is set and the markers are already blanked.
+  The check is on the "what is" pair in any case, so "what is local seo" is
+  kept too.
+- **"let us" opens a sentence after a full stop, "!", "?" or ":".** Spaces,
+  "*", "_" and masked text before it are skipped, so "Now: let us look at it."
+  contracts.
 
 ## Why it exists
 
@@ -34,7 +149,7 @@ for everyone else.
 CommonJS and ESM both. `require('@sonordev/contracts/website')` works in a
 CommonJS Nest API (including `moduleResolution: "node"`, through
 `typesVersions`); `import` works everywhere else. `slots` imports Node's
-`crypto`, so keep it out of browser code.
+`crypto`, so keep it out of browser code; browser code reads `slot-content`.
 
 ## Changing a rule
 

package/dist/site-cache.d.ts

@@ -0,0 +1,55 @@
+/**
+ * How Sonor refreshes a site's cached pages when content changes.
+ *
+ * A site serves cached pages and caches every fetch from Sonor. When someone
+ * edits content in Sonor, sonor-api POSTs the paths and cache tags that
+ * changed to the site's revalidation route, authenticated with the project's
+ * API key, and the site regenerates just those. site-kit tags its fetches with
+ * these names and serves the route (`@sonordev/site-kit/revalidate`);
+ * sonor-api sends them. Single source of truth for the names on both sides:
+ * never spell a tag as a string literal in either.
+ */
+/** Where the revalidation route lives on every site. */
+export declare const SITE_REVALIDATE_PATH = "/api/seo-revalidate";
+/**
+ * One tag per kind of content Sonor serves, so an edit refreshes only the
+ * fetches it touched. The values predate this file (sites and
+ * agency-site-kit already expire them), so they never change.
+ */
+export declare const SITE_CACHE_TAGS: {
+    /** Managed copy (slots). */
+    readonly slots: 'sonor-slots';
+    /** Managed metadata, schema and FAQs. */
+    readonly seo: 'seo';
+    /** The publication: articles, their lists and feeds. */
+    readonly articles: 'blog';
+    /** Article categories and tags. */
+    readonly taxonomy: 'editorial-taxonomy';
+    /** Portfolio items (agency-site-kit). */
+    readonly portfolio: 'portfolio';
+};
+export type SiteCacheTag = (typeof SITE_CACHE_TAGS)[keyof typeof SITE_CACHE_TAGS];
+/** The body sonor-api POSTs to the revalidation route. */
+export interface SiteRevalidatePayload {
+    /** Local paths to regenerate, e.g. `['/services/roofing']`. */
+    paths?: string[];
+    /** Cache tags to expire (see SITE_CACHE_TAGS). */
+    tags?: string[];
+    /** Regenerate every page. */
+    revalidateAll?: boolean;
+    /**
+     * Only check that the route is installed and the key matches; nothing is
+     * regenerated. sonor-api pings after it registers a site's route, so it
+     * knows whether an edit goes live in seconds or waits for the cache to age out.
+     */
+    ping?: boolean;
+}
+/** What the route answers a ping with. */
+export interface SiteRevalidatePong {
+    ok: true;
+    ping: true;
+    /** The site-kit version serving the route. */
+    version?: string;
+}
+/** True when a response body is a pong from the revalidation route. */
+export declare function isSiteRevalidatePong(body: unknown): body is SiteRevalidatePong;

package/dist/site-cache.js

@@ -0,0 +1,23 @@
+'use strict';
+
+// src/contracts/site-cache.ts
+var SITE_REVALIDATE_PATH = "/api/seo-revalidate";
+var SITE_CACHE_TAGS = {
+  /** Managed copy (slots). */
+  slots: "sonor-slots",
+  /** Managed metadata, schema and FAQs. */
+  seo: "seo",
+  /** The publication: articles, their lists and feeds. */
+  articles: "blog",
+  /** Article categories and tags. */
+  taxonomy: "editorial-taxonomy",
+  /** Portfolio items (agency-site-kit). */
+  portfolio: "portfolio"
+};
+function isSiteRevalidatePong(body) {
+  return typeof body === "object" && body !== null && body.ok === true && body.ping === true;
+}
+
+exports.SITE_CACHE_TAGS = SITE_CACHE_TAGS;
+exports.SITE_REVALIDATE_PATH = SITE_REVALIDATE_PATH;
+exports.isSiteRevalidatePong = isSiteRevalidatePong;

package/dist/site-cache.mjs

@@ -0,0 +1,19 @@
+// src/contracts/site-cache.ts
+var SITE_REVALIDATE_PATH = "/api/seo-revalidate";
+var SITE_CACHE_TAGS = {
+  /** Managed copy (slots). */
+  slots: "sonor-slots",
+  /** Managed metadata, schema and FAQs. */
+  seo: "seo",
+  /** The publication: articles, their lists and feeds. */
+  articles: "blog",
+  /** Article categories and tags. */
+  taxonomy: "editorial-taxonomy",
+  /** Portfolio items (agency-site-kit). */
+  portfolio: "portfolio"
+};
+function isSiteRevalidatePong(body) {
+  return typeof body === "object" && body !== null && body.ok === true && body.ping === true;
+}
+
+export { SITE_CACHE_TAGS, SITE_REVALIDATE_PATH, isSiteRevalidatePong };

package/dist/site-edit-param.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The query parameter that asks a framed page to start Sonor's edit overlay.
+ * Its own file so site-kit's bridge, which runs for every visitor, imports
+ * this string and not the rest of `site-edit` (and the rich-text parser it
+ * pulls in). Published through `site-edit`.
+ */
+export declare const SITE_EDIT_PARAM = "sonor_edit";

package/dist/site-edit.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Edit on page: the messages between a site and the Sonor dashboard.
+ *
+ * The dashboard frames the live site with `?sonor_edit=1`. site-kit sees that
+ * it's framed by Sonor, finds the managed copy on the page and outlines it;
+ * a click selects a slot, and the dashboard edits it with the person's own
+ * Sonor session. Nothing on the site writes anything: it reports what's where
+ * and shows a draft in place, and the dashboard does the rest. So the site
+ * needs no login, no secret and no cookie.
+ *
+ * site-kit's overlay (`slots/edit`) and the dashboard's visual editor both
+ * read this file. Pure: no DOM, no network.
+ */
+import { type SlotContentType, type SlotValue } from './slot-content';
+export { SITE_EDIT_PARAM } from './site-edit-param';
+/** Protocol version, sent in `ready` so the dashboard can tell an old overlay. */
+export declare const SITE_EDIT_VERSION = 1;
+/** The dashboard's production origin. */
+export declare const SONOR_APP_ORIGIN = "https://app.sonor.io";
+/**
+ * Origins allowed to drive the overlay: the dashboard, and localhost for
+ * development. A localhost frame is the person's own machine; the overlay
+ * never exposes anything the framed page doesn't already show.
+ */
+export declare function isSonorAppOrigin(origin: string): boolean;
+/** What the dashboard asks the overlay to find: a slot as it's live now. */
+export interface EditableSlot {
+    /** The slot's row id in Sonor. */
+    key: string;
+    /** The slot id in code, e.g. `home-hero-headline`. */
+    id: string;
+    type: SlotContentType;
+    /** What the page shows now: the published content, else the site's fallback. */
+    content: string | null;
+    value?: SlotValue | null;
+}
+/** Dashboard → site. */
+export type SonorToSiteMessage = {
+    type: 'sonor-edit:slots';
+    slots: EditableSlot[];
+} | {
+    type: 'sonor-edit:select';
+    key: string | null;
+} | {
+    type: 'sonor-edit:preview';
+    key: string;
+    content?: string | null;
+    value?: SlotValue | null;
+} | {
+    type: 'sonor-edit:reload';
+};
+/** Site → dashboard. */
+export type SiteToSonorMessage = {
+    type: 'sonor-edit:ready';
+    version: number;
+    path: string;
+    title: string;
+} | {
+    type: 'sonor-edit:found';
+    path: string;
+    found: string[];
+} | {
+    type: 'sonor-edit:select';
+    key: string;
+};
+/** A message from the dashboard, or null for anything else (other scripts post messages too). */
+export declare function parseSonorToSiteMessage(data: unknown): SonorToSiteMessage | null;
+/** A message from the site, or null for anything else. */
+export declare function parseSiteToSonorMessage(data: unknown): SiteToSonorMessage | null;
+/** Collapse whitespace the way a browser lays text out. */
+export declare function normalizeEditText(text: string): string;
+/**
+ * The visible text the overlay looks for to find a slot on the page: the
+ * text itself, the first paragraph of rich text, a link's label, a list's
+ * item titles. Empty strings are dropped.
+ */
+export declare function slotNeedles(slot: EditableSlot): string[];

package/dist/site-edit.js

@@ -0,0 +1,179 @@
+'use strict';
+
+// src/contracts/slot-content.ts
+var SLOT_HREF_MAX_LENGTH = 2048;
+function isSafeSlotHref(href) {
+  if (typeof href !== "string") return false;
+  const h = href.trim();
+  if (!h || h.length > SLOT_HREF_MAX_LENGTH) return false;
+  if (h.startsWith("/")) return !h.startsWith("//") && !/\s/.test(h);
+  if (h.startsWith("#")) return !/\s/.test(h);
+  return /^(https?:\/\/[^\s]+|mailto:[^\s]+|tel:[+\d][\d\s().-]*)$/i.test(h);
+}
+var UL_ITEM = /^\s*[-*]\s+(.*)$/;
+var OL_ITEM = /^\s*\d+[.)]\s+(.*)$/;
+var MAX_INLINE_DEPTH = 4;
+function parseSlotRichText(markdown) {
+  const blocks = [];
+  const chunks = markdown.replace(/\r\n?/g, "\n").split(/\n\s*\n/);
+  for (const chunk of chunks) {
+    const lines = chunk.split("\n").filter((l) => l.trim() !== "");
+    if (lines.length === 0) continue;
+    if (lines.every((l) => UL_ITEM.test(l))) {
+      blocks.push({ t: "ul", items: lines.map((l) => parseInline(UL_ITEM.exec(l)[1])) });
+    } else if (lines.every((l) => OL_ITEM.test(l))) {
+      blocks.push({ t: "ol", items: lines.map((l) => parseInline(OL_ITEM.exec(l)[1])) });
+    } else {
+      const c = [];
+      lines.forEach((line, i) => {
+        if (i > 0) c.push({ t: "br" });
+        c.push(...parseInline(line.trim()));
+      });
+      blocks.push({ t: "p", c });
+    }
+  }
+  return blocks;
+}
+function parseInline(src, depth = 0) {
+  const out = [];
+  let text = "";
+  const flush = () => {
+    if (text) out.push({ t: "text", v: text });
+    text = "";
+  };
+  const nest = depth < MAX_INLINE_DEPTH;
+  let i = 0;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === "\\" && i + 1 < src.length && /[\\*_[\]()]/.test(src[i + 1])) {
+      text += src[i + 1];
+      i += 2;
+      continue;
+    }
+    if (nest && src.startsWith("**", i)) {
+      const end = src.indexOf("**", i + 2);
+      if (end > i + 2) {
+        flush();
+        out.push({ t: "strong", c: parseInline(src.slice(i + 2, end), depth + 1) });
+        i = end + 2;
+        continue;
+      }
+    }
+    if (nest && (ch === "*" || ch === "_")) {
+      const end = src.indexOf(ch, i + 1);
+      if (end > i + 1 && src[i + 1] !== " " && src[end - 1] !== " ") {
+        flush();
+        out.push({ t: "em", c: parseInline(src.slice(i + 1, end), depth + 1) });
+        i = end + 1;
+        continue;
+      }
+    }
+    if (nest && ch === "[") {
+      const close = src.indexOf("](", i + 1);
+      const end = close === -1 ? -1 : src.indexOf(")", close + 2);
+      if (close > i + 1 && end > close + 2) {
+        const href = src.slice(close + 2, end).trim();
+        if (isSafeSlotHref(href)) {
+          flush();
+          out.push({ t: "link", href, c: parseInline(src.slice(i + 1, close), depth + 1) });
+          i = end + 1;
+          continue;
+        }
+      }
+    }
+    text += ch;
+    i += 1;
+  }
+  flush();
+  return out;
+}
+
+// src/contracts/site-edit-param.ts
+var SITE_EDIT_PARAM = "sonor_edit";
+
+// src/contracts/site-edit.ts
+var SITE_EDIT_VERSION = 1;
+var SONOR_APP_ORIGIN = "https://app.sonor.io";
+function isSonorAppOrigin(origin) {
+  if (origin === SONOR_APP_ORIGIN) return true;
+  try {
+    const url = new URL(origin);
+    return url.protocol === "http:" && (url.hostname === "localhost" || url.hostname === "127.0.0.1");
+  } catch {
+    return false;
+  }
+}
+var SONOR_TO_SITE = /* @__PURE__ */ new Set(["sonor-edit:slots", "sonor-edit:select", "sonor-edit:preview", "sonor-edit:reload"]);
+var SITE_TO_SONOR = /* @__PURE__ */ new Set(["sonor-edit:ready", "sonor-edit:found", "sonor-edit:select"]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseSonorToSiteMessage(data) {
+  if (!isRecord(data) || typeof data.type !== "string" || !SONOR_TO_SITE.has(data.type)) return null;
+  switch (data.type) {
+    case "sonor-edit:slots":
+      return Array.isArray(data.slots) ? { type: data.type, slots: data.slots.filter(isEditableSlot).slice(0, 500) } : null;
+    case "sonor-edit:select":
+      return data.key === null || typeof data.key === "string" ? { type: data.type, key: data.key } : null;
+    case "sonor-edit:preview":
+      return typeof data.key === "string" ? {
+        type: data.type,
+        key: data.key,
+        ...typeof data.content === "string" || data.content === null ? { content: data.content } : {},
+        ...isRecord(data.value) || data.value === null ? { value: data.value } : {}
+      } : null;
+    default:
+      return { type: "sonor-edit:reload" };
+  }
+}
+function parseSiteToSonorMessage(data) {
+  if (!isRecord(data) || typeof data.type !== "string" || !SITE_TO_SONOR.has(data.type)) return null;
+  switch (data.type) {
+    case "sonor-edit:ready":
+      return typeof data.version === "number" && typeof data.path === "string" ? { type: data.type, version: data.version, path: data.path, title: typeof data.title === "string" ? data.title : "" } : null;
+    case "sonor-edit:found":
+      return typeof data.path === "string" && Array.isArray(data.found) ? { type: data.type, path: data.path, found: data.found.filter((k) => typeof k === "string") } : null;
+    default:
+      return typeof data.key === "string" ? { type: "sonor-edit:select", key: data.key } : null;
+  }
+}
+function isEditableSlot(value) {
+  return isRecord(value) && typeof value.key === "string" && typeof value.id === "string" && typeof value.type === "string" && (typeof value.content === "string" || value.content === null);
+}
+function normalizeEditText(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function slotNeedles(slot) {
+  const clean = (values) => values.map((v) => normalizeEditText(v ?? "")).filter((v) => v.length > 0);
+  switch (slot.type) {
+    case "link": {
+      const value = slot.value;
+      return clean([value?.label ?? slot.content]);
+    }
+    case "list": {
+      const value = slot.value;
+      const items = value?.items ?? [];
+      return items.length ? clean(items.map((item) => item.title || item.body)) : clean((slot.content ?? "").split("\n"));
+    }
+    case "rich": {
+      const first = parseSlotRichText(slot.content ?? "")[0];
+      if (!first) return [];
+      const inline = first.t === "p" ? first.c : first.items[0] ?? [];
+      return clean([inlineText(inline)]);
+    }
+    default:
+      return clean([slot.content]);
+  }
+}
+function inlineText(nodes) {
+  return nodes.map((n) => n.t === "text" ? n.v : n.t === "br" ? " " : inlineText(n.c)).join("");
+}
+
+exports.SITE_EDIT_PARAM = SITE_EDIT_PARAM;
+exports.SITE_EDIT_VERSION = SITE_EDIT_VERSION;
+exports.SONOR_APP_ORIGIN = SONOR_APP_ORIGIN;
+exports.isSonorAppOrigin = isSonorAppOrigin;
+exports.normalizeEditText = normalizeEditText;
+exports.parseSiteToSonorMessage = parseSiteToSonorMessage;
+exports.parseSonorToSiteMessage = parseSonorToSiteMessage;
+exports.slotNeedles = slotNeedles;