@valbuild/shared 0.150.12 → 0.150.16

package/dist/declarations/src/internal/aiTools/toolNames.d.ts

@@ -1,2 +1,2 @@
-export declare const toolNames: readonly ["get_all_schema", "get_source", "search_content", "validate_content", "create_patch", "add_session_image_to_gallery", "remove_image_gallery_entry", "navigate_to", "get_current_context", "get_patches", "get_source_path_from_route", "set_session_name", "show_compare_view", "ask_user_question", "duplicate_source", "empty_at_path", "count_entries", "get_record_keys"];
+export declare const toolNames: readonly ["get_all_schema", "get_source", "search_content", "validate_content", "create_patch", "add_session_image_to_gallery", "remove_image_gallery_entry", "navigate_to", "get_current_context", "get_patches", "get_source_path_from_route", "set_session_name", "show_compare_view", "ask_user_question", "duplicate_source", "empty_at_path", "count_entries", "get_record_keys", "list_sketchpads", "create_sketchpad", "read_sketchpad", "write_sketchpad"];
 export type ToolName = (typeof toolNames)[number];

package/dist/declarations/src/internal/index.d.ts

@@ -21,14 +21,17 @@ export * from "./getNextAppRouterSourceFolder.js";
 export * from "./routeValidation.js";
 export * from "./resolveSchemaSourceFixes.js";
 export * from "./localeAt.js";
+export * from "./localeRelocation.js";
 export * from "./getErrorMessageFromUnknownJson.js";
 export * from "./zod/SerializedSchema.js";
 export * from "./valCanvasProtocol.js";
 export * from "./elementPicker.js";
 export * from "./pageInspection.js";
+export * from "./pageScreenshot.js";
 export * from "./quickPreview.js";
 export * from "./emptyOf.js";
 export * from "./aiTools/toolNames.js";
+export * from "./sketchpad/sketchFormat.js";
 export * from "./aiTools/aiImageToolPatches.js";
 export * from "./aiTools/aiSourceToolPatches.js";
 export * from "./validation/partitionValidationErrors.js";

package/dist/declarations/src/internal/localeAt.d.ts

@@ -1,4 +1,4 @@
-import { type SerializedEnumSchema, type SerializedSchema, type SourcePath } from "@valbuild/core";
+import { type Json, type JsonObject, type ModuleFilePath, type SerializedEnumSchema, type SerializedSchema, type SourcePath } from "@valbuild/core";
 import { type SchemaSourceSnapshot } from "./resolveSchemaSourceFixes.js";
 /**
  * Which of the project's languages governs a path, or `null` for none.
@@ -18,6 +18,52 @@ import { type SchemaSourceSnapshot } from "./resolveSchemaSourceFixes.js";
  * in most projects, and for every project that has not declared any languages.
  */
 export declare function localeAt(path: SourcePath, snapshot: SchemaSourceSnapshot): string | null;
+/**
+ * Where the scope governing a path opens, and how.
+ *
+ * - `field`: the node `depth` segments down has a locale field. `depth` 0 is the
+ *   module root.
+ * - `record-key`: segment `depth` is a key of a locale-keyed record, which sits
+ *   `depth` segments down.
+ * - `route-key`: segment `depth` is a route whose parameters name the language,
+ *   in the router `depth` segments down (in practice the module root).
+ *
+ * The opener is what decides where an editor goes when the Studio's language
+ * changes under them — the same entry in another language for a key, the
+ * parent for a field. See `relocateForLocale`.
+ */
+export type LocaleScope = {
+    locale: string;
+    depth: number;
+} & ({
+    kind: "field";
+} | {
+    kind: "record-key";
+    keySchema: SerializedSchema;
+} | {
+    kind: "route-key";
+    router: SerializedSchema & {
+        type: "record";
+    };
+});
+/**
+ * The scope that governs a path, read from that module's schema and source
+ * alone, or `null` where none does.
+ *
+ * {@link localeAt} for a caller that already has the module in hand — the
+ * Studio, which has the project's languages from its own provider and would
+ * otherwise have to assemble a snapshot of every module to ask about one.
+ */
+export declare function localeScopeAt(path: SourcePath, schema: SerializedSchema, source: Json, available: readonly string[]): LocaleScope | null;
+/**
+ * The language a whole module is in: the one its root's locale field names, or
+ * `null` where its root has none.
+ *
+ * The only way a module is in one language as a whole — a locale-keyed record
+ * or a router at the root is every one of its languages at once. Needs no path,
+ * so a list of modules can ask it of each.
+ */
+export declare function localeOfModuleRoot(schema: SerializedSchema, source: Json, available: readonly string[]): string | null;
 /**
  * The language a locale schema's value MEANS, or `null` if it means none of
  * the project's.
@@ -44,3 +90,42 @@ export declare function enumLocaleTag(schema: SerializedEnumSchema, value: strin
  * one.
  */
 export declare function isLocaleSchema(schema: SerializedSchema): boolean;
+/**
+ * Whether a router's URLs name the language each page is in — one of its route
+ * parameters is a locale (`s.router(router, { locale: … }, item)`).
+ */
+export declare function hasLocaleRouteParam(schema: SerializedSchema): boolean;
+/**
+ * The language a router's key is in, where one of its route parameters is a
+ * locale — `/nb/blog/hei` is `nb-NO` when `locale` maps `nb` to it.
+ *
+ * Answered from the key alone, with no content read: which is what lets the
+ * Studio's page tree filter every page of a site without loading one of them.
+ */
+export declare function localeOfRouteKey(schema: SerializedSchema & {
+    type: "record";
+}, moduleFilePath: ModuleFilePath, key: string, available: readonly string[]): string | null;
+/**
+ * The route parameters a key gives its router, and which of them is the
+ * language — or `null` where the router has no locale parameter or the key is
+ * not one of its URLs.
+ */
+export declare function localeParamOfRouteKey(schema: SerializedSchema & {
+    type: "record";
+}, moduleFilePath: ModuleFilePath, key: string): {
+    name: string;
+    schema: SerializedSchema;
+    value: string | null;
+    values: Record<string, string | null>;
+} | null;
+/** The child of a source value at a segment, or `null` where there is none. */
+export declare function childSource(source: Json, segment: string): Json;
+/**
+ * Whether `source` is a JSON object rather than an array or a primitive.
+ *
+ * A type predicate rather than the inline checks, because `Array.isArray` does
+ * NOT narrow `JsonArray` out of `Json` — it is `readonly Json[]`, and the
+ * built-in guard only narrows mutable arrays. Without this, every read of a
+ * property would need an assertion.
+ */
+export declare function isJsonObject(source: Json): source is JsonObject;

package/dist/declarations/src/internal/localeRelocation.d.ts

@@ -0,0 +1,46 @@
+import { type Json, type SerializedSchema, type SourcePath } from "@valbuild/core";
+/**
+ * Where an editor goes when the Studio's language changes under them.
+ *
+ * - `stay`: the path is in that language, or in none.
+ * - `path`: the same entry in that language (`counterpart`), or the nearest
+ *   parent that is not in another language (`parent`).
+ * - `home`: neither exists, so the editor goes to the Studio's start, with
+ *   nothing selected.
+ */
+export type LocaleRelocation = {
+    type: "stay";
+} | {
+    type: "path";
+    path: SourcePath;
+    reason: "counterpart" | "parent";
+} | {
+    type: "home";
+};
+/**
+ * Where to move a path to when the Studio is switched to `locale`.
+ *
+ * The rule, in the order it is tried:
+ *
+ * 1. **The same entry in `locale`, where Val KNOWS it.** That is two cases:
+ *    a locale-keyed record, where the counterpart of `"en-US"` is the
+ *    `"nb-NO"` key of the same record; and a router whose URLs name their
+ *    language, where `/about` and `/nb/about` differ only in it. Only a key
+ *    that exists is taken, and the rest of the path is kept as far as it
+ *    still exists, so an editor on a field lands on that field.
+ * 2. **Otherwise the nearest parent that is not in another language.** An
+ *    English post in a list of posts gives the list, now showing Norwegian.
+ * 3. **Otherwise the Studio's start**, which is `home`: nothing selected. That
+ *    is where an object at the module root opened the scope (the whole module
+ *    is in another language), and where the parent would be a router: a list
+ *    of pages is not a page, and the Pages tree is how an editor sees one.
+ *
+ * Not the site's root page, and not any other page: which language a page is
+ * in is the page's own business, and `/` can be in the language the editor
+ * just left. The start screen is in no language.
+ *
+ * Never a guess. Two pages whose URLs differ in more than the language — a
+ * Norwegian slug for a Norwegian page — are not known to be translations of
+ * each other, so that is `home` rather than whichever page looks closest.
+ */
+export declare function relocateForLocale(path: SourcePath, locale: string, schema: SerializedSchema, source: Json, available: readonly string[]): LocaleRelocation;

package/dist/declarations/src/internal/pageScreenshot.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A picture of the page, taken in the page: the assistant's
+ * `screenshot_page`, so it can see a change it made rather than only read it
+ * (`read_page` gives the words and the boxes).
+ *
+ * Taken HERE because nothing else can: the design tab is another origin than
+ * the proposal's page in its frame, and a browser lets no page photograph a
+ * frame of another origin. So the bridge renders its own document --
+ * `modern-screenshot` draws the DOM, with its computed styles, fonts and
+ * same-origin images, into a canvas -- and hands back a JPEG.
+ *
+ * It is a rendering of the DOM, not of the screen: an image from another
+ * origin that does not allow it, a video frame, a `<canvas>` a script drew
+ * and an iframe come out blank. Good enough to see a layout, a colour, a
+ * button that wrapped; the tool says what it cannot show.
+ *
+ * Loaded when asked: the library is not in a page that is never
+ * photographed.
+ */
+/** What `screenshotPage` answers. */
+export type PageScreenshot = {
+    /** A JPEG, as a data URL. */
+    dataUrl: string;
+    width: number;
+    height: number;
+    /** The whole page, from the top, rather than what was on screen. */
+    fullPage: boolean;
+    /** The page went on below what the picture shows. */
+    clipped: boolean;
+};
+/**
+ * The page in `win`, as it is now: what is on screen, or (`fullPage`) the
+ * whole page from the top, cut off at {@link MAX_FULL_PAGE_HEIGHT}. Elements
+ * `exclude` says are not the page's -- the picker's highlight -- are left
+ * out.
+ */
+export declare function screenshotPage(win: Window, options?: {
+    fullPage?: boolean;
+    exclude?: (element: Element) => boolean;
+}): Promise<PageScreenshot>;

package/dist/declarations/src/internal/server/types.d.ts

@@ -1,7 +1,7 @@
 import { Json } from "@valbuild/core";
-export declare const VAL_SESSION_COOKIE: any;
-export declare const VAL_STATE_COOKIE: any;
-export declare const VAL_ENABLE_COOKIE_NAME: any;
+export declare const VAL_SESSION_COOKIE: "val_session";
+export declare const VAL_STATE_COOKIE: "val_state";
+export declare const VAL_ENABLE_COOKIE_NAME: "val_enable";
 export type VAL_SESSION_COOKIE = typeof VAL_SESSION_COOKIE;
 export type VAL_STATE_COOKIE = typeof VAL_STATE_COOKIE;
 export type VAL_ENABLE_COOKIE_NAME = typeof VAL_ENABLE_COOKIE_NAME;

package/dist/declarations/src/internal/sketchpad/sketchFormat.d.ts

@@ -0,0 +1,118 @@
+/**
+ * A page sketch: a page written as indented text, with four primitives.
+ *
+ * ```
+ * # Our people                 text (a heading: #, ## or ###)
+ * We are 40 people in Oslo.    text (a paragraph)
+ * [image: Team photo]          placeholder: [kind] or [kind: label]
+ * [hero: Roof](image: /a.jpg)  a placeholder with an image (or video) in it
+ * icon hero M3 5h18v14H3z      how every [hero] box is drawn: SVG path data
+ * row                          its children side by side
+ *   col 2                      its children stacked; 2 shares of the row
+ *     ## Design
+ *   col
+ *     [button: Join us]
+ * ```
+ *
+ * It is a scratch pad, not a layout language: it says WHAT is on a page and
+ * roughly WHERE, so an assistant and a person can agree on a page's content
+ * before anyone worries about how it looks. The person never sees this text,
+ * only the page it describes; the assistant never sees the page, only this.
+ * So the two have to be the same thing, and the format is STRICT: there is
+ * exactly one way to write what is on the screen. `checkSketch` is that
+ * rule, and the server refuses a write that breaks it, with the line to fix.
+ *
+ * Parsing is still forgiving, so a sketch that breaks the rule shows what it
+ * can rather than nothing; that is for reading, never for accepting.
+ *
+ * A placeholder's kind is any word, and nothing here knows what one means. The
+ * assistant that writes the sketch also draws each kind's icon, as path data
+ * in a 24 by 24 box, so a kind nobody thought of looks as deliberate as an
+ * image. Media put in a box is written into the text too, so the assistant
+ * that builds the page reads it exactly as the person left it.
+ */
+export type SketchNode = SketchRow | SketchCol | SketchText | SketchPlaceholder;
+export type SketchRow = {
+    type: "row";
+    line: number;
+    children: SketchNode[];
+};
+export type SketchCol = {
+    type: "col";
+    line: number;
+    /** Shares of the enclosing row this column takes. */
+    weight: number;
+    children: SketchNode[];
+};
+export type SketchText = {
+    type: "text";
+    line: number;
+    /** 0 is a paragraph; 1-3 are headings. */
+    level: 0 | 1 | 2 | 3;
+    text: string;
+};
+export type SketchPlaceholder = {
+    type: "placeholder";
+    line: number;
+    kind: string;
+    label: string | null;
+    media: SketchMedia | null;
+};
+export type SketchMedia = {
+    type: "image" | "video";
+    src: string;
+};
+export type SketchError = {
+    /** 1-based, like an editor's gutter. */
+    line: number;
+    message: string;
+};
+export type ParsedSketch = {
+    /** The page itself is a column. */
+    blocks: SketchNode[];
+    /**
+     * SVG path data by kind, lower case. Drawn as a 24 by 24 line icon: stroked
+     * in the text colour, not filled.
+     */
+    icons: Record<string, string>;
+    errors: SketchError[];
+};
+export declare function parseSketch(source: string): ParsedSketch;
+/**
+ * The line a text block is written as. Line breaks become spaces, and a
+ * paragraph that would read as something else is kept as text with `\`.
+ */
+export declare function formatSketchText(level: SketchText["level"], text: string): string;
+/** The line a placeholder is written as. */
+export declare function formatSketchBox(placeholder: Pick<SketchPlaceholder, "kind" | "label" | "media">): string;
+/**
+ * The ONE way of writing `blocks` and `icons`: what `checkSketch` holds every
+ * other text to, and what the Studio's editor writes (its own serializer is
+ * tested against this one). Two spaces per level; an empty row gets an empty
+ * col, so it has somewhere to type; a col outside a row is written as its
+ * contents, which is all it shows; the icons last, after one blank line, and
+ * no blank line anywhere else; a final newline. Empty text is not written --
+ * it is not on the page.
+ */
+export declare function formatSketch(blocks: SketchNode[], icons: Record<string, string>): string;
+/**
+ * What a list names a sketch by: its first top-level heading, the biggest
+ * one first. Null for a sketch with no heading, which a list then names by
+ * its page.
+ */
+export declare function sketchTitle(blocks: SketchNode[]): string | null;
+/**
+ * Everything wrong with `source`, or nothing when it is a sketch exactly as
+ * `formatSketch` writes it.
+ *
+ * Strict on purpose. The person sees the page and the assistant sees the
+ * text, so a text with two spellings of one page -- a tab or two spaces, an
+ * icon line here or there, a blank line or none -- is a text the assistant
+ * cannot trust to be what is on the screen, and that would show it a change
+ * nobody made the next time the Studio writes it back. Holding every write
+ * to the one spelling rules all of that out at once.
+ *
+ * The parse errors come first; past those, the first line that is spelled
+ * differently, with how it should be spelled.
+ */
+export declare function checkSketch(source: string): SketchError[];

package/dist/declarations/src/internal/valCanvasProtocol.d.ts

@@ -22,6 +22,7 @@
 import type { ModuleFilePath, SourcePath } from "@valbuild/core";
 import type { PickedElement, PickModifier } from "./elementPicker.js";
 import type { PageLocation, PageSnapshot } from "./pageInspection.js";
+import type { PageScreenshot } from "./pageScreenshot.js";
 import { type QuickPreviewFiles } from "./quickPreview.js";
 /** Marks a page load as the studio's canvas frame. */
 export declare const VAL_CANVAS_PARAM = "val_canvas";
@@ -205,6 +206,16 @@ export type ValCanvasPageMessage = {
     requestId: string;
     snapshot: PageSnapshot | null;
     error?: string;
+} | {
+    /**
+     * What `screenshotPage` asked for: the page as a JPEG data URL, or why
+     * it could not be taken (`pageScreenshot.ts`).
+     */
+    val: typeof VAL_CANVAS_MESSAGE;
+    type: "pageScreenshot";
+    requestId: string;
+    screenshot: PageScreenshot | null;
+    error?: string;
 } | {
     /**
      * A quick preview's files are stored in the page's worker, and a page
@@ -334,6 +345,16 @@ export type ValCanvasStudioMessage = {
     requestId: string;
     selector?: string;
     maxItems?: number;
+} | {
+    /**
+     * Take a picture of the page (`screenshotPage`): the assistant's
+     * `screenshot_page`. Answered with `pageScreenshot` and the same
+     * `requestId`; a bridge that predates it never answers.
+     */
+    val: typeof VAL_CANVAS_MESSAGE;
+    type: "screenshotPage";
+    requestId: string;
+    fullPage?: boolean;
 } | {
     /**
      * Store a quick preview's files in this origin's worker

package/dist/declarations/src/internal/zod/History.d.ts

@@ -64,9 +64,9 @@ export declare const BinaryFileRef: z.ZodObject<{
 }, z.core.$strip>;
 export type BinaryFileRef = z.infer<typeof BinaryFileRef>;
 export declare const HistoricalModule: z.ZodObject<{
-    source: z.ZodNullable<z.ZodType<JSONValueT, unknown, z.core.$ZodTypeInternals<JSONValueT, unknown>>>;
-    schema: z.ZodNullable<z.ZodType<SerializedSchemaT, unknown, z.core.$ZodTypeInternals<SerializedSchemaT, unknown>>>;
-    patchIds: z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>;
+    source: z.ZodNullable<z.ZodType<import("@valbuild/core/patch").JSONValue, unknown, z.core.$ZodTypeInternals<import("@valbuild/core/patch").JSONValue, unknown>>>;
+    schema: z.ZodNullable<z.ZodType<import("@valbuild/core").SerializedSchema, unknown, z.core.$ZodTypeInternals<import("@valbuild/core").SerializedSchema, unknown>>>;
+    patchIds: z.ZodArray<z.ZodString & z.ZodType<import("@valbuild/core").PatchId, string, z.core.$ZodTypeInternals<import("@valbuild/core").PatchId, string>>>;
     changedPaths: z.ZodArray<z.ZodString>;
     failures: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"commit-not-found">;
@@ -109,9 +109,9 @@ export declare const HistoricalPatchSet: z.ZodObject<{
         hasArchive: z.ZodBoolean;
     }, z.core.$strip>;
     modules: z.ZodRecord<z.ZodString, z.ZodObject<{
-        source: z.ZodNullable<z.ZodType<JSONValueT, unknown, z.core.$ZodTypeInternals<JSONValueT, unknown>>>;
-        schema: z.ZodNullable<z.ZodType<SerializedSchemaT, unknown, z.core.$ZodTypeInternals<SerializedSchemaT, unknown>>>;
-        patchIds: z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>;
+        source: z.ZodNullable<z.ZodType<import("@valbuild/core/patch").JSONValue, unknown, z.core.$ZodTypeInternals<import("@valbuild/core/patch").JSONValue, unknown>>>;
+        schema: z.ZodNullable<z.ZodType<import("@valbuild/core").SerializedSchema, unknown, z.core.$ZodTypeInternals<import("@valbuild/core").SerializedSchema, unknown>>>;
+        patchIds: z.ZodArray<z.ZodString & z.ZodType<import("@valbuild/core").PatchId, string, z.core.$ZodTypeInternals<import("@valbuild/core").PatchId, string>>>;
         changedPaths: z.ZodArray<z.ZodString>;
         failures: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             kind: z.ZodLiteral<"commit-not-found">;
@@ -139,7 +139,7 @@ export declare const HistoricalPatchSet: z.ZodObject<{
         }, z.core.$strip>], "kind">>;
     }, z.core.$strip>>;
     patches: z.ZodArray<z.ZodObject<{
-        patchId: z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>;
+        patchId: z.ZodString & z.ZodType<import("@valbuild/core").PatchId, string, z.core.$ZodTypeInternals<import("@valbuild/core").PatchId, string>>;
         moduleFilePath: z.ZodString;
         patch: z.ZodUnknown;
         authorId: z.ZodNullable<z.ZodString>;

package/dist/declarations/src/internal/zod/Patch.d.ts

@@ -1,4 +1,5 @@
 import type { JSONValue as JSONValueT, PatchJSON as PatchJSONT, PatchBlock as PatchBlockT, ParentRef as ParentRefT } from "@valbuild/core/patch";
+import type { PatchId as PatchIdT } from "@valbuild/core";
 import { z } from "zod";
 /**
  * JSON, recursively — the shape of a Source over the wire.

package/dist/declarations/src/internal/zod/SerializedSchema.d.ts

@@ -66,7 +66,25 @@ export declare const ColorOptions: z.ZodObject<{
 export declare const SerializedColorSchema: z.ZodType<SerializedColorSchemaT>;
 export declare const CodeOptions: z.ZodObject<{
     language: z.ZodOptional<z.ZodEnum<{
-        [x: string]: any;
+        html: "html";
+        css: "css";
+        json: "json";
+        typescript: "typescript";
+        javascript: "javascript";
+        javascriptreact: "javascriptreact";
+        typescriptreact: "typescriptreact";
+        java: "java";
+        xml: "xml";
+        markdown: "markdown";
+        sql: "sql";
+        python: "python";
+        rust: "rust";
+        php: "php";
+        go: "go";
+        cpp: "cpp";
+        sass: "sass";
+        vue: "vue";
+        angular: "angular";
     }>>;
 }, z.core.$strip>;
 export declare const SerializedCodeSchema: z.ZodType<SerializedCodeSchemaT>;
@@ -83,7 +101,7 @@ export declare const SerializedSettingsSchema: z.ZodType<SerializedSettingsSchem
  */
 export declare const SerializedValViewSchema: z.ZodObject<{
     type: z.ZodLiteral<"view">;
-    moduleFilePath: z.ZodType<ModuleFilePathT, unknown, z.core.$ZodTypeInternals<ModuleFilePathT, unknown>>;
+    moduleFilePath: z.ZodType<import("@valbuild/core").ModuleFilePath, unknown, z.core.$ZodTypeInternals<import("@valbuild/core").ModuleFilePath, unknown>>;
     opt: z.ZodLiteral<false>;
     readonly: z.ZodOptional<z.ZodBoolean>;
     hidden: z.ZodOptional<z.ZodBoolean>;

package/dist/{getSitemapTree-97b3166f.esm.js → getSitemapTree-7c848c94.esm.js}

@@ -322,7 +322,7 @@ function isValCanvasPageMessage(data) {
   if (_typeof(data) !== "object" || data === null) return false;
   var message = data;
   if (message.val !== VAL_CANVAS_MESSAGE) return false;
-  return message.type === "ready" || message.type === "elements" || message.type === "clicked" || message.type === "pinch" || message.type === "zoom" || message.type === "refreshing" || message.type === "elementPickingStopped" || message.type === "elementPicked" && isPickedElement(data.element) || message.type === "location" && isPageLocation(data) || message.type === "pageRead" && typeof data.requestId === "string" || message.type === "quickPreviewStored" && typeof data.id === "string";
+  return message.type === "ready" || message.type === "elements" || message.type === "clicked" || message.type === "pinch" || message.type === "zoom" || message.type === "refreshing" || message.type === "elementPickingStopped" || message.type === "elementPicked" && isPickedElement(data.element) || message.type === "location" && isPageLocation(data) || message.type === "pageRead" && typeof data.requestId === "string" || message.type === "pageScreenshot" && typeof data.requestId === "string" || message.type === "quickPreviewStored" && typeof data.id === "string";
 }
 function isPageLocation(value) {
   var location = value;
@@ -379,6 +379,10 @@ function isValCanvasStudioMessage(data) {
     var preview = data;
     return typeof preview.id === "string" && /^[A-Za-z0-9_-]{1,64}$/.test(preview.id) && isQuickPreviewFiles(preview.files);
   }
+  if (message.type === "screenshotPage") {
+    var asked = data;
+    return typeof asked.requestId === "string" && (asked.fullPage === undefined || typeof asked.fullPage === "boolean");
+  }
   if (message.type === "readPage") {
     var read = data;
     return typeof read.requestId === "string" && (read.selector === undefined || typeof read.selector === "string") && (read.maxItems === undefined || typeof read.maxItems === "number");
@@ -1137,6 +1141,137 @@ function selectorOf(element, root) {
   return parts.join(" > ");
 }
 
+/**
+ * A picture of the page, taken in the page: the assistant's
+ * `screenshot_page`, so it can see a change it made rather than only read it
+ * (`read_page` gives the words and the boxes).
+ *
+ * Taken HERE because nothing else can: the design tab is another origin than
+ * the proposal's page in its frame, and a browser lets no page photograph a
+ * frame of another origin. So the bridge renders its own document --
+ * `modern-screenshot` draws the DOM, with its computed styles, fonts and
+ * same-origin images, into a canvas -- and hands back a JPEG.
+ *
+ * It is a rendering of the DOM, not of the screen: an image from another
+ * origin that does not allow it, a video frame, a `<canvas>` a script drew
+ * and an iframe come out blank. Good enough to see a layout, a colour, a
+ * button that wrapped; the tool says what it cannot show.
+ *
+ * Loaded when asked: the library is not in a page that is never
+ * photographed.
+ */
+
+/** What `screenshotPage` answers. */
+
+/** Wider than this is scaled down: a model reads a page no better larger. */
+var MAX_WIDTH = 1280;
+/** A whole page longer than this, in CSS pixels, is cut off below it. */
+var MAX_FULL_PAGE_HEIGHT = 4000;
+var JPEG_QUALITY = 0.85;
+/** How long an image or a font on the page is waited for. */
+var LOAD_TIMEOUT_MS = 8000;
+
+/**
+ * The page in `win`, as it is now: what is on screen, or (`fullPage`) the
+ * whole page from the top, cut off at {@link MAX_FULL_PAGE_HEIGHT}. Elements
+ * `exclude` says are not the page's -- the picker's highlight -- are left
+ * out.
+ */
+function screenshotPage(_x) {
+  return _screenshotPage.apply(this, arguments);
+}
+
+/** What the page is drawn on: the body's background, else the root's, else white. */
+function _screenshotPage() {
+  _screenshotPage = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(win) {
+    var _doc$body$scrollHeigh, _doc$body;
+    var options,
+      _yield$import,
+      domToCanvas,
+      doc,
+      root,
+      fullPage,
+      pageWidth,
+      pageHeight,
+      top,
+      height,
+      exclude,
+      drawn,
+      scale,
+      out,
+      context,
+      _args = arguments;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          options = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
+          _context.n = 1;
+          return import('modern-screenshot');
+        case 1:
+          _yield$import = _context.v;
+          domToCanvas = _yield$import.domToCanvas;
+          doc = win.document;
+          root = doc.documentElement;
+          fullPage = options.fullPage === true;
+          pageWidth = root.clientWidth || win.innerWidth;
+          pageHeight = Math.max(root.scrollHeight, (_doc$body$scrollHeigh = (_doc$body = doc.body) === null || _doc$body === void 0 ? void 0 : _doc$body.scrollHeight) !== null && _doc$body$scrollHeigh !== void 0 ? _doc$body$scrollHeigh : 0);
+          top = fullPage ? 0 : win.scrollY;
+          height = fullPage ? Math.min(pageHeight, MAX_FULL_PAGE_HEIGHT) : Math.min(win.innerHeight, pageHeight - top);
+          exclude = options.exclude; // Drawn to the bottom of what is wanted, and no further: the cost is the
+          // page's size, so a viewport near the top is cheap.
+          _context.n = 2;
+          return domToCanvas(root, _objectSpread2({
+            width: pageWidth,
+            height: top + height,
+            scale: 1,
+            backgroundColor: pageBackground(win),
+            timeout: LOAD_TIMEOUT_MS
+          }, exclude !== undefined ? {
+            filter: function filter(node) {
+              return !(isElement(node) && exclude(node));
+            }
+          } : {}));
+        case 2:
+          drawn = _context.v;
+          scale = Math.min(1, MAX_WIDTH / pageWidth);
+          out = doc.createElement("canvas");
+          out.width = Math.round(pageWidth * scale);
+          out.height = Math.round(height * scale);
+          context = out.getContext("2d");
+          if (!(context === null)) {
+            _context.n = 3;
+            break;
+          }
+          throw new Error("This browser would not draw the picture.");
+        case 3:
+          context.drawImage(drawn, 0, top, pageWidth, height, 0, 0, out.width, out.height);
+          return _context.a(2, {
+            dataUrl: out.toDataURL("image/jpeg", JPEG_QUALITY),
+            width: out.width,
+            height: out.height,
+            fullPage: fullPage,
+            clipped: top + height < pageHeight
+          });
+      }
+    }, _callee);
+  }));
+  return _screenshotPage.apply(this, arguments);
+}
+function pageBackground(win) {
+  for (var _i = 0, _arr = [win.document.body, win.document.documentElement]; _i < _arr.length; _i++) {
+    var element = _arr[_i];
+    if (element === null) continue;
+    var color = win.getComputedStyle(element).backgroundColor;
+    if (color && color !== "transparent" && color !== "rgba(0, 0, 0, 0)") {
+      return color;
+    }
+  }
+  return "#ffffff";
+}
+function isElement(node) {
+  return node.nodeType === 1;
+}
+
 function parseRoutePattern(pattern) {
   if (pattern === "" || pattern === "/") {
     return [];
@@ -1378,4 +1513,4 @@ function getPatternFromModuleFilePath(moduleFilePath, srcFolder) {
   .replace("/page.val.ts", "").replace("/page.val.js", "");
 }
 
-export { quickPreviewSiteOrigin as A, isDesignTabOrigin as B, parseRoutePattern as C, DEFAULT_CANVAS_SELECTION as D, formatRoutePattern as E, getNextAppRouterSourceFolder as F, getTanStackRouterSourceFolder as G, getPageRouterSourceFolder as H, isTanStackRoutesFolder as I, getPageRouterSitemapTree as J, getPatternFromModuleFilePath as K, QUICK_PREVIEW_PARAM as Q, VAL_CONFIG_SESSION_STORAGE_KEY as V, VAL_THEME_SESSION_STORAGE_KEY as a, VAL_AI_SESSION_STORAGE_KEY as b, VAL_CANVAS_PARAM as c, VAL_CANVAS_MESSAGE as d, DEFAULT_CANVAS_SELECTION_SOFT as e, isValCanvasStudioMessage as f, isValCanvasFrame as g, describeElement as h, isValCanvasPageMessage as i, attachElementPicker as j, createPickerOverlay as k, elementLabel as l, modifierLabel as m, watchPageLocation as n, readPageSnapshot as o, pageLocationOf as p, findBySelector as q, restoreScroll as r, startElementPicking as s, QUICK_PREVIEW_SERVICE_WORKER_PATH as t, QUICK_PREVIEW_STORE_MESSAGE as u, isQuickPreviewFiles as v, withValCanvasParam as w, QUICK_PREVIEW_SERVICE_WORKER_SOURCE as x, storeQuickPreview as y, withQuickPreviewParam as z };
+export { withQuickPreviewParam as A, quickPreviewSiteOrigin as B, isDesignTabOrigin as C, DEFAULT_CANVAS_SELECTION as D, parseRoutePattern as E, formatRoutePattern as F, getNextAppRouterSourceFolder as G, getTanStackRouterSourceFolder as H, getPageRouterSourceFolder as I, isTanStackRoutesFolder as J, getPageRouterSitemapTree as K, getPatternFromModuleFilePath as L, QUICK_PREVIEW_PARAM as Q, VAL_CONFIG_SESSION_STORAGE_KEY as V, VAL_THEME_SESSION_STORAGE_KEY as a, VAL_AI_SESSION_STORAGE_KEY as b, VAL_CANVAS_PARAM as c, VAL_CANVAS_MESSAGE as d, DEFAULT_CANVAS_SELECTION_SOFT as e, isValCanvasStudioMessage as f, isValCanvasFrame as g, describeElement as h, isValCanvasPageMessage as i, attachElementPicker as j, createPickerOverlay as k, elementLabel as l, modifierLabel as m, watchPageLocation as n, readPageSnapshot as o, pageLocationOf as p, findBySelector as q, restoreScroll as r, startElementPicking as s, screenshotPage as t, QUICK_PREVIEW_SERVICE_WORKER_PATH as u, QUICK_PREVIEW_STORE_MESSAGE as v, withValCanvasParam as w, isQuickPreviewFiles as x, QUICK_PREVIEW_SERVICE_WORKER_SOURCE as y, storeQuickPreview as z };