@opencraw/studio 0.0.7 → 0.0.9

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

@@ -77,6 +77,194 @@ export declare const inferSelectorCommandSchema: z.ZodObject<{
     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";
+        top: "top";
+        center: "center";
+        bottom: "bottom";
+    }>>;
+}, 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";
+            top: "top";
+            center: "center";
+            bottom: "bottom";
+        }>>;
+    }, z.core.$strip>;
+}, 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";
+        top: "top";
+        center: "center";
+        bottom: "bottom";
+    }>>;
+    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";
+            top: "top";
+            center: "center";
+            bottom: "bottom";
+        }>>;
+        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">;
@@ -120,6 +308,25 @@ export declare const explainWhyCommandSchema: z.ZodObject<{
         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>;
 export declare const studioCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"open-workspace">;
     folder: z.ZodString;
@@ -170,6 +377,85 @@ export declare const studioCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         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";
+            top: "top";
+            center: "center";
+            bottom: "bottom";
+        }>>;
+    }, z.core.$strip>;
+}, 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";
+            top: "top";
+            center: "center";
+            bottom: "bottom";
+        }>>;
+        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>;
@@ -181,10 +467,24 @@ 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 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/src/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

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

@@ -0,0 +1,127 @@
+import { z } from 'zod';
+/** One text box on a slide, in points — mirrors `document-view/deck-view.mapper.ts`'s `DeckShapeView`, the wire shape for the UI (studio plan §3.4, issue #94's 5d). */
+export declare const deckShapeViewSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    text: z.ZodString;
+    placeholder: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const deckChartSeriesViewSchema: z.ZodObject<{
+    name: z.ZodString;
+    categories: z.ZodArray<z.ZodString>;
+    values: z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>;
+}, z.core.$strip>;
+export declare const deckChartViewSchema: z.ZodObject<{
+    type: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    series: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        categories: z.ZodArray<z.ZodString>;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const deckSlideViewSchema: z.ZodObject<{
+    number: z.ZodNumber;
+    title: z.ZodOptional<z.ZodString>;
+    hidden: z.ZodBoolean;
+    shapes: z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        text: z.ZodString;
+        placeholder: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    shapeRows: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+    tables: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        hidden: z.ZodBoolean;
+        hiddenRows: z.ZodArray<z.ZodNumber>;
+        columnCount: z.ZodNumber;
+        rows: z.ZodArray<z.ZodArray<z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                date: "date";
+            }>;
+        }, z.core.$strip>>>;
+        merges: z.ZodArray<z.ZodObject<{
+            ref: z.ZodString;
+            top: z.ZodNumber;
+            left: z.ZodNumber;
+            bottom: z.ZodNumber;
+            right: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    charts: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        series: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            categories: z.ZodArray<z.ZodString>;
+            values: z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    notes: z.ZodString;
+}, z.core.$strip>;
+/** What `deck-view` answers with (studio plan §3.4, issue #94's 5d): the slide size in points and every slide's shapes, tables, charts and notes, for the deck canvas to draw and pick from. */
+export declare const deckDocumentViewSchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    slides: z.ZodArray<z.ZodObject<{
+        number: z.ZodNumber;
+        title: z.ZodOptional<z.ZodString>;
+        hidden: z.ZodBoolean;
+        shapes: z.ZodArray<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            text: z.ZodString;
+            placeholder: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        shapeRows: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+        tables: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            hidden: z.ZodBoolean;
+            hiddenRows: z.ZodArray<z.ZodNumber>;
+            columnCount: z.ZodNumber;
+            rows: z.ZodArray<z.ZodArray<z.ZodObject<{
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    date: "date";
+                }>;
+            }, z.core.$strip>>>;
+            merges: z.ZodArray<z.ZodObject<{
+                ref: z.ZodString;
+                top: z.ZodNumber;
+                left: z.ZodNumber;
+                bottom: z.ZodNumber;
+                right: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        charts: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            series: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                categories: z.ZodArray<z.ZodString>;
+                values: z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        notes: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DeckShapeView = z.infer<typeof deckShapeViewSchema>;
+export type DeckChartSeriesView = z.infer<typeof deckChartSeriesViewSchema>;
+export type DeckChartView = z.infer<typeof deckChartViewSchema>;
+export type DeckSlideView = z.infer<typeof deckSlideViewSchema>;
+export type DeckDocumentView = z.infer<typeof deckDocumentViewSchema>;
+//# sourceMappingURL=deck-view.contract.d.ts.map

package/dist/src/studio-api/document-tree-view.contract.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+/** One row of the document tree — mirrors `document-view/tree-view.mapper.ts`'s `DocumentTreeNode`, the wire shape for the UI (studio plan §3.4, issue #94's 5a). */
+export interface DocumentTreeNodeView {
+    id: string;
+    label: string;
+    valueType: 'object' | 'array' | 'string' | 'number' | 'boolean' | 'null' | 'element';
+    preview?: string;
+    jsonpath?: string;
+    xpath?: string;
+    listPath?: string;
+    listCount?: number;
+    attributes?: Record<string, string>;
+    children: DocumentTreeNodeView[];
+}
+export declare const documentTreeNodeViewSchema: z.ZodType<DocumentTreeNodeView>;
+/** What `document-tree` answers with (studio plan §3.4, issue #94's 5a): the parsed JSON/XML document as a tree, and, for XML, the namespace prefixes a pick's `extract` can use in `namespaces`. */
+export declare const documentTreeViewSchema: z.ZodObject<{
+    format: z.ZodEnum<{
+        json: "json";
+        xml: "xml";
+    }>;
+    root: z.ZodType<DocumentTreeNodeView, unknown, z.core.$ZodTypeInternals<DocumentTreeNodeView, unknown>>;
+    namespaces: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type DocumentTreeView = z.infer<typeof documentTreeViewSchema>;
+//# sourceMappingURL=document-tree-view.contract.d.ts.map

package/dist/src/studio-api/event.contract.d.ts

@@ -60,6 +60,33 @@ export declare const runFinishedEventSchema: z.ZodObject<{
 export declare const workspaceChangedEventSchema: z.ZodObject<{
     type: z.ZodLiteral<"workspace-changed">;
 }, z.core.$strip>;
+/**
+ * One recorded action landed as a step (issue #95): the card it becomes
+ * (`scope-outline`'s own `OutlineCard`/`OutlineBracket` shape — the wire
+ * form `outline-view.contract.ts` already defines, never a second card
+ * format) and whether its value is a secret placeholder, for the secret
+ * pill styling.
+ */
+export declare const recordingCardEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"recording-card">;
+    node: z.ZodType<import("./outline-view.contract").OutlineNode, unknown, z.core.$ZodTypeInternals<import("./outline-view.contract").OutlineNode, unknown>>;
+    secret: z.ZodBoolean;
+}, z.core.$strip>;
+/** A notice from the recording session that is not itself a step: a "next" link offer, or an unsupported iframe/shadow-DOM report. */
+export declare const recordingNoteEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"recording-note">;
+    kind: z.ZodEnum<{
+        unsupported: "unsupported";
+        "next-link": "next-link";
+        info: "info";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>;
+/** The recording window closed — `stop-recording` completed, or the window was closed some other way. `steps` is every step recorded, in order, exactly as `stop-recording`'s own response carries them. */
+export declare const recordingStoppedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"recording-stopped">;
+    steps: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
 export declare const studioEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"trace-line">;
     line: z.ZodString;
@@ -97,6 +124,21 @@ export declare const studioEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }>>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"workspace-changed">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"recording-card">;
+    node: z.ZodType<import("./outline-view.contract").OutlineNode, unknown, z.core.$ZodTypeInternals<import("./outline-view.contract").OutlineNode, unknown>>;
+    secret: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"recording-note">;
+    kind: z.ZodEnum<{
+        unsupported: "unsupported";
+        "next-link": "next-link";
+        info: "info";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"recording-stopped">;
+    steps: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>], "type">;
 export type StoppedBy = z.infer<typeof stoppedBySchema>;
 export type TraceLineEvent = z.infer<typeof traceLineEventSchema>;
@@ -105,6 +147,9 @@ export type RecordEvent = z.infer<typeof recordEventSchema>;
 export type RecordRejectedEvent = z.infer<typeof recordRejectedEventSchema>;
 export type RunFinishedEvent = z.infer<typeof runFinishedEventSchema>;
 export type WorkspaceChangedEvent = z.infer<typeof workspaceChangedEventSchema>;
+export type RecordingCardEvent = z.infer<typeof recordingCardEventSchema>;
+export type RecordingNoteEvent = z.infer<typeof recordingNoteEventSchema>;
+export type RecordingStoppedEvent = z.infer<typeof recordingStoppedEventSchema>;
 /** Every event the server pushes to the UI over the WebSocket. */
 export type StudioEvent = z.infer<typeof studioEventSchema>;
 //# sourceMappingURL=event.contract.d.ts.map

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

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+/** One table matched by a `table` extract's options against a workbook — mirrors `@opencraw/core`'s `GridTable`. */
+export declare const gridTablePreviewMatchSchema: z.ZodObject<{
+    sheet: 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 `grid-preview` answers with (studio plan §3.4, issue #94's 5c: 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 gridTablePreviewViewSchema: z.ZodObject<{
+    matches: z.ZodArray<z.ZodObject<{
+        sheet: 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 GridTablePreviewMatchView = z.infer<typeof gridTablePreviewMatchSchema>;
+export type GridTablePreviewView = z.infer<typeof gridTablePreviewViewSchema>;
+//# sourceMappingURL=grid-preview-view.contract.d.ts.map