@opencraw/studio 0.0.18 → 0.0.19

package/dist/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<{
+                boolean: "boolean";
+                date: "date";
+                number: "number";
+                string: "string";
+            }>;
+        }, 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<{
+                    boolean: "boolean";
+                    date: "date";
+                    number: "number";
+                    string: "string";
+                }>;
+            }, 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/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/studio-api/event.contract.d.ts

@@ -0,0 +1,155 @@
+import { z } from 'zod';
+/** Why a sample run stopped before finishing on its own; mirrors `@opencraw/core`'s `RecipeReport.stoppedBy`. */
+export declare const stoppedBySchema: z.ZodEnum<{
+    "sample-maxMs": "sample-maxMs";
+    "sample-maxPages": "sample-maxPages";
+    "sample-maxRecords": "sample-maxRecords";
+}>;
+/** One line of the engine's own trace output (`traceLine`), streamed as a sample run proceeds. */
+export declare const traceLineEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"trace-line">;
+    line: z.ZodString;
+}, z.core.$strip>;
+/** 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<{
+    type: z.ZodLiteral<"run-finished">;
+    recipeId: z.ZodString;
+    emitted: z.ZodNumber;
+    rejected: z.ZodNumber;
+    duplicates: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    error: z.ZodOptional<z.ZodString>;
+    stoppedBy: z.ZodOptional<z.ZodEnum<{
+        "sample-maxMs": "sample-maxMs";
+        "sample-maxPages": "sample-maxPages";
+        "sample-maxRecords": "sample-maxRecords";
+    }>>;
+}, z.core.$strip>;
+/** The workspace's recipes changed on disk (a save, or a future watcher) and should be re-fetched. */
+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<{
+        info: "info";
+        "next-link": "next-link";
+        unsupported: "unsupported";
+    }>;
+    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;
+}, z.core.$strip>, 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>, 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;
+    emitted: z.ZodNumber;
+    rejected: z.ZodNumber;
+    duplicates: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    error: z.ZodOptional<z.ZodString>;
+    stoppedBy: z.ZodOptional<z.ZodEnum<{
+        "sample-maxMs": "sample-maxMs";
+        "sample-maxPages": "sample-maxPages";
+        "sample-maxRecords": "sample-maxRecords";
+    }>>;
+}, 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<{
+        info: "info";
+        "next-link": "next-link";
+        unsupported: "unsupported";
+    }>;
+    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/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/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<{
+        boolean: "boolean";
+        date: "date";
+        number: "number";
+        string: "string";
+    }>;
+}, 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<{
+            boolean: "boolean";
+            date: "date";
+            number: "number";
+            string: "string";
+        }>;
+    }, 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<{
+                boolean: "boolean";
+                date: "date";
+                number: "number";
+                string: "string";
+            }>;
+        }, 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/studio-api/import-document-view.contract.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+/** `import-document`'s answer: where the copy landed, and the `file:` URL a recipe's `start.url` points at it with. */
+export declare const importDocumentViewSchema: z.ZodObject<{
+    path: z.ZodString;
+    url: z.ZodString;
+}, z.core.$strip>;
+export type ImportDocumentView = z.infer<typeof importDocumentViewSchema>;
+//# sourceMappingURL=import-document-view.contract.d.ts.map

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

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

package/dist/studio-api/infer-selector-view.contract.d.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+/** One clicked node's field: the best selector found for it, verified against the snapshot. */
+export declare const fieldPickSchema: z.ZodObject<{
+    selector: z.ZodString;
+    tier: z.ZodEnum<{
+        class: "class";
+        "data-attr": "data-attr";
+        id: "id";
+        position: "position";
+        structure: "structure";
+    }>;
+    take: z.ZodString;
+    matches: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * What `infer-selector` answers with (issue #91, studio plan §3.2):
+ * `"field"` for one clicked node — a `Read` card's shape; `"list"` for two
+ * similar nodes — the safe `extract`(items)+`forEach`(field) shape, item and
+ * field each verified separately; `"unsupported"` when the two picks are not
+ * a coherent list (different branches, the same node twice, or shadow DOM),
+ * with a message the card can show as-is.
+ */
+export declare const inferSelectorViewSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"field">;
+    field: z.ZodObject<{
+        selector: z.ZodString;
+        tier: z.ZodEnum<{
+            class: "class";
+            "data-attr": "data-attr";
+            id: "id";
+            position: "position";
+            structure: "structure";
+        }>;
+        take: z.ZodString;
+        matches: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"list">;
+    item: z.ZodObject<{
+        selector: z.ZodString;
+        tier: z.ZodEnum<{
+            class: "class";
+            "data-attr": "data-attr";
+            id: "id";
+            position: "position";
+            structure: "structure";
+        }>;
+        matches: z.ZodNumber;
+    }, z.core.$strip>;
+    field: z.ZodObject<{
+        selector: z.ZodString;
+        tier: z.ZodEnum<{
+            class: "class";
+            "data-attr": "data-attr";
+            id: "id";
+            position: "position";
+            structure: "structure";
+        }>;
+        take: z.ZodString;
+        matches: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"unsupported">;
+    reason: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type FieldPick = z.infer<typeof fieldPickSchema>;
+export type InferSelectorView = z.infer<typeof inferSelectorViewSchema>;
+//# sourceMappingURL=infer-selector-view.contract.d.ts.map

package/dist/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<{
+    "inline-state": "inline-state";
+    "json-script": "json-script";
+    "ld-json": "ld-json";
+    link: "link";
+    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<{
+        "inline-state": "inline-state";
+        "json-script": "json-script";
+        "ld-json": "ld-json";
+        link: "link";
+        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<{
+            "inline-state": "inline-state";
+            "json-script": "json-script";
+            "ld-json": "ld-json";
+            link: "link";
+            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/studio-api/outline-view.contract.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+/** One piece of a card's sentence: plain wording, a bound id (a "pill"), or a literal shown as code. Mirrors `scope-outline/outline.model.ts`'s `SentencePart`: the wire shape for the UI. */
+export interface SentencePart {
+    kind: 'word' | 'pill' | 'code';
+    text: string;
+}
+interface OutlineNodeBase {
+    path: string;
+    stepType: string;
+    sentence: SentencePart[];
+    step: Record<string, unknown>;
+}
+/** A leaf step, read as a sentence (or, when `custom`, not read as one: the UI shows `step`'s raw JSON instead). */
+export interface OutlineCard extends OutlineNodeBase {
+    kind: 'card';
+    custom: boolean;
+}
+/** A container step (`forEach`, `paginate`, `if`), its body nested one level in. */
+export interface OutlineBracket extends OutlineNodeBase {
+    kind: 'bracket';
+    stepType: 'forEach' | 'paginate' | 'if';
+    children: OutlineNode[];
+    elseChildren?: OutlineNode[];
+}
+export type OutlineNode = OutlineCard | OutlineBracket;
+/** The outline the UI renders and edits: the recipe's other keys untouched, plus its steps as a tree. */
+export interface OutlineView {
+    recipe: Record<string, unknown>;
+    steps: OutlineNode[];
+}
+export declare const sentencePartSchema: z.ZodType<SentencePart>;
+export declare const outlineCardSchema: z.ZodType<OutlineCard>;
+export declare const outlineBracketSchema: z.ZodType<OutlineBracket>;
+export declare const outlineNodeSchema: z.ZodType<OutlineNode>;
+export declare const outlineViewSchema: z.ZodType<OutlineView>;
+export {};
+//# sourceMappingURL=outline-view.contract.d.ts.map