@opencraw/studio 0.0.18 → 0.0.19

package/dist/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/studio-api/region-preview-view.contract.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+/** One page of a PDF, or one slide of a deck, a `region` extract's box reads text off — mirrors `document-view/region-preview.use-case.ts`'s `RegionPreviewMatch`: `cells` for a PDF, `shapes` for a deck, the other empty. */
+export declare const regionPreviewMatchSchema: z.ZodObject<{
+    page: z.ZodNumber;
+    text: z.ZodString;
+    cells: z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    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>>;
+}, z.core.$strip>;
+/**
+ * What `region-preview` answers with (issues #121 and #122: the PDF and
+ * deck canvases' click-to-snap selection): the engine's own matches for
+ * the selector — the text the step would bind, and the cells or text boxes
+ * to highlight — or `error` when the selector does not parse yet, or names
+ * the other document's keyword, reported rather than thrown.
+ */
+export declare const regionPreviewViewSchema: z.ZodObject<{
+    matches: z.ZodArray<z.ZodObject<{
+        page: z.ZodNumber;
+        text: z.ZodString;
+        cells: z.ZodArray<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            text: z.ZodString;
+        }, z.core.$strip>>;
+        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>>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RegionPreviewMatchView = z.infer<typeof regionPreviewMatchSchema>;
+export type RegionPreviewView = z.infer<typeof regionPreviewViewSchema>;
+//# sourceMappingURL=region-preview-view.contract.d.ts.map

package/dist/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/studio-api/sample-run-view.contract.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+/** One record of a sample run's result, kept for the Records tab. */
+export declare const sampleRunRecordSchema: z.ZodObject<{
+    key: z.ZodNullable<z.ZodString>;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+/** The last sample run's result, for a client that opens the UI after it finished. */
+export declare const sampleRunViewSchema: z.ZodObject<{
+    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";
+    }>>;
+    records: z.ZodArray<z.ZodObject<{
+        key: z.ZodNullable<z.ZodString>;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+    trace: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type SampleRunRecord = z.infer<typeof sampleRunRecordSchema>;
+export type SampleRunView = z.infer<typeof sampleRunViewSchema>;
+//# sourceMappingURL=sample-run-view.contract.d.ts.map

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

@@ -0,0 +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). `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<{
+        csv: "csv";
+        docx: "docx";
+        html: "html";
+        json: "json";
+        jsonl: "jsonl";
+        markdown: "markdown";
+        pdf: "pdf";
+        pptx: "pptx";
+        text: "text";
+        xlsx: "xlsx";
+        xml: "xml";
+        yaml: "yaml";
+    }>>;
+}, z.core.$strip>;
+export type SnapshotView = z.infer<typeof snapshotViewSchema>;
+//# sourceMappingURL=snapshot-view.contract.d.ts.map

package/dist/studio-api/start-page-view.contract.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/** What `fetch-start-page` answers with. */
+export declare const startPageViewSchema: z.ZodObject<{
+    html: z.ZodString;
+}, z.core.$strip>;
+export type StartPageView = z.infer<typeof startPageViewSchema>;
+//# sourceMappingURL=start-page-view.contract.d.ts.map

package/dist/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/studio-api/verify-selector-view.contract.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+/**
+ * What `verify-selector` answers with: the match count against the snapshot
+ * and, when the live page could be reached, against it too (issue #91's
+ * "flag a selector that matches the snapshot but not the live page").
+ * `liveChecked` is `false` when the live page could not be fetched (offline,
+ * blocked by `allowedHosts`, a transient error) — the card shows the
+ * snapshot count alone rather than a misleading "0 on the live page".
+ */
+export declare const verifySelectorViewSchema: z.ZodObject<{
+    selector: z.ZodString;
+    snapshotMatches: z.ZodNumber;
+    liveChecked: z.ZodBoolean;
+    liveMatches: z.ZodOptional<z.ZodNumber>;
+    liveError: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type VerifySelectorView = z.infer<typeof verifySelectorViewSchema>;
+//# sourceMappingURL=verify-selector-view.contract.d.ts.map

package/dist/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/studio-api/workspace-view.contract.d.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+/** One problem found on a recipe file, with the JSON path it lives at. */
+export declare const recipeIssueSchema: z.ZodObject<{
+    path: z.ZodString;
+    message: z.ZodString;
+    kind: z.ZodEnum<{
+        binding: "binding";
+        validation: "validation";
+    }>;
+}, z.core.$strip>;
+/** One recipe file in an opened workspace. */
+export declare const recipeListingSchema: z.ZodObject<{
+    file: z.ZodString;
+    kind: z.ZodEnum<{
+        input: "input";
+        output: "output";
+        unknown: "unknown";
+    }>;
+    id: z.ZodOptional<z.ZodString>;
+    issues: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        message: z.ZodString;
+        kind: z.ZodEnum<{
+            binding: "binding";
+            validation: "validation";
+        }>;
+    }, z.core.$strip>>;
+    text: z.ZodString;
+    outline: z.ZodOptional<z.ZodType<import("./outline-view.contract").OutlineView, unknown, z.core.$ZodTypeInternals<import("./outline-view.contract").OutlineView, unknown>>>;
+}, z.core.$strip>;
+/** The hooks Studio was started with (`opencraw studio --hooks <file>`, issue #150): where they came from and what they are called, for the warning bar and the hook-name suggestions. */
+export declare const loadedHooksSchema: z.ZodObject<{
+    source: z.ZodString;
+    names: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/** What `open-workspace` answers with: every recipe file directly inside the folder, and the hooks Studio runs them with, if any. */
+export declare const workspaceViewSchema: z.ZodObject<{
+    folder: z.ZodString;
+    recipes: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        kind: z.ZodEnum<{
+            input: "input";
+            output: "output";
+            unknown: "unknown";
+        }>;
+        id: z.ZodOptional<z.ZodString>;
+        issues: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            message: z.ZodString;
+            kind: z.ZodEnum<{
+                binding: "binding";
+                validation: "validation";
+            }>;
+        }, z.core.$strip>>;
+        text: z.ZodString;
+        outline: z.ZodOptional<z.ZodType<import("./outline-view.contract").OutlineView, unknown, z.core.$ZodTypeInternals<import("./outline-view.contract").OutlineView, unknown>>>;
+    }, z.core.$strip>>;
+    hooks: z.ZodOptional<z.ZodObject<{
+        source: z.ZodString;
+        names: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RecipeIssue = z.infer<typeof recipeIssueSchema>;
+export type RecipeListing = z.infer<typeof recipeListingSchema>;
+export type LoadedHooks = z.infer<typeof loadedHooksSchema>;
+export type WorkspaceView = z.infer<typeof workspaceViewSchema>;
+//# sourceMappingURL=workspace-view.contract.d.ts.map

package/dist/studio-server/access-token.policy.d.ts

@@ -0,0 +1,26 @@
+import type { IncomingMessage } from 'node:http';
+/** The cookie set on the page's own document response, so its own asset and API requests carry the token too. */
+export declare const TOKEN_COOKIE = "opencraw_token";
+/** A random token, generated once at server startup and required on every request. */
+export declare function generateToken(): string;
+/**
+ * The token a request carries, checked in this order: the `x-opencraw-token`
+ * header, the `token` query param, the studio's own cookie (set after the
+ * first authenticated document request, so a browser's own asset and API
+ * requests need not repeat the query param).
+ *
+ * @param request - The incoming request.
+ * @param query - Its URL's query string, parsed.
+ * @returns The token found, or `undefined`.
+ */
+export declare function tokenOf(request: Pick<IncomingMessage, 'headers'>, query: URLSearchParams): string | undefined;
+/**
+ * Whether a request proves it holds the server's token.
+ *
+ * @param expected - The server's token.
+ * @param request - The incoming request.
+ * @param query - Its URL's query string, parsed.
+ * @returns Whether the request is authorized.
+ */
+export declare function isAuthorized(expected: string, request: Pick<IncomingMessage, 'headers'>, query: URLSearchParams): boolean;
+//# sourceMappingURL=access-token.policy.d.ts.map

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

@@ -0,0 +1,17 @@
+import type { DeckPreviewCommand, DeckTablePreviewView } from '../studio-api';
+import type { StudioState } from './workspace.store';
+/**
+ * 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/studio-server/deck-view.handler.d.ts

@@ -0,0 +1,15 @@
+import type { DeckDocumentView, DeckViewCommand } from '../studio-api';
+import type { StudioState } from './workspace.store';
+/**
+ * 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/studio-server/document-tree.handler.d.ts

@@ -0,0 +1,14 @@
+import type { DocumentTreeCommand, DocumentTreeView } from '../studio-api';
+import type { StudioState } from './workspace.store';
+/**
+ * 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/studio-server/explain-why.handler.d.ts

@@ -0,0 +1,14 @@
+import type { ExplainWhyCommand, WhyView } from '../studio-api';
+import type { StudioState } from './workspace.store';
+/**
+ * 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/studio-server/fetch-start-page.handler.d.ts

@@ -0,0 +1,14 @@
+import type { FetchStartPageCommand, StartPageView } from '../studio-api';
+import type { StudioState } from './workspace.store';
+/**
+ * Handles `fetch-start-page`: loads the named input recipe from the current
+ * workspace and fetches its start point (see `page-snapshot`'s own caveats:
+ * no session bootstrap, a fresh browser or HTTP context per call).
+ *
+ * @param state - The server state: `folder` must already be set.
+ * @param command - The command.
+ * @returns The page's content as plain text.
+ * @throws Error when no workspace is open, or the recipe cannot be found or loaded.
+ */
+export declare function handleFetchStartPage(state: StudioState, command: FetchStartPageCommand): Promise<StartPageView>;
+//# sourceMappingURL=fetch-start-page.handler.d.ts.map

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

@@ -0,0 +1,17 @@
+import type { GridPreviewCommand, GridTablePreviewView } from '../studio-api';
+import type { StudioState } from './workspace.store';
+/**
+ * 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/studio-server/grid-view.handler.d.ts

@@ -0,0 +1,20 @@
+import type { GridViewCommand, WorkbookDocumentView } from '../studio-api';
+import type { StudioState } from './workspace.store';
+/**
+ * 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/studio-server/import-document.handler.d.ts

@@ -0,0 +1,14 @@
+import type { ImportDocumentCommand, ImportDocumentView } from '../studio-api';
+/**
+ * Handles `import-document` (issue #120): decodes the base64 bytes and copies
+ * the file into the folder (see `recipe-workspace/import-document.use-case.ts`
+ * for the folder creation and the no-overwrite numbering). Nothing is
+ * broadcast: the copy is not a recipe, the workspace listing does not change
+ * until the UI saves the recipe pair that points at it, which `save-recipe`
+ * announces as usual.
+ *
+ * @param command - The folder, the file's name and its base64 content.
+ * @returns Where the copy landed and its `file:` URL.
+ */
+export declare function handleImportDocument(command: ImportDocumentCommand): Promise<ImportDocumentView>;
+//# sourceMappingURL=import-document.handler.d.ts.map

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

@@ -0,0 +1,3 @@
+export { startStudioServer } from './studio-http.use-case';
+export type { StudioServer, StudioServerOptions } from './studio-http.use-case';
+//# sourceMappingURL=index.d.ts.map

package/dist/studio-server/infer-selector.handler.d.ts

@@ -0,0 +1,18 @@
+import type { InferSelectorCommand, InferSelectorView } from '../studio-api';
+import type { StudioState } from './workspace.store';
+/**
+ * Handles `infer-selector`: turns one or two picked nodes (their
+ * `data-oc-node` ids, off the cached snapshot) into a verified selector —
+ * one id for a `Read` card's field, two for the safe item+field list shape
+ * `selector-inference`'s `inferList` builds by construction (issue #91,
+ * studio plan §3.2). All the actual candidate/ranking/list-inference work
+ * is `selector-inference`'s (pure); this handler only locates the clicked
+ * nodes in the cached document and calls into it.
+ *
+ * @param state - The server state.
+ * @param command - The command; `command.path` must already have a cached snapshot (call `take-snapshot` first).
+ * @returns A field pick, a list pick, or `"unsupported"` with why.
+ * @throws Error when no workspace is open, or `command.path` has no cached snapshot yet.
+ */
+export declare function handleInferSelector(state: StudioState, command: InferSelectorCommand): InferSelectorView;
+//# sourceMappingURL=infer-selector.handler.d.ts.map

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

@@ -0,0 +1,18 @@
+import type { InspectPageCommand, InspectView } from '../studio-api';
+import type { StudioState } from './workspace.store';
+/**
+ * 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/studio-server/open-workspace.handler.d.ts

@@ -0,0 +1,20 @@
+import type { OpenWorkspaceCommand, WorkspaceView } from '../studio-api';
+import type { StudioState } from './workspace.store';
+/**
+ * Handles `open-workspace`: reads the folder, remembers it as the server's
+ * current workspace (every later command that names a recipe resolves it
+ * against this folder), and, when that is a different folder than before,
+ * tells every connected client the workspace changed.
+ *
+ * Only on an actual switch: the UI answers `workspace-changed` with another
+ * `open-workspace` of the same folder (its workspace query re-fetches), so a
+ * broadcast on every open would answer that re-fetch with another broadcast,
+ * for ever — and each round cancels the fetch in flight, so a recipe saved
+ * meanwhile never showed up in the listing (found by issue #120's drop flow).
+ *
+ * @param state - The server state to update.
+ * @param command - The command.
+ * @returns The workspace's recipes and their issues.
+ */
+export declare function handleOpenWorkspace(state: StudioState, command: OpenWorkspaceCommand): Promise<WorkspaceView>;
+//# sourceMappingURL=open-workspace.handler.d.ts.map

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

@@ -0,0 +1,17 @@
+import type { StudioState } from './workspace.store';
+/**
+ * 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/studio-server/pdf-view.handler.d.ts

@@ -0,0 +1,14 @@
+import type { PdfDocumentView, PdfViewCommand } from '../studio-api';
+import type { StudioState } from './workspace.store';
+/**
+ * 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