@opencraw/studio 0.0.7 → 0.0.8

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, missingWhyTargetSchema, rejectedWhyTargetSchema, whyTargetSchema, explainWhyCommandSchema, studioCommandSchema } from './command.contract.js';
-export type { SampleBudget, OpenWorkspaceCommand, RunSampleCommand, StopRunCommand, SaveRecipeCommand, FetchStartPageCommand, SaveOutlineCommand, TakeSnapshotCommand, VerifySelectorCommand, InferSelectorCommand, MissingWhyTarget, RejectedWhyTarget, WhyTarget, ExplainWhyCommand, 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, fieldTraceSchema, traceLineEventSchema, recordEventSchema, recordRejectedEventSchema, runFinishedEventSchema, workspaceChangedEventSchema, studioEventSchema } from './event.contract.js';
-export type { StoppedBy, FieldTraceView, TraceLineEvent, RecordEvent, RecordRejectedEvent, 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';
@@ -18,4 +18,22 @@ export { sentencePartSchema, outlineCardSchema, outlineBracketSchema, outlineNod
 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-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/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

package/dist/src/studio-server/inspect-page.handler.d.ts

@@ -0,0 +1,18 @@
+import type { InspectPageCommand, InspectView } from '../studio-api/index.js';
+import type { StudioState } from './workspace.store.js';
+/**
+ * Handles `inspect-page`: 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). `domTree` reads the cached,
+ * rewritten snapshot (the same markup the content pane's iframe shows, so a
+ * tree row's `nodeId` lines up with it exactly); `pageData` reads the raw
+ * capture (`SnapshotResult.rawHtml`), since the display snapshot has had its
+ * `<script>` tags stripped for the sandboxed iframe.
+ *
+ * @param state - The server state.
+ * @param command - The command; `command.path` must already have a cached snapshot (call `take-snapshot` first).
+ * @returns The tree and the data-in-the-page findings.
+ * @throws Error when no workspace is open, or `command.path` has no cached snapshot yet.
+ */
+export declare function handleInspectPage(state: StudioState, command: InspectPageCommand): InspectView;
+//# sourceMappingURL=inspect-page.handler.d.ts.map

package/dist/src/studio-server/pdf-bytes.handler.d.ts

@@ -0,0 +1,17 @@
+import type { StudioState } from './workspace.store.js';
+/**
+ * Handles `GET /api/pdf-bytes`: the raw bytes of a cached PDF snapshot, for
+ * the PDF canvas's `pdf.js` to render in the browser (studio plan §3.4,
+ * issue #94's 5b). Not a `studio-api` command — the other commands all
+ * answer JSON, and pdf.js wants the file itself — so this is its own route,
+ * read directly by `studio-http.use-case.ts` (mirrors `static-file.handler.ts`'s
+ * own reach outside the command dispatch).
+ *
+ * @param state - The server state.
+ * @param recipeId - The recipe.
+ * @param path - The step path; must already have a cached PDF snapshot (call `take-snapshot` first).
+ * @returns The raw PDF bytes.
+ * @throws Error when `path` has no cached snapshot yet, or the snapshot's document is not a PDF.
+ */
+export declare function handlePdfBytes(state: StudioState, recipeId: string, path: string): Promise<Uint8Array>;
+//# sourceMappingURL=pdf-bytes.handler.d.ts.map

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

@@ -0,0 +1,14 @@
+import type { PdfDocumentView, PdfViewCommand } from '../studio-api/index.js';
+import type { StudioState } from './workspace.store.js';
+/**
+ * Handles `pdf-view`: 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.
+ *
+ * @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 PDF.
+ */
+export declare function handlePdfView(state: StudioState, command: PdfViewCommand): PdfDocumentView;
+//# sourceMappingURL=pdf-view.handler.d.ts.map

package/dist/src/studio-server/recording.handler.d.ts

@@ -0,0 +1,33 @@
+import type { StartRecordingCommand, StopRecordingCommand } from '../studio-api/index.js';
+import type { StudioState } from './workspace.store.js';
+/**
+ * Handles `start-recording`: opens the studio's own headed browser window
+ * on the named recipe's start point (issue #95, phase 6) and streams
+ * `recording-card`/`recording-note` events as the person drives it. One
+ * recording at a time, like one sample run at a time: a second
+ * `start-recording` stops whatever was already open first.
+ *
+ * @param state - The server state: `folder` must already be set, `recorderProfileDir` names the studio's own recorder profile (never a crawl's own, never the person's default browser).
+ * @param command - The command.
+ * @returns `{ started: true }` once the window is open.
+ * @throws Error when no workspace is open, or the recipe cannot be found or loaded.
+ */
+export declare function handleStartRecording(state: StudioState, command: StartRecordingCommand): Promise<{
+    started: true;
+}>;
+/**
+ * Handles `stop-recording`: closes the recording window, if one is open,
+ * and answers with every step recorded, in order — enough for the caller to
+ * build "make this the login" (`session.bootstrap`) or "keep as steps"
+ * without asking the server again. Also broadcasts `recording-stopped`, so
+ * every connected client (not only the one that asked) knows the window
+ * closed.
+ *
+ * @param state - The server state holding the active recording, if any.
+ * @param _command - The command (carries nothing beyond its type).
+ * @returns Every step recorded, in order; empty when nothing was recording.
+ */
+export declare function handleStopRecording(state: StudioState, _command: StopRecordingCommand): Promise<{
+    steps: Record<string, unknown>[];
+}>;
+//# sourceMappingURL=recording.handler.d.ts.map

package/dist/src/studio-server/responses-seen.handler.d.ts

@@ -0,0 +1,16 @@
+import type { ResponsesSeenCommand, ResponsesSeenView } from '../studio-api/index.js';
+import type { StudioState } from './workspace.store.js';
+/**
+ * Handles `responses-seen`: the JSON responses observed 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 — picking one
+ * is the seam the UI uses to switch the recipe to api mode (issue #93's
+ * acceptance; the JSON tree canvas that follows is phase 5's).
+ *
+ * @param state - The server state: `folder` must already be set.
+ * @param command - The command.
+ * @returns The observed responses.
+ * @throws Error when no workspace is open, or the recipe cannot be found or loaded.
+ */
+export declare function handleResponsesSeen(state: StudioState, command: ResponsesSeenCommand): Promise<ResponsesSeenView>;
+//# sourceMappingURL=responses-seen.handler.d.ts.map

package/dist/src/studio-server/studio-http.use-case.d.ts

@@ -12,8 +12,10 @@ export interface StudioServerOptions {
      * the folder reaches it through the URL's `folder` query param).
      */
     initialFolder?: string;
-    /** Browser launch settings every web-mode command shares (`take-snapshot`, `verify-selector`, `run-sample`); an executable path override (e.g. `OPENCRAW_CHROMIUM`, read by the caller — the server itself has no opinion on env vars) for a sandbox with no full Playwright install. Default: Playwright's own bundled browser. */
+    /** Browser launch settings every web-mode command shares (`take-snapshot`, `verify-selector`, `run-sample`, `start-recording`); an executable path override (e.g. `OPENCRAW_CHROMIUM`, read by the caller — the server itself has no opinion on env vars) for a sandbox with no full Playwright install. Default: Playwright's own bundled browser. `start-recording` always forces `headless: false` regardless of what this sets. */
     browser?: BrowserSessionConfig;
+    /** Where the studio's own recorder profile lives (issue #95); default: a fixed directory under the OS temp folder, never a crawl's own profile directory, never the person's default browser. */
+    recorderProfileDir?: string;
 }
 /** The running server: its URL (token included, ready to open), the token alone, and how to stop it. */
 export interface StudioServer {

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

@@ -0,0 +1,16 @@
+import type { TablePreviewCommand, TablePreviewView } from '../studio-api/index.js';
+import type { StudioState } from './workspace.store.js';
+/**
+ * Handles `table-preview`: the PDF canvas's live preview of a `table`
+ * extract's options (`document-view`'s `table-preview.use-case.ts`, studio
+ * plan §3.4, issue #94's 5b), off the same cached snapshot `take-snapshot`
+ * 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 matches, 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 handleTablePreview(state: StudioState, command: TablePreviewCommand): TablePreviewView;
+//# sourceMappingURL=table-preview.handler.d.ts.map

package/dist/src/studio-server/workspace.store.d.ts

@@ -1,19 +1,23 @@
 import type { BrowserSessionConfig } from '@opencraw/core';
+import type { RecorderSessionHandle } from '../flow-recording/index.js';
 import type { SnapshotCache } from '../page-snapshot/index.js';
 import type { LastRunCache, SampleRunHandle } from '../sample-run/index.js';
 import type { StudioEvent } from '../studio-api/index.js';
 import type { WsConnection } from './websocket.client.js';
-/** The server's mutable state: the opened folder, the run in progress (if any), the connected event sockets, the per-recipe snapshot cache `take-snapshot`/`verify-selector`/`infer-selector` share, each recipe's last finished sample run (`explain-why`, issue #92), and the browser launch settings every web-mode command (`take-snapshot`, `verify-selector`, `run-sample`) shares. */
+/** The server's mutable state: the opened folder, the run in progress (if any), the recording in progress (if any, issue #95), the connected event sockets, the per-recipe snapshot cache `take-snapshot`/`verify-selector`/`infer-selector` share, each recipe's last finished sample run (`explain-why`, issue #92), the browser launch settings every web-mode command (`take-snapshot`, `verify-selector`, `run-sample`, `start-recording`) shares, and where the studio's own recorder profile lives. */
 export interface StudioState {
     folder?: string;
     activeRun?: SampleRunHandle;
+    activeRecording?: RecorderSessionHandle;
     sockets: Set<WsConnection>;
     snapshots: SnapshotCache;
     lastRuns: LastRunCache;
     /** Set once at server start (`StudioServerOptions.browser`); every web-mode command reads it from here rather than each accepting its own. */
     browser?: BrowserSessionConfig;
+    /** Set once at server start (`StudioServerOptions.recorderProfileDir`), else `defaultRecorderProfileDir()`. */
+    recorderProfileDir: string;
 }
-/** @returns Fresh state for a new server instance: no workspace open, no run, no sockets, an empty snapshot cache, no last runs, Playwright's own default browser. */
+/** @returns Fresh state for a new server instance: no workspace open, no run, no recording, no sockets, an empty snapshot cache, no last runs, Playwright's own default browser, the default recorder profile directory. */
 export declare function createStudioState(): StudioState;
 /**
  * Sends one event to every connected client. A socket that errors while