@opencraw/studio 0.0.18 → 0.0.20

package/dist/selector-inference/shadow-dom.error.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Thrown when a pick or a list-inference walk crosses a declarative shadow
+ * root (`<template shadowrootmode>`). v1 does not pierce shadow DOM: rather
+ * than infer a selector that silently matches the wrong thing (or nothing,
+ * once the page hydrates), the studio surfaces this and stops.
+ */
+export declare class ShadowDomUnsupportedError extends Error {
+    readonly path: string;
+    constructor(path: string);
+}
+//# sourceMappingURL=shadow-dom.error.d.ts.map

package/dist/selector-inference/take-kind.policy.d.ts

@@ -0,0 +1,12 @@
+import type { DomPathLevel } from './dom-path.model';
+/**
+ * What a `Read` card's `take` should be for the element a pick landed on
+ * (issue #91, studio plan §3.2): `attr:href` for an `<a>`, `attr:src` for an
+ * `<img>`, `attr:<name>` for the first `data-*` attribute otherwise, `json`
+ * for a `<script type="application/json">`, else the default, `text`.
+ *
+ * @param level - The clicked element's own level (the last entry of its `DomPath`).
+ * @returns The `take` value to put on the `extract` step.
+ */
+export declare function takeKindFor(level: DomPathLevel): string;
+//# sourceMappingURL=take-kind.policy.d.ts.map

package/dist/studio-api/command.contract.d.ts

@@ -0,0 +1,531 @@
+import { z } from 'zod';
+/** A budget for a sample run; never authored into a recipe, only asked for by the caller. */
+export declare const sampleBudgetSchema: z.ZodObject<{
+    maxRecords: z.ZodOptional<z.ZodNumber>;
+    maxPages: z.ZodOptional<z.ZodNumber>;
+    maxMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** Opens a recipe folder: the server reads it and answers with a `WorkspaceView`. */
+export declare const openWorkspaceCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"open-workspace">;
+    folder: z.ZodString;
+}, z.core.$strip>;
+/** Runs one input recipe under a budget, streaming `trace-line` and `record` events, ending in `run-finished`. */
+export declare const runSampleCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"run-sample">;
+    recipeId: z.ZodString;
+    budget: z.ZodOptional<z.ZodObject<{
+        maxRecords: z.ZodOptional<z.ZodNumber>;
+        maxPages: z.ZodOptional<z.ZodNumber>;
+        maxMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Closes the crawler of the run in progress, if any; a no-op otherwise. */
+export declare const stopRunCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"stop-run">;
+}, z.core.$strip>;
+/** Writes a recipe file: the whole object, pretty-printed by the server (see `recipe-workspace`). */
+export declare const saveRecipeCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"save-recipe">;
+    path: z.ZodString;
+    recipe: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+/** Fetches the HTML of an input recipe's start page, as the engine would see it. */
+export declare const fetchStartPageCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"fetch-start-page">;
+    recipeId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Writes a recipe file from an edited outline: the server converts it back
+ * to the recipe's JSON (`scope-outline`'s `outlineToRecipe`) and saves it
+ * exactly as `save-recipe` would. Kept as its own command, rather than
+ * asking the Steps tab to run the outline↔recipe mappers itself, so that
+ * conversion stays server-side code (it already is: `@opencraw/studio`'s
+ * root export also carries Node-only slices, so the UI never imports
+ * runtime code from it, only types — see `apps/studio-ui`'s `steps-outline`
+ * for where this is called from).
+ */
+export declare const saveOutlineCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"save-outline">;
+    path: z.ZodString;
+    outline: z.ZodType<import("./outline-view.contract").OutlineView, unknown, z.core.$ZodTypeInternals<import("./outline-view.contract").OutlineView, unknown>>;
+}, z.core.$strip>;
+/**
+ * Captures the snapshot the content pane shows for a step (`page-snapshot`'s
+ * `take-snapshot.use-case.ts`), caching it by recipe and step path so
+ * switching the selected step does not always re-run the recipe.
+ */
+export declare const takeSnapshotCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"take-snapshot">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Verifies a candidate selector against the cached snapshot and, when
+ * reachable, the live page — the studio's own selection (`@opencraw/core`'s
+ * `countMatches`), never the browser's or a guess (issue #91).
+ */
+export declare const verifySelectorCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"verify-selector">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    selector: z.ZodString;
+}, z.core.$strip>;
+export declare const inferSelectorCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"infer-selector">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    nodeIds: z.ZodUnion<readonly [z.ZodTuple<[z.ZodString], null>, z.ZodTuple<[z.ZodString, z.ZodString], null>]>;
+}, z.core.$strip>;
+/**
+ * The Inspect panel's DOM tree and data-in-the-page findings, off the same
+ * cached snapshot `take-snapshot`/`infer-selector` already use (`page-inspector`,
+ * issue #93). Call `take-snapshot` first, same as `infer-selector`.
+ */
+export declare const inspectPageCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"inspect-page">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>;
+/**
+ * The JSON responses seen while a recipe's start page rendered
+ * (`page-inspector`'s `responses-seen.use-case.ts`, issue #93), for the
+ * Inspect panel's "responses seen" list. Opens its own browser session
+ * (see that use-case's doc comment for why); slower than `inspect-page`.
+ */
+export declare const responsesSeenCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"responses-seen">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>;
+/**
+ * The document tree for the content pane's tree canvas (`document-view`'s
+ * `tree-view.mapper.ts`, studio plan §3.4, issue #94's 5a), off the same
+ * cached snapshot `take-snapshot`/`inspect-page` already use — call
+ * `take-snapshot` first, same as `inspect-page`. Only a JSON/YAML/XML
+ * snapshot has one; PDF, workbook and deck documents get their own canvases
+ * (5b/5c/5d).
+ */
+export declare const documentTreeCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"document-tree">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>;
+/**
+ * The PDF canvas's cells and rows (`document-view`'s `pdf-view.mapper.ts`,
+ * studio plan §3.4, issue #94's 5b), off the same cached snapshot
+ * `take-snapshot`/`document-tree` already use — call `take-snapshot` first.
+ * Only a PDF snapshot has one; JSON/YAML/XML get the tree canvas (5a), the
+ * workbook and deck their own canvases (5c/5d).
+ */
+export declare const pdfViewCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"pdf-view">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>;
+/** A `table` extract's options, as the studio's PDF canvas picks build them — mirrors `document-view/table-preview.use-case.ts`'s `TablePreviewOptions`. */
+export declare const tablePreviewOptionsSchema: z.ZodObject<{
+    header: z.ZodString;
+    until: z.ZodOptional<z.ZodString>;
+    columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    align: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        bottom: "bottom";
+        center: "center";
+        top: "top";
+    }>>;
+}, z.core.$strip>;
+/**
+ * The live preview of a `table` extract's options against a cached PDF
+ * snapshot (`document-view`'s `table-preview.use-case.ts`, studio plan §3.4,
+ * issue #94's 5b): the matched rows to highlight on the page, recomputed as
+ * the person edits the options — call `take-snapshot` first.
+ */
+export declare const tablePreviewCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"table-preview">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    options: z.ZodObject<{
+        header: z.ZodString;
+        until: z.ZodOptional<z.ZodString>;
+        columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        align: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            bottom: "bottom";
+            center: "center";
+            top: "top";
+        }>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * The live preview of a `region` extract's selector against a cached PDF
+ * snapshot (`document-view`'s `region-preview.use-case.ts`, issue #121: the
+ * PDF canvas's click-to-snap selection): the text the step would bind and
+ * the cells to highlight, recomputed as the box changes — call
+ * `take-snapshot` first.
+ */
+export declare const regionPreviewCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"region-preview">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    selector: z.ZodString;
+}, z.core.$strip>;
+/**
+ * The grid canvas's sheets and cells (`document-view`'s `workbook-view.mapper.ts`,
+ * studio plan §3.4, issue #94's 5c), off the same cached snapshot
+ * `take-snapshot`/`document-tree` already use — call `take-snapshot` first.
+ * Only a CSV/spreadsheet snapshot has one; JSON/YAML/XML get the tree canvas
+ * (5a), PDF the PDF canvas (5b), the deck its own canvas (5d).
+ *
+ * `delimiter`/`encoding` override a CSV's auto-detected format (issue #94's
+ * 5c: "the detected delimiter and encoding shown and overridable"); the
+ * server re-reads the file with the override applied and keeps it cached, so
+ * a later `grid-preview` sees the same reading. Both are rejected on a
+ * spreadsheet snapshot (there is nothing to detect).
+ */
+export declare const gridViewCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"grid-view">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    delimiter: z.ZodOptional<z.ZodString>;
+    encoding: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** A `table` extract's options for a workbook, as the studio's grid canvas picks build them — mirrors `document-view/table-preview.use-case.ts`'s `GridTablePreviewOptions`. */
+export declare const gridPreviewOptionsSchema: z.ZodObject<{
+    sheet: z.ZodOptional<z.ZodString>;
+    header: z.ZodString;
+    until: z.ZodOptional<z.ZodString>;
+    columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    headerRows: z.ZodOptional<z.ZodInt>;
+    fillDown: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    includeHidden: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * The live preview of a `table` extract's options against a cached CSV/
+ * spreadsheet snapshot (`document-view`'s `table-preview.use-case.ts`'s
+ * `previewGridTable`, studio plan §3.4, issue #94's 5c): the matched
+ * table(s), recomputed as the person edits the options — call `take-snapshot`
+ * and `grid-view` first.
+ */
+export declare const gridPreviewCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"grid-preview">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    options: z.ZodObject<{
+        sheet: z.ZodOptional<z.ZodString>;
+        header: z.ZodString;
+        until: z.ZodOptional<z.ZodString>;
+        columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        headerRows: z.ZodOptional<z.ZodInt>;
+        fillDown: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        includeHidden: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * The deck canvas's slides, shapes, tables, charts and notes for a deck
+ * (PowerPoint) snapshot (`document-view`'s `deck-view.mapper.ts`, studio plan
+ * §3.4, issue #94's 5d), off the same cached snapshot
+ * `take-snapshot`/`document-tree` already use — call `take-snapshot` first.
+ * Only a `.pptx` snapshot has one; JSON/YAML/XML get the tree canvas (5a),
+ * PDF the PDF canvas (5b), the workbook the grid canvas (5c).
+ */
+export declare const deckViewCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"deck-view">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>;
+/** A `table` extract's options for a deck, as the studio's deck canvas picks build them — mirrors `document-view/table-preview.use-case.ts`'s `DeckTablePreviewOptions`. */
+export declare const deckPreviewOptionsSchema: z.ZodObject<{
+    slide: z.ZodOptional<z.ZodString>;
+    shapes: z.ZodOptional<z.ZodBoolean>;
+    align: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        bottom: "bottom";
+        center: "center";
+        top: "top";
+    }>>;
+    header: z.ZodString;
+    until: z.ZodOptional<z.ZodString>;
+    columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    headerRows: z.ZodOptional<z.ZodInt>;
+    fillDown: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    includeHidden: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * The live preview of a `table` extract's options against a cached deck
+ * snapshot (`document-view`'s `table-preview.use-case.ts`'s `previewDeckTable`,
+ * studio plan §3.4, issue #94's 5d): the matched table(s), recomputed as the
+ * person edits the options — call `take-snapshot` and `deck-view` first.
+ */
+export declare const deckPreviewCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"deck-preview">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    options: z.ZodObject<{
+        slide: z.ZodOptional<z.ZodString>;
+        shapes: z.ZodOptional<z.ZodBoolean>;
+        align: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            bottom: "bottom";
+            center: "center";
+            top: "top";
+        }>>;
+        header: z.ZodString;
+        until: z.ZodOptional<z.ZodString>;
+        columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        headerRows: z.ZodOptional<z.ZodInt>;
+        fillDown: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        includeHidden: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** A missing value in an emitted record, by its position in the last sample run's records (the order they streamed in, matching the UI's own `records` list). */
+export declare const missingWhyTargetSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"missing">;
+    recipeId: z.ZodString;
+    recordIndex: z.ZodInt;
+    field: z.ZodString;
+}, z.core.$strip>;
+/** A rejected record, by its position in the last sample run's `rejectedRecords`. */
+export declare const rejectedWhyTargetSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"rejected">;
+    recipeId: z.ZodString;
+    rejectedIndex: z.ZodInt;
+}, z.core.$strip>;
+export declare const whyTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"missing">;
+    recipeId: z.ZodString;
+    recordIndex: z.ZodInt;
+    field: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"rejected">;
+    recipeId: z.ZodString;
+    rejectedIndex: z.ZodInt;
+}, z.core.$strip>], "kind">;
+/**
+ * Explains one missing or rejected value from the recipe's last sample run
+ * (`explain-why.use-case.ts`, issue #92's Why? tab): the mapping trace and
+ * scope snapshot `run-sample` already kept, the step that bound the value's
+ * source id and whether it ran, was skipped or found nothing, and the
+ * missing-value policy that applied.
+ */
+export declare const explainWhyCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"explain-why">;
+    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"missing">;
+        recipeId: z.ZodString;
+        recordIndex: z.ZodInt;
+        field: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"rejected">;
+        recipeId: z.ZodString;
+        rejectedIndex: z.ZodInt;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+/**
+ * Opens the studio's own headed browser window and starts recording user
+ * actions on it (issue #95, phase 6): clicks, fills, selects, key presses
+ * and scrolls stream back as `recording-card` events, each already a
+ * verified step. `recipeId`'s start point is where the window opens.
+ */
+export declare const startRecordingCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"start-recording">;
+    recipeId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Closes the recording window, if one is open; a no-op otherwise. Answers
+ * with every step recorded, in order, so the caller can offer "make this
+ * the login" (writes them under `session.bootstrap`) or "keep as steps"
+ * (appends them to the recipe's own `steps`) without a second round trip.
+ */
+export declare const stopRecordingCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"stop-recording">;
+}, z.core.$strip>;
+/**
+ * Copies a document the person dropped on (or opened in) the studio into a
+ * workspace folder, so a recipe can point at it with a `file:` URL (issue
+ * #120). The bytes travel base64-encoded inside the JSON command envelope
+ * every other command uses: a local tool's own files are a few megabytes at
+ * most, not worth a second, multipart endpoint. `folder` is created when it
+ * does not exist yet, so a dropped file can also start a workspace; `name`
+ * is a plain file name (no directories), kept as the copy's name unless one
+ * is already there, in which case a numbered one is used.
+ */
+export declare const importDocumentCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"import-document">;
+    folder: z.ZodString;
+    name: z.ZodString;
+    bytes: z.ZodString;
+}, z.core.$strip>;
+export declare const studioCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"open-workspace">;
+    folder: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"import-document">;
+    folder: z.ZodString;
+    name: z.ZodString;
+    bytes: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"run-sample">;
+    recipeId: z.ZodString;
+    budget: z.ZodOptional<z.ZodObject<{
+        maxRecords: z.ZodOptional<z.ZodNumber>;
+        maxPages: z.ZodOptional<z.ZodNumber>;
+        maxMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"stop-run">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"save-recipe">;
+    path: z.ZodString;
+    recipe: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"fetch-start-page">;
+    recipeId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"save-outline">;
+    path: z.ZodString;
+    outline: z.ZodType<import("./outline-view.contract").OutlineView, unknown, z.core.$ZodTypeInternals<import("./outline-view.contract").OutlineView, unknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"take-snapshot">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"verify-selector">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    selector: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"infer-selector">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    nodeIds: z.ZodUnion<readonly [z.ZodTuple<[z.ZodString], null>, z.ZodTuple<[z.ZodString, z.ZodString], null>]>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"explain-why">;
+    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"missing">;
+        recipeId: z.ZodString;
+        recordIndex: z.ZodInt;
+        field: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"rejected">;
+        recipeId: z.ZodString;
+        rejectedIndex: z.ZodInt;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"inspect-page">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"responses-seen">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"document-tree">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"pdf-view">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"table-preview">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    options: z.ZodObject<{
+        header: z.ZodString;
+        until: z.ZodOptional<z.ZodString>;
+        columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        align: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            bottom: "bottom";
+            center: "center";
+            top: "top";
+        }>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"region-preview">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    selector: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"grid-view">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    delimiter: z.ZodOptional<z.ZodString>;
+    encoding: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"grid-preview">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    options: z.ZodObject<{
+        sheet: z.ZodOptional<z.ZodString>;
+        header: z.ZodString;
+        until: z.ZodOptional<z.ZodString>;
+        columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        headerRows: z.ZodOptional<z.ZodInt>;
+        fillDown: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        includeHidden: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"deck-view">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"deck-preview">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    options: z.ZodObject<{
+        slide: z.ZodOptional<z.ZodString>;
+        shapes: z.ZodOptional<z.ZodBoolean>;
+        align: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            bottom: "bottom";
+            center: "center";
+            top: "top";
+        }>>;
+        header: z.ZodString;
+        until: z.ZodOptional<z.ZodString>;
+        columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        headerRows: z.ZodOptional<z.ZodInt>;
+        fillDown: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        includeHidden: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"start-recording">;
+    recipeId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"stop-recording">;
+}, z.core.$strip>], "type">;
+export type SampleBudget = z.infer<typeof sampleBudgetSchema>;
+export type OpenWorkspaceCommand = z.infer<typeof openWorkspaceCommandSchema>;
+export type ImportDocumentCommand = z.infer<typeof importDocumentCommandSchema>;
+export type RunSampleCommand = z.infer<typeof runSampleCommandSchema>;
+export type StopRunCommand = z.infer<typeof stopRunCommandSchema>;
+export type SaveRecipeCommand = z.infer<typeof saveRecipeCommandSchema>;
+export type FetchStartPageCommand = z.infer<typeof fetchStartPageCommandSchema>;
+export type SaveOutlineCommand = z.infer<typeof saveOutlineCommandSchema>;
+export type TakeSnapshotCommand = z.infer<typeof takeSnapshotCommandSchema>;
+export type VerifySelectorCommand = z.infer<typeof verifySelectorCommandSchema>;
+export type InferSelectorCommand = z.infer<typeof inferSelectorCommandSchema>;
+export type InspectPageCommand = z.infer<typeof inspectPageCommandSchema>;
+export type ResponsesSeenCommand = z.infer<typeof responsesSeenCommandSchema>;
+export type DocumentTreeCommand = z.infer<typeof documentTreeCommandSchema>;
+export type PdfViewCommand = z.infer<typeof pdfViewCommandSchema>;
+export type TablePreviewOptions = z.infer<typeof tablePreviewOptionsSchema>;
+export type TablePreviewCommand = z.infer<typeof tablePreviewCommandSchema>;
+export type RegionPreviewCommand = z.infer<typeof regionPreviewCommandSchema>;
+export type GridViewCommand = z.infer<typeof gridViewCommandSchema>;
+export type GridPreviewOptions = z.infer<typeof gridPreviewOptionsSchema>;
+export type GridPreviewCommand = z.infer<typeof gridPreviewCommandSchema>;
+export type DeckViewCommand = z.infer<typeof deckViewCommandSchema>;
+export type DeckPreviewOptions = z.infer<typeof deckPreviewOptionsSchema>;
+export type DeckPreviewCommand = z.infer<typeof deckPreviewCommandSchema>;
+export type MissingWhyTarget = z.infer<typeof missingWhyTargetSchema>;
+export type RejectedWhyTarget = z.infer<typeof rejectedWhyTargetSchema>;
+export type WhyTarget = z.infer<typeof whyTargetSchema>;
+export type ExplainWhyCommand = z.infer<typeof explainWhyCommandSchema>;
+export type StartRecordingCommand = z.infer<typeof startRecordingCommandSchema>;
+export type StopRecordingCommand = z.infer<typeof stopRecordingCommandSchema>;
+/** Every command the UI can send the server, over HTTP POST. */
+export type StudioCommand = z.infer<typeof studioCommandSchema>;
+//# sourceMappingURL=command.contract.d.ts.map

package/dist/studio-api/deck-preview-view.contract.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+/** One table matched by a `table` extract's options against a deck — mirrors `@opencraw/core`'s `DeckTable`. */
+export declare const deckTablePreviewMatchSchema: z.ZodObject<{
+    slide: z.ZodNumber;
+    slideTitle: z.ZodString;
+    title: z.ZodString;
+    header: z.ZodArray<z.ZodString>;
+    rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+}, z.core.$strip>;
+/**
+ * What `deck-preview` answers with (studio plan §3.4, issue #94's 5d: the
+ * live preview): every matched table, or `error` when a pattern in the
+ * options does not compile — expected while the person is still typing it,
+ * not thrown.
+ */
+export declare const deckTablePreviewViewSchema: z.ZodObject<{
+    matches: z.ZodArray<z.ZodObject<{
+        slide: z.ZodNumber;
+        slideTitle: z.ZodString;
+        title: z.ZodString;
+        header: z.ZodArray<z.ZodString>;
+        rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DeckTablePreviewMatchView = z.infer<typeof deckTablePreviewMatchSchema>;
+export type DeckTablePreviewView = z.infer<typeof deckTablePreviewViewSchema>;
+//# sourceMappingURL=deck-preview-view.contract.d.ts.map