@graph8/sdk 0.373.0 → 0.374.0

package/blocks/inbox/lib/inbox-manage.ts

@@ -0,0 +1,227 @@
+"use client";
+
+/**
+ * Pure helpers for the inbox management parts: composing a new message, managing tags and blocked senders,
+ * server-side search, and the per-thread actions (read state, unassign, remove a tag). No SDK calls here.
+ *
+ * Several of these endpoints answer with an open `{ items: [...] }` payload (no response schema in the
+ * contract), so every reader below is defensive: it accepts a bare list, `{ items }`, or the named list the
+ * route actually uses, and skips rows it cannot make sense of.
+ */
+import type { InboxChannel, InboxTag, InboxThread } from "./inbox-types";
+import { stripHtml } from "./inbox-types";
+
+/** Rows from a bare list, `{ data: [...] }`, `{ items: [...] }` or a named list such as `{ tags: [...] }`. */
+export function rowsFrom<T = Record<string, unknown>>(payload: unknown, ...names: string[]): T[] {
+  const list = (v: unknown): T[] | null => (Array.isArray(v) ? (v as T[]) : null);
+  const direct = list(payload);
+  if (direct) return direct;
+  const obj = (payload ?? {}) as Record<string, unknown>;
+  const inner = (obj.data && typeof obj.data === "object" ? (obj.data as Record<string, unknown>) : obj) as Record<string, unknown>;
+  return list(inner) ?? list(inner.items) ?? names.map((n) => list(inner[n])).find(Boolean) ?? list(obj.items) ?? [];
+}
+
+// --- Compose ----------------------------------------------------------------------------------------------------
+
+export interface MailboxChoice {
+  /** The address the message is sent from (`from_mailbox`). */
+  address: string;
+  label: string;
+  /** False when the caller may see the mailbox but not send as it; `reason` says why. */
+  canSend: boolean;
+  reason?: string;
+}
+
+/** Sender choices from `GET /inbox/mailboxes/paginated` (rows carry `can_send` / `send_blocked_reason`). */
+export function mailboxChoices(payload: unknown): MailboxChoice[] {
+  const out: MailboxChoice[] = [];
+  const seen = new Set<string>();
+  for (const row of rowsFrom<Record<string, unknown>>(payload, "mailboxes")) {
+    const address = String(row?.mailbox ?? row?.email ?? "").trim();
+    if (!address || seen.has(address.toLowerCase())) continue;
+    seen.add(address.toLowerCase());
+    const canSend = row.can_send !== false;
+    const reason = typeof row.send_blocked_reason === "string" ? row.send_blocked_reason : undefined;
+    out.push({ address, label: address, canSend, reason: canSend ? undefined : (reason ?? "not allowed to send as this mailbox") });
+  }
+  return out;
+}
+
+const EMAIL = /^[^\s@,;<>]+@[^\s@,;<>]+\.[^\s@,;<>]+$/;
+export const isEmail = (value: string): boolean => EMAIL.test(value.trim());
+
+/** Split "a@x.com, b@y.com; c@z.com" into trimmed, de-duplicated addresses (case-insensitive). */
+export function splitAddresses(value: string): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const part of value.split(/[,;\n]/)) {
+    const v = part.trim();
+    if (v && !seen.has(v.toLowerCase())) {
+      seen.add(v.toLowerCase());
+      out.push(v);
+    }
+  }
+  return out;
+}
+
+/** A phone number the SMS route will accept: E.164 (`+` then 8 to 15 digits). */
+export const isPhone = (value: string): boolean => /^\+[1-9]\d{7,14}$/.test(value.replace(/[\s().-]/g, ""));
+export const normalizePhone = (value: string): string => value.replace(/[\s().-]/g, "");
+
+const escapeHtml = (s: string) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+/** The compose API takes an HTML body; what people type is plain text. Paragraphs become `<p>`, newlines `<br>`. */
+export function textToHtml(text: string): string {
+  return text
+    .trim()
+    .split(/\n{2,}/)
+    .map((p) => `<p>${escapeHtml(p).replace(/\n/g, "<br>")}</p>`)
+    .join("");
+}
+
+export interface EmailComposeInput {
+  from: string;
+  to: string;
+  cc?: string;
+  subject: string;
+  body: string;
+}
+
+/** What is still missing before an email may be sent, in the order the form asks for it. Empty means ready. */
+export function emailComposeProblems(input: EmailComposeInput): string[] {
+  const problems: string[] = [];
+  if (!input.from.trim()) problems.push("Choose the mailbox to send from.");
+  const to = splitAddresses(input.to);
+  if (to.length === 0) problems.push("Add at least one recipient.");
+  else if (to.some((a) => !isEmail(a))) problems.push("One of the recipient addresses is not valid.");
+  if (splitAddresses(input.cc ?? "").some((a) => !isEmail(a))) problems.push("One of the Cc addresses is not valid.");
+  if (!input.subject.trim()) problems.push("Add a subject.");
+  if (!input.body.trim()) problems.push("Write the message.");
+  return problems;
+}
+
+export interface SmsComposeInput {
+  from: string;
+  to: string;
+  body: string;
+}
+
+export function smsComposeProblems(input: SmsComposeInput): string[] {
+  const problems: string[] = [];
+  if (!input.from.trim()) problems.push("Choose the number to text from.");
+  if (!input.to.trim()) problems.push("Add the phone number to text.");
+  else if (!isPhone(input.to)) problems.push("Use the full number with country code, for example +14155550100.");
+  if (!input.body.trim()) problems.push("Write the message.");
+  return problems;
+}
+
+// --- Tags -------------------------------------------------------------------------------------------------------
+
+export interface ManagedTag {
+  id: string;
+  name: string;
+  description: string;
+  color: string;
+  /** Built-in tags: "system" cannot be edited or deleted, "sdr_ai" cannot be renamed or deleted. */
+  policy: "system" | "sdr_ai" | "user";
+}
+
+/** Tags from `GET /workflows/inbox-tags` (`{ tags: [...], total }`, with or without an envelope). */
+export function managedTags(payload: unknown): ManagedTag[] {
+  const out: ManagedTag[] = [];
+  for (const row of rowsFrom<Record<string, unknown>>(payload, "tags")) {
+    const id = row?.id == null ? "" : String(row.id);
+    if (!id) continue;
+    const policy = row.policy === "system" || row.policy === "sdr_ai" || row.is_system === true ? (row.policy === "sdr_ai" ? "sdr_ai" : "system") : "user";
+    out.push({ id, name: String(row.name ?? id), description: String(row.description ?? ""), color: String(row.color ?? ""), policy });
+  }
+  return out;
+}
+
+export const asInboxTags = (tags: ManagedTag[]): InboxTag[] => tags.map((t) => ({ id: t.id, name: t.name }));
+
+export const canEditTag = (tag: ManagedTag): boolean => tag.policy !== "system";
+export const canRenameTag = (tag: ManagedTag): boolean => tag.policy === "user";
+export const canDeleteTag = (tag: ManagedTag): boolean => tag.policy === "user";
+
+/** Only the fields that changed, for `PUT /inbox/tags/{id}` (which writes exactly what it is sent). */
+export function tagChanges(
+  loaded: Pick<ManagedTag, "name" | "description" | "color">,
+  draft: { name: string; description: string; color: string },
+): Record<string, string> {
+  const out: Record<string, string> = {};
+  if (draft.name.trim() !== loaded.name) out.name = draft.name.trim();
+  if (draft.description.trim() !== loaded.description) out.description = draft.description.trim();
+  if (draft.color.trim() !== loaded.color) out.color = draft.color.trim();
+  return out;
+}
+
+export const isHexColor = (v: string): boolean => v === "" || /^#[0-9a-f]{6}$/i.test(v.trim());
+
+// --- Blocked senders --------------------------------------------------------------------------------------------
+
+export interface BlockedSender {
+  id: string;
+  email: string;
+  mailbox: string;
+  reason: string;
+}
+
+export function blockedSenders(payload: unknown): BlockedSender[] {
+  const out: BlockedSender[] = [];
+  for (const row of rowsFrom<Record<string, unknown>>(payload, "blocked_senders", "senders")) {
+    const id = row?.id == null ? "" : String(row.id);
+    const email = String(row?.sender_email ?? row?.email ?? "");
+    if (id && email) out.push({ id, email, mailbox: String(row.mailbox ?? ""), reason: String(row.reason ?? "") });
+  }
+  return out;
+}
+
+// --- Per-thread actions -----------------------------------------------------------------------------------------
+
+/** The `channel_type` the `/inbox/channels/{id}/...` routes use for a thread of this channel. */
+export function channelTypeOf(channel: InboxChannel | string): "email" | "sms" | "heyreach" {
+  return channel === "sms" ? "sms" : channel === "linkedin" ? "heyreach" : "email";
+}
+
+/** Marking a thread unread exists only for LinkedIn; email and SMS can only be marked read. */
+export const canMarkUnread = (thread: Pick<InboxThread, "channel" | "linkedin_account_id">): boolean =>
+  thread.channel === "linkedin" && thread.linkedin_account_id != null;
+
+/** Can this thread be marked read at all? (LinkedIn needs its account id for the route.) */
+export const canMarkRead = (thread: Pick<InboxThread, "channel" | "linkedin_account_id">): boolean =>
+  thread.channel !== "linkedin" || thread.linkedin_account_id != null;
+
+// --- Server-side search -----------------------------------------------------------------------------------------
+
+export interface SearchHit {
+  id: string;
+  channel: "email" | "linkedin";
+  title: string;
+  subtitle: string;
+  preview: string;
+  when?: string;
+}
+
+const str = (v: unknown): string => (typeof v === "string" ? v : "");
+
+/** A search result row (email thread or LinkedIn conversation) as a list entry. Null when it has no usable id. */
+export function searchHit(channel: "email" | "linkedin", row: Record<string, unknown>): SearchHit | null {
+  const id = row.id ?? row.email_id ?? row.thread_id ?? row.conversation_id ?? row.chat_id;
+  if (id == null || id === "") return null;
+  const contact = (row.contact ?? {}) as Record<string, unknown>;
+  const first = Array.isArray(row.messages) ? ((row.messages as Array<Record<string, unknown>>)[0] ?? {}) : {};
+  const who = str(contact.name) || str(row.contact_name) || str(row.from_name) || str(row.from_email) || str(row.sender) || str(contact.email);
+  const title = str(row.subject) || who || (channel === "linkedin" ? "LinkedIn conversation" : "Email conversation");
+  const preview = stripHtml(str(row.snippet) || str(row.preview) || str(row.last_message) || str(first.content) || str(row.body)).replace(/\s+/g, " ").slice(0, 140);
+  const when = str(row.updated_at) || str(row.last_message_at) || str(row.created_at) || undefined;
+  return { id: String(id), channel, title, subtitle: who && who !== title ? who : str(row.mailbox), preview, when };
+}
+
+// --- Hidden or missing threads ------------------------------------------------------------------------------------
+
+/**
+ * The dev API answers a uniform 404 for a thread that does not exist AND for one this key may not see (an org key sees
+ * shared threads only), so the two cannot be told apart. Views say so instead of showing a generic failure.
+ */
+export const isNotFound = (error: unknown): boolean => (error as { status?: number } | null)?.status === 404;

package/blocks/newsletter/components/newsletter-screen.tsx

@@ -200,6 +200,8 @@ export function NewsletterScreen({ initialNewsletterId, renderRowActions, render
   const [goal, setGoal] = useState("");
   const [pending, setPending] = useState<"create" | "activate" | null>(null);
   // Bumped after a version restore so the editor reloads the draft instead of showing the old text.
+  // Bumped after a version restore so the Write tab remounts and reloads the draft. The History tab is NOT keyed on it:
+  // remounting it would drop a Duplicate confirm opened right after the restore (it refetches its own versions).
   const [formRev, setFormRev] = useState(0);
 
   const newsletters = useG8Query((signal) => g8Get<Newsletter[]>("/newsletters", {}, { signal }).then((r) => r.data ?? []), []);
@@ -249,7 +251,7 @@ export function NewsletterScreen({ initialNewsletterId, renderRowActions, render
         { id: "write", label: isDraft(selected) ? "Write" : "Content", content: <IssueForm key={`f${selected.id}:${formRev}`} newsletterId={newsletterId} issueId={selected.id} onSaved={() => void issues.refetch()} onDeleted={() => { setIssueParam(null); void issues.refetch(); }} /> },
         { id: "send", label: "Send", content: <IssueScheduler key={`s${selected.id}`} newsletterId={newsletterId} issueId={selected.id} onSent={() => void issues.refetch()} /> },
         { id: "results", label: "Results", content: <IssueResults newsletterId={newsletterId} issue={selected} /> },
-        { id: "history", label: "History", content: <IssueVersions key={`v${selected.id}:${formRev}`} newsletterId={newsletterId} issue={selected} onRestored={() => { setFormRev((n) => n + 1); void issues.refetch(); }} onDuplicated={(id) => { void issues.refetch(); setIssueParam(String(id)); }} /> },
+        { id: "history", label: "History", content: <IssueVersions key={`v${selected.id}`} newsletterId={newsletterId} issue={selected} onRestored={() => { setFormRev((n) => n + 1); void issues.refetch(); }} onDuplicated={(id) => { void issues.refetch(); setIssueParam(String(id)); }} /> },
         { id: "details", label: "Issue details", content: <IssueDetails issue={selected} /> },
         ...(extraDetailTabs ?? []).map((t) => ({ id: t.id, label: t.label, content: t.render(selected) })),
       ]

package/blocks/pages/block.json

@@ -262,7 +262,16 @@
       ]
     }
   ],
-  "hooks": [],
+  "hooks": [
+    {
+      "name": "useLandingPagePaths",
+      "file": "hooks/use-landing-page-paths.ts",
+      "purpose": "Resolve a website path to the one published landing page at that address (by id, never by name), for glue such as web analytics' Open landing page.",
+      "operations": [
+        "list_landing_pages_landing_pages_get"
+      ]
+    }
+  ],
   "lib": [
     {
       "file": "lib/studio.ts",

package/blocks/pages/hooks/use-landing-page-paths.ts

@@ -0,0 +1,60 @@
+"use client";
+
+/**
+ * useLandingPagePaths: which landing page lives at a given website path. Used by glue that links a page in analytics to
+ * its landing page (web-analytics: "Open landing page").
+ *
+ * A page is matched by its published address only: the path of `published_url`. The analytics path has no host, so when two
+ * landing pages publish the same path on different domains the path is ambiguous and links to NEITHER (never a guess, and
+ * never a match on the page's name or title). Drafts have no `published_url` and are never matched.
+ *
+ * SDK operations (read, free):
+ *   1. listLandingPages  GET /landing-pages?limit&offset   (every page is read, 100 at a time, with useAllPages)
+ */
+import { useMemo } from "react";
+import { useAllPages } from "@/g8/hooks/use-all-pages";
+import { g8Get } from "@/g8/lib/g8-client";
+import { rowsOf } from "../lib/studio";
+import type { LandingPageRow } from "../lib/studio";
+
+const PAGE = 100;
+
+/** `/pricing/` and `/pricing` are the same page; the root stays `/`. */
+export function normalizePath(path: string): string {
+  const p = path.split(/[?#]/)[0];
+  return p.length > 1 ? p.replace(/\/+$/, "") || "/" : p || "/";
+}
+
+/** path -> landing page id, for published pages whose path is unique among them. */
+export function landingPageIdsByPath(pages: Array<Pick<LandingPageRow, "id" | "published_url">>): Map<string, string> {
+  const seen = new Map<string, string | null>();
+  for (const page of pages) {
+    if (!page.published_url) continue;
+    let path: string;
+    try {
+      path = normalizePath(new URL(page.published_url).pathname);
+    } catch {
+      continue;
+    }
+    seen.set(path, seen.has(path) ? null : page.id);
+  }
+  const out = new Map<string, string>();
+  for (const [path, id] of seen) if (id) out.set(path, id);
+  return out;
+}
+
+export interface LandingPagePaths {
+  /** The id of the one published landing page at this path, or undefined. */
+  resolve: (path: string) => string | undefined;
+  loading: boolean;
+}
+
+export function useLandingPagePaths(): LandingPagePaths {
+  const pages = useAllPages<LandingPageRow>(async (page, signal) => {
+    const env = await g8Get("/landing-pages", { limit: PAGE, offset: (page - 1) * PAGE }, { signal });
+    const rows = rowsOf<LandingPageRow>(env.data, "landing_pages");
+    return { rows, hasNext: rows.length >= PAGE };
+  }, []);
+  const map = useMemo(() => landingPageIdsByPath(pages.items), [pages.items]);
+  return { resolve: (path) => map.get(normalizePath(path)), loading: pages.loading };
+}

package/blocks/programmatic-pages/README.md

@@ -0,0 +1,82 @@
+# programmatic-pages
+
+One **template landing page** plus one **data source** makes **one page per row**: a page per account, per city, per integration. A campaign holds the template, the source (a contact list, or a Workbench, CSV or sitemap-import table), an address pattern such as `{{company}}-{{first_name}}`, and per-variable rules. Rendering is free (no model runs). Putting pages on the live site is a separate, confirmed step.
+
+## Screens
+
+`ProgrammaticPagesScreen` (`components/programmatic-pages-screen.tsx`) is the finished page.
+
+```tsx
+import { ProgrammaticPagesScreen } from "@/g8/programmatic-pages/components/programmatic-pages-screen";
+export default function Page() { return <ProgrammaticPagesScreen />; }
+```
+
+Open a campaign (`?id=`) for Overview, Pages, Preview, Variables, Source, Settings, Edit and Details (`?tab=`); `&view=full` shows it as a full page. The Overview links to the template page in the `pages` screen (`/pages?id=`; override with `pagesHref`).
+
+Flows: see every campaign with state, source and page counts (search; filter by state and source; the list is complete, the API does not page it); create one from a template page and a list or table; render all pages and follow the run; read, search and filter the generated pages; mark pages ready, regenerate them, replace one page's HTML and undo it; take pages off the live site, delete them, export their addresses, send live ones to Search Console (each confirmed); publish waiting pages, republish everything or roll the last publish back (each confirmed with its page count); preview one row; set a fallback, character limit and cut rule per variable; switch the source or import a sitemap as the source; set regeneration, publishing, search and link settings; edit the name and address pattern; delete a campaign (confirmed). Optional props: `pagesHref`, `renderRowActions`, `renderDetailActions`, `extraDetailTabs`, `toolbarActions`.
+
+Parts to mount alone: `ProgrammaticCampaignForm`, `ProgrammaticOverview`, `ProgrammaticGenerate`, `ProgrammaticPublish`, `ProgrammaticGeneratedPages`, `ProgrammaticPreview`, `ProgrammaticVariables`, `ProgrammaticSource`, `ProgrammaticSettings`.
+
+## Install
+
+```
+npx @graph8/sdk add programmatic-pages
+```
+
+Installs `foundation`, `crm` and `pages` first if missing. Everything lands under `g8/programmatic-pages/`.
+
+## Prerequisites (the human must do these)
+
+| Where | What | How to verify |
+|---|---|---|
+| graph8 | A **template landing page** with HTML and `{{variables}}` (make it in the pages block). It cannot be changed after the campaign exists. | `GET /api/v1/landing-pages` lists it. |
+| graph8 | A **source** with a column for each variable (a contact list or a Workbench table). | `GET /api/v1/programmatic-campaigns/{id}/variables` shows every variable as found. |
+| graph8 | **Publishing** needs a connected Cloudflare website or hosted publishing. Rendering does not. | A person publishes one test campaign. |
+| graph8 key | `campaigns:read`, `campaigns:write`, `campaigns:delete`; `campaigns:run` for page actions and publish (separate from `campaigns:write`); `lists:read`. | `g8.api.me.describeCurrentKey()` |
+| Your app | `allowedPrefixes` must include `programmatic-campaigns`, `landing-pages`, `workbench`, `lists`. | The route file lists them. |
+
+## The flow, in order (ids passed between steps)
+
+1. **Create**: `createProgrammaticCampaign({ name, template_page_id, data_source_type, list_id | data_source_id, slug_template? })` -> **`campaign.id`** (a UUID). `template_page_id` comes from `listLandingPages`, `list_id` from `listLists`, a table id from `listWorkbenchTables`.
+2. **Check**: `getProgrammaticCampaignVariables` shows each `{{variable}}`, whether the source has a column for it, and the rule stored for it. `updateProgrammaticWorkspace({ variable_config })` REPLACES the whole array: send the existing entries back with your change.
+3. **Preview**: `previewProgrammaticPage({ contact_id? })` renders one row and saves nothing.
+4. **Render**: `startProgrammaticGeneration` (202) then poll `getProgrammaticGenerationStatus` until `completed`, `failed` or `paused`. Free.
+5. **Review**: `listProgrammaticGeneratedPages` (50 per read, up to 500) and `getProgrammaticWorkspace` (counts, search health, deployment).
+6. **Page actions**: `runProgrammaticPageAction` (`mark_ready_to_deploy`, `unpublish`, `mark_for_regeneration`, `override`, `reset_override`) and `runProgrammaticBulkPageAction` on a selection.
+7. **Publish**: `runProgrammaticBulkPageAction({ action: "deploy_pending_changes" | "republish_all" | "rollback_publish" })`, confirmed with the page count.
+8. **Source**: `updateProgrammaticWorkspace` switches list or table; `importProgrammaticSitemap` REPLACES the source with a table of the sitemap's addresses.
+9. **Remove**: `deleteProgrammaticCampaign` removes the campaign and its pages (confirmed); live copies are not taken down.
+
+## Default decisions (do not ask the human unless marked)
+
+| Decision | Default | Ask? |
+|---|---|---|
+| Data source | None: a person picks the list or table | **yes** |
+| Address pattern | Left blank: the API's own `{{company}}-{{first_name}}` | no |
+| Rendering | Free; makes drafts. Confirmed first when the approval mode is "Publish automatically" | no |
+| Publishing | Never without a person confirming the page count | **yes** |
+| Stopping | Unpublish first; a delete does not take live pages down | no |
+
+## Operation coverage (15 programmaticPages operations, all used)
+
+`listProgrammaticCampaigns`, `createProgrammaticCampaign`, `getProgrammaticCampaign`, `updateProgrammaticCampaign`, `deleteProgrammaticCampaign`, `getProgrammaticCampaignVariables`, `previewProgrammaticPage`, `startProgrammaticGeneration`, `getProgrammaticGenerationStatus`, `listProgrammaticGeneratedPages`, `getProgrammaticWorkspace`, `updateProgrammaticWorkspace`, `importProgrammaticSitemap`, `runProgrammaticPageAction`, `runProgrammaticBulkPageAction`. Tiers: `deleteProgrammaticCampaign` is destructive; both page-action operations are external (they can change the live site); none is billable. The block also reads `listLandingPages`, `getLandingPage`, `listWorkbenchTables` and (through the crm `ListSelect`) `listLists`.
+
+## API gaps (found while building; not edited, the backend is colleague-owned)
+
+| Asked for | Reality | What the block does |
+|---|---|---|
+| "Generated as drafts; nothing goes live until a deploy" | With approval mode `auto_publish` the render task marks every page `published` with a public address as it renders. | Confirms the render (external, sized by the source rows) in that mode and says so. |
+| Re-render replaces pages | The render does not clear earlier pages and `cb_programmatic_pages` has no unique slug, so a second run can add a second set. | A visible warning before "Generate again"; delete duplicates with the bulk delete. |
+| Read a page's HTML | No endpoint returns a generated page's HTML. | "Replace HTML" asks for the full replacement. |
+| Filter or search generated pages | `listProgrammaticGeneratedPages` takes `offset` and `limit` only. | Search and the status filter act on the loaded pages and say so. |
+| Map a variable to a differently named column | The workspace shows `source_column`, but the renderer matches `{{name}}` to a column of the same name only. | Only the rules the renderer reads are offered: fallback, character limit, cut rule. |
+| Edit a running or finished campaign | `updateProgrammaticCampaign` answers 400 unless the status is draft or failed. | The Edit tab says so; source, variables and settings go through the workspace, which has no such rule. |
+| Change the template | `updateProgrammaticCampaign` has no template field. | Shown read-only; make a new campaign. |
+| Rename the source list | The list source carries no name. | Shown as "Current list" until the options load. |
+| `deploy_pending_changes` count | The workspace counts pages in status `generated`; the API also redeploys live pages whose data changed. | The confirm shows the waiting count and the changed-row count. |
+| Responses | Every programmatic response is an open object (`StudioContentPayload`); the list key is `campaigns` / `pages`, mirrored onto `items`. | Read defensively; a missing value shows a dash. |
+
+## Things that surprise people
+
+- Page action `publish` and `regenerate` are aliases (`mark_ready_to_deploy`, `mark_for_regeneration`); marking ready does not put a page on the live site, only a publish does.
+- Preview needs a numeric row id; workbench rows without one can only be previewed as "First row".