@opencraw/studio 0.0.6 → 0.0.8

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

@@ -10,12 +10,36 @@ export declare const traceLineEventSchema: z.ZodObject<{
     type: z.ZodLiteral<"trace-line">;
     line: z.ZodString;
 }, z.core.$strip>;
-/** One record a sample run emitted. */
+/** One entry of a mapping trace field: what a rule's `from` read, and the value after each transform, in order (`@opencraw/core`'s `FieldTrace`). */
+export declare const fieldTraceSchema: z.ZodObject<{
+    from: z.ZodUnknown;
+    steps: z.ZodArray<z.ZodObject<{
+        op: z.ZodString;
+        value: z.ZodUnknown;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** One record a sample run emitted: `scope` (what it was mapped from) and `mapping` (each field's trace) ride along, so the Record tab (#92) can show a transform chain's real values without a second round trip. */
 export declare const recordEventSchema: z.ZodObject<{
     type: z.ZodLiteral<"record">;
     recipeId: z.ZodString;
     key: z.ZodNullable<z.ZodString>;
     data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    scope: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    mapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        from: z.ZodUnknown;
+        steps: z.ZodArray<z.ZodObject<{
+            op: z.ZodString;
+            value: z.ZodUnknown;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** One record a sample run rejected (a field's `skip-record` policy on a missing or uncoercible value). */
+export declare const recordRejectedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"record-rejected">;
+    recipeId: z.ZodString;
+    field: z.ZodString;
+    reason: z.ZodString;
+    scope: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 /** A sample run ended: how many records, and why it stopped when it did not finish on its own. */
 export declare const runFinishedEventSchema: z.ZodObject<{
@@ -36,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;
@@ -44,6 +95,20 @@ export declare const studioEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     recipeId: z.ZodString;
     key: z.ZodNullable<z.ZodString>;
     data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    scope: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    mapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        from: z.ZodUnknown;
+        steps: z.ZodArray<z.ZodObject<{
+            op: z.ZodString;
+            value: z.ZodUnknown;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"record-rejected">;
+    recipeId: z.ZodString;
+    field: z.ZodString;
+    reason: z.ZodString;
+    scope: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"run-finished">;
     recipeId: z.ZodString;
@@ -59,12 +124,32 @@ 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>;
+export type FieldTraceView = z.infer<typeof fieldTraceSchema>;
 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

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

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+/** One cell's value, and the type the grid shows it as — mirrors `document-view/workbook-view.mapper.ts`'s `GridCellView`, the wire shape for the UI (studio plan §3.4, issue #94's 5c). */
+export declare const gridCellViewSchema: 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>;
+/** One merged range, 0-based and inclusive. */
+export declare const gridMergeViewSchema: z.ZodObject<{
+    ref: z.ZodString;
+    top: z.ZodNumber;
+    left: z.ZodNumber;
+    bottom: z.ZodNumber;
+    right: z.ZodNumber;
+}, z.core.$strip>;
+export declare const gridSheetViewSchema: 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>;
+/** What `grid-view` answers with (studio plan §3.4, issue #94's 5c): every sheet's cells, typed, with hidden sheets/rows marked and merged ranges resolved, for the grid canvas to draw. */
+export declare const workbookDocumentViewSchema: z.ZodObject<{
+    sheets: 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>>;
+    csv: z.ZodOptional<z.ZodObject<{
+        encoding: z.ZodString;
+        delimiter: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type GridCellView = z.infer<typeof gridCellViewSchema>;
+export type GridMergeView = z.infer<typeof gridMergeViewSchema>;
+export type GridSheetView = z.infer<typeof gridSheetViewSchema>;
+export type WorkbookDocumentView = z.infer<typeof workbookDocumentViewSchema>;
+//# sourceMappingURL=grid-view.contract.d.ts.map

package/dist/src/studio-api/index.d.ts

@@ -1,13 +1,13 @@
-export { sampleBudgetSchema, openWorkspaceCommandSchema, runSampleCommandSchema, stopRunCommandSchema, saveRecipeCommandSchema, fetchStartPageCommandSchema, saveOutlineCommandSchema, takeSnapshotCommandSchema, verifySelectorCommandSchema, inferSelectorCommandSchema, studioCommandSchema } from './command.contract.js';
-export type { SampleBudget, OpenWorkspaceCommand, RunSampleCommand, StopRunCommand, SaveRecipeCommand, FetchStartPageCommand, SaveOutlineCommand, TakeSnapshotCommand, VerifySelectorCommand, InferSelectorCommand, StudioCommand } from './command.contract.js';
+export { sampleBudgetSchema, openWorkspaceCommandSchema, runSampleCommandSchema, stopRunCommandSchema, saveRecipeCommandSchema, fetchStartPageCommandSchema, saveOutlineCommandSchema, takeSnapshotCommandSchema, verifySelectorCommandSchema, inferSelectorCommandSchema, missingWhyTargetSchema, rejectedWhyTargetSchema, whyTargetSchema, explainWhyCommandSchema, inspectPageCommandSchema, responsesSeenCommandSchema, documentTreeCommandSchema, pdfViewCommandSchema, tablePreviewOptionsSchema, tablePreviewCommandSchema, gridViewCommandSchema, gridPreviewOptionsSchema, gridPreviewCommandSchema, deckViewCommandSchema, deckPreviewOptionsSchema, deckPreviewCommandSchema, startRecordingCommandSchema, stopRecordingCommandSchema, studioCommandSchema } from './command.contract.js';
+export type { SampleBudget, OpenWorkspaceCommand, RunSampleCommand, StopRunCommand, SaveRecipeCommand, FetchStartPageCommand, SaveOutlineCommand, TakeSnapshotCommand, VerifySelectorCommand, InferSelectorCommand, MissingWhyTarget, RejectedWhyTarget, WhyTarget, ExplainWhyCommand, InspectPageCommand, ResponsesSeenCommand, DocumentTreeCommand, PdfViewCommand, TablePreviewOptions, TablePreviewCommand, GridViewCommand, GridPreviewOptions, GridPreviewCommand, DeckViewCommand, DeckPreviewOptions, DeckPreviewCommand, StartRecordingCommand, StopRecordingCommand, StudioCommand } from './command.contract.js';
 export { snapshotViewSchema } from './snapshot-view.contract.js';
 export type { SnapshotView } from './snapshot-view.contract.js';
 export { verifySelectorViewSchema } from './verify-selector-view.contract.js';
 export type { VerifySelectorView } from './verify-selector-view.contract.js';
 export { fieldPickSchema, inferSelectorViewSchema } from './infer-selector-view.contract.js';
 export type { FieldPick, InferSelectorView } from './infer-selector-view.contract.js';
-export { stoppedBySchema, traceLineEventSchema, recordEventSchema, runFinishedEventSchema, workspaceChangedEventSchema, studioEventSchema } from './event.contract.js';
-export type { StoppedBy, TraceLineEvent, RecordEvent, RunFinishedEvent, WorkspaceChangedEvent, StudioEvent } from './event.contract.js';
+export { stoppedBySchema, fieldTraceSchema, traceLineEventSchema, recordEventSchema, recordRejectedEventSchema, runFinishedEventSchema, workspaceChangedEventSchema, recordingCardEventSchema, recordingNoteEventSchema, recordingStoppedEventSchema, studioEventSchema } from './event.contract.js';
+export type { StoppedBy, FieldTraceView, TraceLineEvent, RecordEvent, RecordRejectedEvent, RunFinishedEvent, WorkspaceChangedEvent, RecordingCardEvent, RecordingNoteEvent, RecordingStoppedEvent, StudioEvent } from './event.contract.js';
 export { recipeIssueSchema, recipeListingSchema, workspaceViewSchema } from './workspace-view.contract.js';
 export type { RecipeIssue, RecipeListing, WorkspaceView } from './workspace-view.contract.js';
 export { sampleRunRecordSchema, sampleRunViewSchema } from './sample-run-view.contract.js';
@@ -16,4 +16,24 @@ export { startPageViewSchema } from './start-page-view.contract.js';
 export type { StartPageView } from './start-page-view.contract.js';
 export { sentencePartSchema, outlineCardSchema, outlineBracketSchema, outlineNodeSchema, outlineViewSchema } from './outline-view.contract.js';
 export type { SentencePart, OutlineCard, OutlineBracket, OutlineNode, OutlineView } from './outline-view.contract.js';
+export { whyViewSchema } from './why-view.contract.js';
+export type { WhyView } from './why-view.contract.js';
+export { domTreeNodeViewSchema, pageDataFindingSchema, inspectViewSchema } from './inspect-view.contract.js';
+export type { DomTreeNodeView, PageDataKind, PageDataFindingView, InspectView } from './inspect-view.contract.js';
+export { observedResponseSchema, responsesSeenViewSchema } from './responses-seen-view.contract.js';
+export type { ObservedResponseView, ResponsesSeenView } from './responses-seen-view.contract.js';
+export { documentTreeNodeViewSchema, documentTreeViewSchema } from './document-tree-view.contract.js';
+export type { DocumentTreeNodeView, DocumentTreeView } from './document-tree-view.contract.js';
+export { pdfCellViewSchema, pdfRowViewSchema, pdfPageViewSchema, pdfDocumentViewSchema } from './pdf-view.contract.js';
+export type { PdfCellView, PdfRowView, PdfPageView, PdfDocumentView } from './pdf-view.contract.js';
+export { tablePreviewTableSchema, tablePreviewBandSchema, tablePreviewMatchSchema, tablePreviewViewSchema } from './table-preview-view.contract.js';
+export type { TablePreviewTableView, TablePreviewBandView, TablePreviewMatchView, TablePreviewView } from './table-preview-view.contract.js';
+export { gridCellViewSchema, gridMergeViewSchema, gridSheetViewSchema, workbookDocumentViewSchema } from './grid-view.contract.js';
+export type { GridCellView, GridMergeView, GridSheetView, WorkbookDocumentView } from './grid-view.contract.js';
+export { gridTablePreviewMatchSchema, gridTablePreviewViewSchema } from './grid-preview-view.contract.js';
+export type { GridTablePreviewMatchView, GridTablePreviewView } from './grid-preview-view.contract.js';
+export { deckShapeViewSchema, deckChartSeriesViewSchema, deckChartViewSchema, deckSlideViewSchema, deckDocumentViewSchema } from './deck-view.contract.js';
+export type { DeckShapeView, DeckChartSeriesView, DeckChartView, DeckSlideView, DeckDocumentView } from './deck-view.contract.js';
+export { deckTablePreviewMatchSchema, deckTablePreviewViewSchema } from './deck-preview-view.contract.js';
+export type { DeckTablePreviewMatchView, DeckTablePreviewView } from './deck-preview-view.contract.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+/** One row of the Inspect panel's DOM tree — mirrors `page-inspector/dom-tree.mapper.ts`'s `DomTreeNode`, the wire shape for the UI (issue #93). */
+export interface DomTreeNodeView {
+    nodeId: string;
+    tag: string;
+    id?: string;
+    classes?: string[];
+    attributes: Record<string, string>;
+    text?: string;
+    hidden: boolean;
+    children: DomTreeNodeView[];
+    repeatCount?: number;
+    repeatNodeIds?: string[];
+}
+export declare const domTreeNodeViewSchema: z.ZodType<DomTreeNodeView>;
+declare const pageDataKindSchema: z.ZodEnum<{
+    link: "link";
+    "ld-json": "ld-json";
+    "json-script": "json-script";
+    "inline-state": "inline-state";
+    meta: "meta";
+}>;
+/** One "data in the page" entry — mirrors `page-inspector/page-data.algorithm.ts`'s `PageDataFinding`. */
+export declare const pageDataFindingSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        link: "link";
+        "ld-json": "ld-json";
+        "json-script": "json-script";
+        "inline-state": "inline-state";
+        meta: "meta";
+    }>;
+    label: z.ZodString;
+    selector: z.ZodString;
+    selectorKind: z.ZodLiteral<"css">;
+    matches: z.ZodNumber;
+    keys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    attribute: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PageDataKind = z.infer<typeof pageDataKindSchema>;
+export type PageDataFindingView = z.infer<typeof pageDataFindingSchema>;
+/** What `inspect-page` answers with (studio plan §3.3, issue #93): the DOM tree and the data-in-the-page findings, in one round trip — both come from the same cached snapshot/raw capture, so there is no reason to ask twice. */
+export declare const inspectViewSchema: z.ZodObject<{
+    tree: z.ZodType<DomTreeNodeView, unknown, z.core.$ZodTypeInternals<DomTreeNodeView, unknown>>;
+    pageData: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            link: "link";
+            "ld-json": "ld-json";
+            "json-script": "json-script";
+            "inline-state": "inline-state";
+            meta: "meta";
+        }>;
+        label: z.ZodString;
+        selector: z.ZodString;
+        selectorKind: z.ZodLiteral<"css">;
+        matches: z.ZodNumber;
+        keys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        attribute: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type InspectView = z.infer<typeof inspectViewSchema>;
+export {};
+//# sourceMappingURL=inspect-view.contract.d.ts.map

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

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+/** One text cell, in PDF points — mirrors `document-view/pdf-view.mapper.ts`'s `PdfCellView`, the wire shape for the UI (studio plan §3.4, issue #94's 5b). */
+export declare const pdfCellViewSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const pdfRowViewSchema: z.ZodObject<{
+    top: z.ZodNumber;
+    bottom: z.ZodNumber;
+    cells: z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const pdfPageViewSchema: z.ZodObject<{
+    number: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    rows: z.ZodArray<z.ZodObject<{
+        top: z.ZodNumber;
+        bottom: z.ZodNumber;
+        cells: z.ZodArray<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            text: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    rowCount: z.ZodNumber;
+    cellCount: z.ZodNumber;
+    hasTextLayer: z.ZodBoolean;
+}, z.core.$strip>;
+/** What `pdf-view` answers with (studio plan §3.4, issue #94's 5b): every page's cells and rows, for the PDF canvas to draw over its own `pdf.js` rendering. */
+export declare const pdfDocumentViewSchema: z.ZodObject<{
+    pages: z.ZodArray<z.ZodObject<{
+        number: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        rows: z.ZodArray<z.ZodObject<{
+            top: z.ZodNumber;
+            bottom: z.ZodNumber;
+            cells: z.ZodArray<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+                text: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        rowCount: z.ZodNumber;
+        cellCount: z.ZodNumber;
+        hasTextLayer: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PdfCellView = z.infer<typeof pdfCellViewSchema>;
+export type PdfRowView = z.infer<typeof pdfRowViewSchema>;
+export type PdfPageView = z.infer<typeof pdfPageViewSchema>;
+export type PdfDocumentView = z.infer<typeof pdfDocumentViewSchema>;
+//# sourceMappingURL=pdf-view.contract.d.ts.map

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

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+/** One JSON response seen — mirrors `page-inspector/responses-seen.use-case.ts`'s `ObservedResponse`. */
+export declare const observedResponseSchema: z.ZodObject<{
+    url: z.ZodString;
+    status: z.ZodNumber;
+    size: z.ZodNumber;
+    shape: z.ZodString;
+}, z.core.$strip>;
+export type ObservedResponseView = z.infer<typeof observedResponseSchema>;
+/** What `responses-seen` answers with (studio plan §3.3, issue #93): the JSON responses the page fetched while it rendered, for the panel's "responses seen" list. */
+export declare const responsesSeenViewSchema: z.ZodObject<{
+    responses: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        status: z.ZodNumber;
+        size: z.ZodNumber;
+        shape: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ResponsesSeenView = z.infer<typeof responsesSeenViewSchema>;
+//# sourceMappingURL=responses-seen-view.contract.d.ts.map

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

@@ -1,9 +1,30 @@
 import { z } from 'zod';
-/** What `take-snapshot` answers with: the rewritten document ready for the content pane's sandboxed iframe (studio plan §3.1, issue #91). */
+/**
+ * What `take-snapshot` answers with: the rewritten document ready for the
+ * content pane's sandboxed iframe (studio plan §3.1, issue #91). `format`
+ * (api mode only; absent in web mode, whose document is always HTML) is
+ * what the content pane uses to choose a canvas — the snapshot iframe for
+ * `html` (and `docx`/`markdown`, already turned into HTML), else
+ * `document-view`'s tree/pdf/grid/deck canvas (studio plan §3.4, issue #94).
+ */
 export declare const snapshotViewSchema: z.ZodObject<{
     html: z.ZodString;
     nodeCount: z.ZodNumber;
     baseUrl: z.ZodString;
+    format: z.ZodOptional<z.ZodEnum<{
+        text: "text";
+        html: "html";
+        json: "json";
+        jsonl: "jsonl";
+        pdf: "pdf";
+        csv: "csv";
+        xlsx: "xlsx";
+        pptx: "pptx";
+        yaml: "yaml";
+        markdown: "markdown";
+        xml: "xml";
+        docx: "docx";
+    }>>;
 }, z.core.$strip>;
 export type SnapshotView = z.infer<typeof snapshotViewSchema>;
 //# sourceMappingURL=snapshot-view.contract.d.ts.map

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

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+/** One table matched by a `table` extract's options — mirrors `@opencraw/core`'s `PdfTable`. */
+export declare const tablePreviewTableSchema: z.ZodObject<{
+    page: z.ZodNumber;
+    title: z.ZodString;
+    header: z.ZodArray<z.ZodString>;
+    rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+/** One column band a matched table's body clustered into — mirrors `@opencraw/core`'s `TableBandDiagnostics`. */
+export declare const tablePreviewBandSchema: z.ZodObject<{
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+    column: z.ZodNumber;
+    name: z.ZodString;
+}, z.core.$strip>;
+/** One matched table, with the exact page rows to highlight — mirrors `document-view/table-preview.use-case.ts`'s `TablePreviewMatch`. */
+export declare const tablePreviewMatchSchema: z.ZodObject<{
+    page: z.ZodNumber;
+    headerRowIndex: z.ZodNumber;
+    matchedRowIndices: z.ZodArray<z.ZodNumber>;
+    bands: z.ZodArray<z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+        column: z.ZodNumber;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    bandTolerance: z.ZodNumber;
+    table: z.ZodObject<{
+        page: z.ZodNumber;
+        title: z.ZodString;
+        header: z.ZodArray<z.ZodString>;
+        rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * What `table-preview` answers with (studio plan §3.4, issue #94's 5b: the
+ * live preview): every match, or `error` when a pattern in the options does
+ * not compile — expected while the person is still typing it, not thrown.
+ */
+export declare const tablePreviewViewSchema: z.ZodObject<{
+    matches: z.ZodArray<z.ZodObject<{
+        page: z.ZodNumber;
+        headerRowIndex: z.ZodNumber;
+        matchedRowIndices: z.ZodArray<z.ZodNumber>;
+        bands: z.ZodArray<z.ZodObject<{
+            start: z.ZodNumber;
+            end: z.ZodNumber;
+            column: z.ZodNumber;
+            name: z.ZodString;
+        }, z.core.$strip>>;
+        bandTolerance: z.ZodNumber;
+        table: z.ZodObject<{
+            page: z.ZodNumber;
+            title: z.ZodString;
+            header: z.ZodArray<z.ZodString>;
+            rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TablePreviewTableView = z.infer<typeof tablePreviewTableSchema>;
+export type TablePreviewBandView = z.infer<typeof tablePreviewBandSchema>;
+export type TablePreviewMatchView = z.infer<typeof tablePreviewMatchSchema>;
+export type TablePreviewView = z.infer<typeof tablePreviewViewSchema>;
+//# sourceMappingURL=table-preview-view.contract.d.ts.map

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+/** What `explain-why` answers with: the sentence (`why-sentence.mapper.ts`'s `buildWhySentence`), plus the structured facts a click can act on — a link back to the step that bound the value, the policy that applied. */
+export declare const whyViewSchema: z.ZodObject<{
+    sentence: z.ZodString;
+    field: z.ZodString;
+    recipeId: z.ZodString;
+    outcome: z.ZodEnum<{
+        missing: "missing";
+        rejected: "rejected";
+    }>;
+    stepPath: z.ZodOptional<z.ZodString>;
+    policy: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type WhyView = z.infer<typeof whyViewSchema>;
+//# sourceMappingURL=why-view.contract.d.ts.map

package/dist/src/studio-server/deck-preview.handler.d.ts

@@ -0,0 +1,17 @@
+import type { DeckPreviewCommand, DeckTablePreviewView } from '../studio-api/index.js';
+import type { StudioState } from './workspace.store.js';
+/**
+ * Handles `deck-preview`: the deck canvas's live preview of a `table`
+ * extract's options (`document-view`'s `table-preview.use-case.ts`'s
+ * `previewDeckTable`, studio plan §3.4, issue #94's 5d), off the same cached
+ * snapshot `take-snapshot`/`deck-view` already captured — a pure computation
+ * over it, so this answers instantly on every option change, no re-fetch or
+ * re-parse.
+ *
+ * @param state - The server state.
+ * @param command - The command; `command.path` must already have a cached snapshot (call `take-snapshot` first).
+ * @returns The matched tables, or `error` when an option's pattern does not compile.
+ * @throws Error when no workspace is open, or `command.path` has no cached snapshot yet.
+ */
+export declare function handleDeckPreview(state: StudioState, command: DeckPreviewCommand): DeckTablePreviewView;
+//# sourceMappingURL=deck-preview.handler.d.ts.map

package/dist/src/studio-server/deck-view.handler.d.ts

@@ -0,0 +1,15 @@
+import type { DeckDocumentView, DeckViewCommand } from '../studio-api/index.js';
+import type { StudioState } from './workspace.store.js';
+/**
+ * Handles `deck-view`: the deck canvas's slides, shapes, tables, charts and
+ * notes (`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.
+ *
+ * @param state - The server state.
+ * @param command - The command; `command.path` must already have a cached snapshot (call `take-snapshot` first).
+ * @returns The document's view.
+ * @throws Error when no workspace is open, `command.path` has no cached snapshot yet, or the snapshot's document is not a read deck.
+ */
+export declare function handleDeckView(state: StudioState, command: DeckViewCommand): DeckDocumentView;
+//# sourceMappingURL=deck-view.handler.d.ts.map

package/dist/src/studio-server/document-tree.handler.d.ts

@@ -0,0 +1,14 @@
+import type { DocumentTreeCommand, DocumentTreeView } from '../studio-api/index.js';
+import type { StudioState } from './workspace.store.js';
+/**
+ * Handles `document-tree`: the content pane's tree canvas for a JSON, YAML
+ * or XML document (`document-view`, studio plan §3.4, issue #94's 5a), off
+ * the same cached snapshot `take-snapshot`/`inspect-page` already use.
+ *
+ * @param state - The server state.
+ * @param command - The command; `command.path` must already have a cached snapshot (call `take-snapshot` first).
+ * @returns The tree.
+ * @throws Error when no workspace is open, `command.path` has no cached snapshot yet, or the snapshot's document is not JSON/YAML/XML (no parsed body at all in web mode; PDF/workbook/deck in api mode — see `documentTreeView`'s own doc comment).
+ */
+export declare function handleDocumentTree(state: StudioState, command: DocumentTreeCommand): DocumentTreeView;
+//# sourceMappingURL=document-tree.handler.d.ts.map

package/dist/src/studio-server/explain-why.handler.d.ts

@@ -0,0 +1,14 @@
+import type { ExplainWhyCommand, WhyView } from '../studio-api/index.js';
+import type { StudioState } from './workspace.store.js';
+/**
+ * Handles `explain-why` (issue #92's Why? tab): builds the sentence for a
+ * missing or rejected value from the recipe's last sample run, kept in
+ * `state.lastRuns` by `handleRunSample`.
+ *
+ * @param state - The server state: `folder` must already be set (`open-workspace` first).
+ * @param command - The command.
+ * @returns The explanation.
+ * @throws Error when no workspace is open, no sample run has finished for the target's recipe, or the target does not name a real record/field.
+ */
+export declare function handleExplainWhy(state: StudioState, command: ExplainWhyCommand): Promise<WhyView>;
+//# sourceMappingURL=explain-why.handler.d.ts.map

package/dist/src/studio-server/grid-preview.handler.d.ts

@@ -0,0 +1,17 @@
+import type { GridPreviewCommand, GridTablePreviewView } from '../studio-api/index.js';
+import type { StudioState } from './workspace.store.js';
+/**
+ * Handles `grid-preview`: the grid canvas's live preview of a `table`
+ * extract's options (`document-view`'s `table-preview.use-case.ts`'s
+ * `previewGridTable`, studio plan §3.4, issue #94's 5c), off the same
+ * cached snapshot `take-snapshot`/`grid-view` already captured — a pure
+ * computation over it, so this answers instantly on every option change, no
+ * re-fetch or re-parse.
+ *
+ * @param state - The server state.
+ * @param command - The command; `command.path` must already have a cached snapshot (call `take-snapshot` first).
+ * @returns The matched tables, or `error` when an option's pattern does not compile.
+ * @throws Error when no workspace is open, or `command.path` has no cached snapshot yet.
+ */
+export declare function handleGridPreview(state: StudioState, command: GridPreviewCommand): GridTablePreviewView;
+//# sourceMappingURL=grid-preview.handler.d.ts.map

package/dist/src/studio-server/grid-view.handler.d.ts

@@ -0,0 +1,20 @@
+import type { GridViewCommand, WorkbookDocumentView } from '../studio-api/index.js';
+import type { StudioState } from './workspace.store.js';
+/**
+ * Handles `grid-view`: 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`/`pdf-view` already use.
+ *
+ * `delimiter`/`encoding` re-read a CSV with the override applied
+ * (`page-snapshot`'s `rereadCsv`) and replace the cached snapshot's body with
+ * the fresh reading, so a following `grid-preview` (and another `grid-view`
+ * with no override) sees the same one — the override sticks until
+ * `take-snapshot` recaptures.
+ *
+ * @param state - The server state.
+ * @param command - The command; `command.path` must already have a cached snapshot (call `take-snapshot` first).
+ * @returns The document's view.
+ * @throws Error when no workspace is open, `command.path` has no cached snapshot yet, an override is given for a snapshot that is not a CSV, or the snapshot's document is not a read workbook.
+ */
+export declare function handleGridView(state: StudioState, command: GridViewCommand): Promise<WorkbookDocumentView>;
+//# sourceMappingURL=grid-view.handler.d.ts.map