@opencraw/studio 0.0.5 → 0.0.7

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

@@ -50,6 +50,76 @@ export declare const saveOutlineCommandSchema: z.ZodObject<{
     path: z.ZodString;
     outline: z.ZodType<import("./outline-view.contract").OutlineView, unknown, z.core.$ZodTypeInternals<import("./outline-view.contract").OutlineView, unknown>>;
 }, z.core.$strip>;
+/**
+ * Captures the snapshot the content pane shows for a step (`page-snapshot`'s
+ * `take-snapshot.use-case.ts`), caching it by recipe and step path so
+ * switching the selected step does not always re-run the recipe.
+ */
+export declare const takeSnapshotCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"take-snapshot">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Verifies a candidate selector against the cached snapshot and, when
+ * reachable, the live page — the studio's own selection (`@opencraw/core`'s
+ * `countMatches`), never the browser's or a guess (issue #91).
+ */
+export declare const verifySelectorCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"verify-selector">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    selector: z.ZodString;
+}, z.core.$strip>;
+export declare const inferSelectorCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"infer-selector">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    nodeIds: z.ZodUnion<readonly [z.ZodTuple<[z.ZodString], null>, z.ZodTuple<[z.ZodString, z.ZodString], null>]>;
+}, z.core.$strip>;
+/** A missing value in an emitted record, by its position in the last sample run's records (the order they streamed in, matching the UI's own `records` list). */
+export declare const missingWhyTargetSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"missing">;
+    recipeId: z.ZodString;
+    recordIndex: z.ZodInt;
+    field: z.ZodString;
+}, z.core.$strip>;
+/** A rejected record, by its position in the last sample run's `rejectedRecords`. */
+export declare const rejectedWhyTargetSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"rejected">;
+    recipeId: z.ZodString;
+    rejectedIndex: z.ZodInt;
+}, z.core.$strip>;
+export declare const whyTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"missing">;
+    recipeId: z.ZodString;
+    recordIndex: z.ZodInt;
+    field: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"rejected">;
+    recipeId: z.ZodString;
+    rejectedIndex: z.ZodInt;
+}, z.core.$strip>], "kind">;
+/**
+ * Explains one missing or rejected value from the recipe's last sample run
+ * (`explain-why.use-case.ts`, issue #92's Why? tab): the mapping trace and
+ * scope snapshot `run-sample` already kept, the step that bound the value's
+ * source id and whether it ran, was skipped or found nothing, and the
+ * missing-value policy that applied.
+ */
+export declare const explainWhyCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"explain-why">;
+    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"missing">;
+        recipeId: z.ZodString;
+        recordIndex: z.ZodInt;
+        field: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"rejected">;
+        recipeId: z.ZodString;
+        rejectedIndex: z.ZodInt;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
 export declare const studioCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"open-workspace">;
     folder: z.ZodString;
@@ -74,6 +144,32 @@ export declare const studioCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"save-outline">;
     path: z.ZodString;
     outline: z.ZodType<import("./outline-view.contract").OutlineView, unknown, z.core.$ZodTypeInternals<import("./outline-view.contract").OutlineView, unknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"take-snapshot">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"verify-selector">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    selector: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"infer-selector">;
+    recipeId: z.ZodString;
+    path: z.ZodString;
+    nodeIds: z.ZodUnion<readonly [z.ZodTuple<[z.ZodString], null>, z.ZodTuple<[z.ZodString, z.ZodString], null>]>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"explain-why">;
+    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"missing">;
+        recipeId: z.ZodString;
+        recordIndex: z.ZodInt;
+        field: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"rejected">;
+        recipeId: z.ZodString;
+        rejectedIndex: z.ZodInt;
+    }, z.core.$strip>], "kind">;
 }, z.core.$strip>], "type">;
 export type SampleBudget = z.infer<typeof sampleBudgetSchema>;
 export type OpenWorkspaceCommand = z.infer<typeof openWorkspaceCommandSchema>;
@@ -82,6 +178,13 @@ export type StopRunCommand = z.infer<typeof stopRunCommandSchema>;
 export type SaveRecipeCommand = z.infer<typeof saveRecipeCommandSchema>;
 export type FetchStartPageCommand = z.infer<typeof fetchStartPageCommandSchema>;
 export type SaveOutlineCommand = z.infer<typeof saveOutlineCommandSchema>;
+export type TakeSnapshotCommand = z.infer<typeof takeSnapshotCommandSchema>;
+export type VerifySelectorCommand = z.infer<typeof verifySelectorCommandSchema>;
+export type InferSelectorCommand = z.infer<typeof inferSelectorCommandSchema>;
+export type MissingWhyTarget = z.infer<typeof missingWhyTargetSchema>;
+export type RejectedWhyTarget = z.infer<typeof rejectedWhyTargetSchema>;
+export type WhyTarget = z.infer<typeof whyTargetSchema>;
+export type ExplainWhyCommand = z.infer<typeof explainWhyCommandSchema>;
 /** Every command the UI can send the server, over HTTP POST. */
 export type StudioCommand = z.infer<typeof studioCommandSchema>;
 //# sourceMappingURL=command.contract.d.ts.map

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

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

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

@@ -1,7 +1,13 @@
-export { sampleBudgetSchema, openWorkspaceCommandSchema, runSampleCommandSchema, stopRunCommandSchema, saveRecipeCommandSchema, fetchStartPageCommandSchema, saveOutlineCommandSchema, studioCommandSchema } from './command.contract.js';
-export type { SampleBudget, OpenWorkspaceCommand, RunSampleCommand, StopRunCommand, SaveRecipeCommand, FetchStartPageCommand, SaveOutlineCommand, StudioCommand } from './command.contract.js';
-export { stoppedBySchema, traceLineEventSchema, recordEventSchema, runFinishedEventSchema, workspaceChangedEventSchema, studioEventSchema } from './event.contract.js';
-export type { StoppedBy, TraceLineEvent, RecordEvent, RunFinishedEvent, WorkspaceChangedEvent, StudioEvent } from './event.contract.js';
+export { 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 { 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 { 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';
@@ -10,4 +16,6 @@ export { startPageViewSchema } from './start-page-view.contract.js';
 export type { StartPageView } from './start-page-view.contract.js';
 export { sentencePartSchema, outlineCardSchema, outlineBracketSchema, outlineNodeSchema, outlineViewSchema } from './outline-view.contract.js';
 export type { SentencePart, OutlineCard, OutlineBracket, OutlineNode, OutlineView } from './outline-view.contract.js';
+export { whyViewSchema } from './why-view.contract.js';
+export type { WhyView } from './why-view.contract.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/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<{
+        id: "id";
+        "data-attr": "data-attr";
+        class: "class";
+        structure: "structure";
+        position: "position";
+    }>;
+    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<{
+            id: "id";
+            "data-attr": "data-attr";
+            class: "class";
+            structure: "structure";
+            position: "position";
+        }>;
+        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<{
+            id: "id";
+            "data-attr": "data-attr";
+            class: "class";
+            structure: "structure";
+            position: "position";
+        }>;
+        matches: z.ZodNumber;
+    }, z.core.$strip>;
+    field: z.ZodObject<{
+        selector: z.ZodString;
+        tier: z.ZodEnum<{
+            id: "id";
+            "data-attr": "data-attr";
+            class: "class";
+            structure: "structure";
+            position: "position";
+        }>;
+        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/src/studio-api/snapshot-view.contract.d.ts

@@ -0,0 +1,9 @@
+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). */
+export declare const snapshotViewSchema: z.ZodObject<{
+    html: z.ZodString;
+    nodeCount: z.ZodNumber;
+    baseUrl: z.ZodString;
+}, z.core.$strip>;
+export type SnapshotView = z.infer<typeof snapshotViewSchema>;
+//# sourceMappingURL=snapshot-view.contract.d.ts.map

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

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

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

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

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

@@ -0,0 +1,18 @@
+import type { InferSelectorCommand, InferSelectorView } from '../studio-api/index.js';
+import type { StudioState } from './workspace.store.js';
+/**
+ * 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/src/studio-server/studio-http.use-case.d.ts

@@ -1,3 +1,4 @@
+import type { BrowserSessionConfig } from '@opencraw/core';
 export interface StudioServerOptions {
     /** Where the built UI lives; default: `dist/ui` next to the running server code. */
     uiRoot?: string;
@@ -11,6 +12,8 @@ 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?: BrowserSessionConfig;
 }
 /** 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/take-snapshot.handler.d.ts

@@ -0,0 +1,16 @@
+import type { SnapshotView, TakeSnapshotCommand } from '../studio-api/index.js';
+import type { StudioState } from './workspace.store.js';
+/**
+ * Handles `take-snapshot`: loads the named input recipe, captures its
+ * snapshot at `command.path` (only `"start"` is captured for now — see
+ * `page-snapshot`'s `take-snapshot.use-case.ts`), and caches it so a later
+ * `verify-selector`/`infer-selector` against the same recipe and path, or
+ * the UI reselecting the same step, does not recapture it.
+ *
+ * @param state - The server state: `folder` must already be set.
+ * @param command - The command.
+ * @returns The rewritten snapshot.
+ * @throws Error when no workspace is open, or the recipe cannot be found or loaded.
+ */
+export declare function handleTakeSnapshot(state: StudioState, command: TakeSnapshotCommand): Promise<SnapshotView>;
+//# sourceMappingURL=take-snapshot.handler.d.ts.map

package/dist/src/studio-server/verify-selector.handler.d.ts

@@ -0,0 +1,18 @@
+import type { VerifySelectorCommand, VerifySelectorView } from '../studio-api/index.js';
+import type { StudioState } from './workspace.store.js';
+/**
+ * Handles `verify-selector`: runs a candidate through the engine's own
+ * selection (`@opencraw/core`'s `countMatches`) against the cached
+ * snapshot, and, best-effort, against the live page too — issue #91's "flag
+ * a selector that matches the snapshot but not the live page". The live
+ * page is fetched raw (`page-snapshot`'s `fetchStartPage`, the same reach
+ * `take-snapshot` has: only `"start"` today), not through the rewritten
+ * snapshot, so its match count is the site's own, not the studio's.
+ *
+ * @param state - The server state.
+ * @param command - The command; `command.path` must already have a cached snapshot (call `take-snapshot` first).
+ * @returns The match counts.
+ * @throws Error when no workspace is open, the recipe cannot be found, or `command.path` has no cached snapshot yet.
+ */
+export declare function handleVerifySelector(state: StudioState, command: VerifySelectorCommand): Promise<VerifySelectorView>;
+//# sourceMappingURL=verify-selector.handler.d.ts.map

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

@@ -1,13 +1,19 @@
-import type { SampleRunHandle } from '../sample-run/index.js';
+import type { BrowserSessionConfig } from '@opencraw/core';
+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), and the connected event sockets. */
+/** 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. */
 export interface StudioState {
     folder?: string;
     activeRun?: SampleRunHandle;
     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;
 }
-/** @returns Fresh state for a new server instance: no workspace open, no run, no sockets. */
+/** @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. */
 export declare function createStudioState(): StudioState;
 /**
  * Sends one event to every connected client. A socket that errors while