@dev.fast/whiteboard 0.0.0-stage → 0.2.1-preview.20261005.98

package/src/review-api/authoring-tools.ts

@@ -0,0 +1,211 @@
+import { z } from "zod";
+
+import {
+  activityBeginSchema,
+  activityEndSchema,
+  activityUpdateSchema,
+} from "./activity.js";
+import { pathTargetSchema, publishedEditSchema } from "./document.js";
+import { instructionsQuerySchema } from "./instructions.js";
+import { uploadSchema } from "./local-data.js";
+import { inspectQuerySchema } from "./read-schemas.js";
+import { REVIEW_STATUS_TOOL } from "./status-tool.js";
+import { commandSchema } from "./store.js";
+
+/** The host publishes its input schemas, except where agents write less than
+ * the host accepts (publishedEditSchema, publishedLensEditSchema) or name a
+ * checkout by path (pathTargetSchema); adapters validate nothing. */
+export function authoringTools(
+  scratchpadAvailable = false,
+  traceEnabled = false,
+) {
+  const id = z.string().min(1);
+  const review = { reviewId: id };
+
+  // Anthropic rejects a top-level union, so publish one object; the host validates the union.
+  const [image, trace] = uploadSchema.options;
+
+  const uploadInput = z
+    .strictObject({
+      ...image.shape,
+      ...trace.shape,
+      kind: z.enum(["image", "trace"]),
+    })
+    .partial()
+    .required({ id: true, repositoryId: true, kind: true });
+
+  const descriptions = {
+    create:
+      'Create a review of saved working files, immutable commits or a GitHub PR. Revisions are resolved on acceptance. A worktree target reviews the saved files in its checkout, uncommitted ones included and untracked ones left out (git add -N a new file to include it), against base: the branch to compare against, by default the default branch of the repository. The diff starts at the merge base of base and HEAD, which follows rebases. Omitted commits base means source at head with no diff; supply the parent to review introduced changes. For a GitHub PR, pullRequestUrl alone is enough: target and title become optional, and the host fetches the PR into a registered checkout of its repository and pins the current PR head and GitHub diff base, titled from the PR. When a review for that PR exists, it is returned instead, reporting whether its head moved and whether an agent is working on it; update it in place, move its target with review_set_target, or create a separate review with reuseExisting. kind:"scratchpad" names the one scratchpad, which the host creates itself. The result carries review, the review as review_list shows it: its target with resolved commits, origin (its PR), repositoryName and repositoryPath, so no follow-up read is needed before diffing. When Desktop is available the review opens there and the result reports opened, softwareMapEnabled and environmentIssues, as review_open does; set open:false to author in the background without taking over Desktop.',
+    set_target:
+      "Move the review to a new target, such as the commits after a rebase or amend, preserving the document and component IDs. Revisions are resolved on acceptance. Returns warnings for retained source ranges in files the new commits changed, to verify, and resources that no longer match; fix them with review_edit. Earlier versions keep their source. Omitted pullRequestUrl keeps the PR within the same repository; changing repositories clears it. Supply a URL to replace it or null to detach.",
+    edit: [
+      "Edit one document component. content is one component, named by its type; each type's fields are in the Components section of session_get_instructions (authoring or scratchpad).",
+      "Anchors are head/path#L10-L20 or base/path#L7, or diff/path#L84-R90 for a range across sides, with repository-relative paths and 1-based inclusive lines. pins {repositoryId, head, base?} say which commits anchors quote: a step, frame, attachment or operation without pins uses its block's, and a block without them the review's.",
+      "insert adds content: parentId nests it, afterId places it, and omitted placement appends (on the scratchpad, it lands at the top). update patches a component's own fields; null removes an optional one. A section's children and a diagram's units change through their own IDs; a call stack's frames change by replacing the call stack. move and remove take a targetId; removing a flow_node removes its edges.",
+      "The host assigns short durable IDs. The result names the edited component and, for an insert or replace, its first-level children, and quotes the first and last line of each anchor the edit added or changed (the first 20; unquotedAnchors counts the rest): check they are the lines you meant. Accepted edits save at once.",
+      "While a reader may be watching, write small and often: one paragraph per edit. Insert a new diagram whole. Change one already drawn a unit at a time (a flow_node, flow_edge or step, with parentId naming the diagram), and link each added flow_node to a node already drawn.",
+    ].join("\n"),
+    lens_edit:
+      "Edit one Diff-view lens. Lenses partition the review's change for the Diff view; they sit beside the document (never in it) and version with it. The host assigns durable lens IDs; updates replace only the fields supplied. Write one lens per call while a reader may be watching; each draws in on the Diffs page. Pass your activityId so your courier draws each lens. The result identifies the lens and reports uncategorized: changed lines no lens selects yet, grouped by file. Keep adding lenses until it is empty or what remains is deliberate. review_lens_get reads the current lenses and gaps.",
+    rename: "Change the review title.",
+    restore:
+      "Restore title, source pins, PR identity and content from a saved version.",
+    attention:
+      "Mark a review viewed, dismissed or restored without changing its content.",
+    delete: "Permanently delete this review and its history.",
+  };
+
+  const tool = (
+    name: string,
+    description: string,
+    schema: z.ZodType,
+    method: "GET" | "POST",
+    path: string,
+    commandType?: string,
+  ) => ({
+    name: `review_${name}`,
+    description,
+    inputSchema: {
+      ...z.toJSONSchema(schema, { io: "input" }),
+      type: "object" as const,
+    },
+    method,
+    path,
+    commandType,
+  });
+
+  return [
+    REVIEW_STATUS_TOOL,
+    tool(
+      "capabilities",
+      "Discover whether Desktop is available and optional software-map generation is enabled. Read before authoring.",
+      z.strictObject({}),
+      "GET",
+      "/capabilities",
+    ),
+    tool(
+      "get_instructions",
+      'Read Whiteboard\'s guidance before creating or editing a review. The default topic gives the authoring workflow; "file-lenses" covers Diff-view file lenses.' +
+        (traceEnabled
+          ? ' Call review_get_instructions({topic:"trace-archaeology"}) for why code exists, what an agent was thinking, or whether an agent solved this before.'
+          : "") +
+        (scratchpadAvailable
+          ? ' When the user asks in conversation to be shown how code works or wants a diagram, without asking for a review, draw it on the scratchpad rather than answering only in chat: call review_get_instructions({topic:"scratchpad"}) first. A request for a review or to use Whiteboard means authoring a review with the default topic.'
+          : ""),
+      instructionsQuerySchema.partial(),
+      "GET",
+      "/instructions",
+    ),
+    tool(
+      "activity_begin",
+      "Show that you are working on a review: the reader sees your focus and your courier drawing your edits, and the review reads as finished only once every agent has ended. Returns an activityId: pass it to session_edit and session_lens_edit so your courier draws them, and to review_activity_update and review_activity_end. Nothing is locked; other agents can work on the review too. The activity expires after 3 minutes without an edit or update.",
+      activityBeginSchema.extend(review),
+      "POST",
+      "/:reviewId/activity/begin",
+    ),
+    tool(
+      "activity_update",
+      "Change your focus, or keep your activity alive during long reads or pauses; an edit carrying your activityId already keeps it alive. Omitted focus preserves it and null clears it. Fails once the activity has expired: begin a new one.",
+      activityUpdateSchema.extend(review),
+      "POST",
+      "/:reviewId/activity/update",
+    ),
+    tool(
+      "activity_end",
+      "End your activity when your part is finished: readers treat a review with content and no live activity as ready. Ending it creates no document version. Ending twice, or an expired activity, changes nothing.",
+      activityEndSchema.extend(review),
+      "POST",
+      "/:reviewId/activity/end",
+    ),
+    ...commandSchema.shape.operation.options.map((operation) => {
+      const type = operation.shape.type.value;
+
+      // Agents name a checkout by its path; /commands registers it.
+      const {
+        type: _type,
+        repositoryId: _repositoryId,
+        ...fields
+      }: Record<string, z.ZodType> = operation.shape;
+
+      return tool(
+        type,
+        descriptions[type],
+        z.strictObject({
+          ...fields,
+          ...(type === "create" && {
+            target: pathTargetSchema.optional(),
+            repositoryPath: id
+              .optional()
+              .describe(
+                "Only with pullRequestUrl and no target: the local checkout to fetch the PR into. Default: the existing review's, else the first registered checkout with a remote for the PR's repository.",
+              ),
+            open: z.boolean().optional(),
+          }),
+          ...(type === "set_target" && { target: pathTargetSchema }),
+          ...(type === "edit" && { edit: publishedEditSchema }),
+        }),
+        "POST",
+        "/commands",
+        type,
+      );
+    }),
+    tool("list", "List saved reviews.", z.strictObject({}), "GET", ""),
+    tool(
+      "get",
+      "Read a readable, nested text outline with editable IDs. targetId reads one component in full; full:true reads all content. Use format:json for raw node data or snapshots instead of text.",
+      z.strictObject({ ...review, ...inspectQuerySchema.shape }),
+      "GET",
+      "/:reviewId/inspect",
+    ),
+    tool(
+      "lens_get",
+      "Read the review's Diff-view lenses as authored (ids, titles, targets), each lens's resolved fileCount (and unavailable reason, if any), and uncategorized: the changed lines no lens selects yet, by file.",
+      z.strictObject(review),
+      "GET",
+      "/:reviewId/lenses",
+    ),
+    tool(
+      "history",
+      "List saved document versions.",
+      z.strictObject(review),
+      "GET",
+      "/:reviewId/history",
+    ),
+    tool(
+      "open",
+      "Show an existing review immediately and prepare current pinned checkouts in the background. Returns softwareMapEnabled and any already-recorded environmentIssues. Missing optional setup is not an issue; use review_environment to recheck.",
+      z.strictObject(review),
+      "POST",
+      "/:reviewId/open",
+    ),
+    tool(
+      "environment",
+      "Acquire and recheck this review's current base/head language checkouts (not historical or selected commits). Returns acquisition issues, not full LSP health. Missing optional setup and failed setup with a usable checkout stay silent. Set retry:true to rerun failed preparation after an actual language-feature failure; preparation runs in the background.",
+      z.strictObject({ ...review, retry: z.boolean().optional() }),
+      "POST",
+      "/:reviewId/environment",
+    ),
+    tool(
+      "workspace_cleanup",
+      "Inspect failed cleanup of retired review-owned checkouts. Supply workspaceId to retry removal of that checkout. This does not remove active review checkouts.",
+      z.strictObject({ workspaceId: id.optional() }),
+      "POST",
+      "/workspace-cleanup",
+    ),
+    tool(
+      "register_repository",
+      "Register a local Git or jj repository and return its id, for pins on scratchpad blocks. session_create and session_set_target take the checkout's path instead.",
+      z.strictObject({ path: id }),
+      "POST",
+      "/repositories",
+    ),
+    tool(
+      "upload",
+      'Retain an image or trace for use in a review. kind:"image" takes base64; kind:"trace" takes trace. Reusing an upload ID requires identical content; rejected uploads are not saved.',
+      uploadInput,
+      "POST",
+      "/resources",
+    ),
+  ];
+}

package/src/review-api/blocks/call_stack_diff.ts

@@ -0,0 +1,75 @@
+import { anchorSchema } from "@review/lens-selection.js";
+import { ReviewInputError } from "@review/review-api/input-error.js";
+import { z } from "zod";
+
+import {
+  type BlockDefinition,
+  defineBlock,
+  elementPins,
+  identity,
+  label,
+} from "./definition.js";
+
+export const frameSchema = z.strictObject({
+  ...identity,
+  // Optional component-local name for the same frame on both sides (even if moved).
+  key: label.optional(),
+  parentKey: label.nullable().optional(),
+  callSite: anchorSchema.optional(),
+  source: anchorSchema,
+  contextSources: z
+    .array(anchorSchema)
+    .max(1000)
+    .optional()
+    .describe(
+      "Supporting code owned by this frame, such as field initializers. These ranges share the frame’s diff section and coverage; they do not create call edges.",
+    ),
+  label: label.optional(),
+  pins: elementPins,
+  via: z
+    .strictObject({
+      kind: z.enum(["call", "queue", "callback", "rpc"]),
+      reason: label,
+    })
+    .optional(),
+});
+
+export type Frame = z.infer<typeof frameSchema>;
+
+const schema = defineBlock("call_stack_diff", {
+  title: label,
+  base: z.array(frameSchema),
+  head: z.array(frameSchema),
+  pins: elementPins,
+});
+
+export type CallStackDiffBlock = z.infer<typeof schema>;
+
+export const call_stack_diff = {
+  type: "call_stack_diff",
+  schema,
+  check(block: CallStackDiffBlock) {
+    for (const side of ["base", "head"] as const) {
+      const keys = block[side].flatMap((frame) =>
+        frame.key ? [frame.key] : [],
+      );
+
+      if (new Set(keys).size !== keys.length)
+        throw new ReviewInputError(`Frame keys must be unique within ${side}.`);
+
+      for (const [index, frame] of block[side].entries()) {
+        if (
+          frame.parentKey &&
+          !block[side]
+            .slice(0, index)
+            .some((parent) => parent.key === frame.parentKey)
+        )
+          throw new ReviewInputError(
+            "A frame parentKey must name an earlier frame on the same side.",
+          );
+      }
+
+      // Columns may compare two paths in one snapshot. Each source keeps its own pin.
+    }
+  },
+} satisfies BlockDefinition<CallStackDiffBlock>;

package/src/review-api/blocks/callout.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+
+import { type BlockDefinition, defineBlock, label } from "./definition.js";
+import { type Block, blockSchema } from "./index.js";
+
+export interface CalloutBlock {
+  id?: string;
+  type: "callout";
+  title?: string;
+  tone: "info" | "warning" | "danger" | "success";
+  children: Block[];
+}
+
+// blockSchema is read inside z.lazy, after every module in the cycle has evaluated.
+export const calloutSchema = defineBlock("callout", {
+  title: label.optional(),
+  tone: z.enum(["info", "warning", "danger", "success"]).default("info"),
+  children: z.array(z.lazy((): z.ZodType<Block> => blockSchema)),
+});
+
+export const callout: BlockDefinition<CalloutBlock> = {
+  type: "callout",
+  schema: calloutSchema,
+};

package/src/review-api/blocks/code.ts

@@ -0,0 +1,9 @@
+import { defineBlock, text } from "./definition.js";
+
+/** Shared with sequence steps. */
+export const codeFields = { language: text.default("text"), text };
+
+export const code = {
+  type: "code",
+  schema: defineBlock("code", { ...codeFields, caption: text.optional() }),
+} as const;

package/src/review-api/blocks/code_peek.ts

@@ -0,0 +1,13 @@
+import { anchorSchema } from "@review/lens-selection.js";
+
+import { defineBlock, elementPins, text } from "./definition.js";
+
+export const code_peek = {
+  type: "code_peek",
+  schema: defineBlock("code_peek", {
+    source: anchorSchema,
+    pins: elementPins,
+    // Not rendered yet.
+    caption: text.optional(),
+  }),
+} as const;

package/src/review-api/blocks/database_lens.ts

@@ -0,0 +1,150 @@
+import { type JsonValue, jsonValueSchema } from "@dev.fast/review-protocol";
+import { anchorSchema } from "@review/lens-selection.js";
+import { ReviewInputError } from "@review/review-api/input-error.js";
+import { z } from "zod";
+
+import {
+  type BlockDefinition,
+  defineBlock,
+  elementPins,
+  identity,
+  label,
+  requireKey,
+  text,
+} from "./definition.js";
+
+export interface DatabaseField {
+  label: string;
+  dataType: string;
+  nullable?: boolean;
+  primaryKey?: boolean;
+  references?: { store: string; collection: string; field: string };
+  /** An illustrative value shown beside the field. */
+  example?: JsonValue;
+  /** Nested fields of a document-store object field. */
+  fields?: Record<string, DatabaseField>;
+}
+
+export const fieldSchema: z.ZodType<DatabaseField> = z.lazy(() =>
+  z.strictObject({
+    label,
+    dataType: label,
+    nullable: z.boolean().optional(),
+    primaryKey: z.boolean().optional(),
+    references: z
+      .strictObject({ store: label, collection: label, field: label })
+      .optional(),
+    example: jsonValueSchema.optional(),
+    fields: z.record(text, fieldSchema).optional(),
+  }),
+);
+
+export const databaseActorSchema = z.union([
+  label,
+  z.strictObject({ label, softwareMapPath: label.optional() }),
+]);
+
+export const storeSchema = z.strictObject({
+  label,
+  storage: z.enum(["relational", "document"]),
+  dataStoreKind: z
+    .enum(["database", "objectStore", "bucket", "artifactStore", "fileStore"])
+    .optional(),
+  softwareMapPath: label.optional(),
+  collections: z.record(
+    text,
+    z.strictObject({
+      label,
+      key: label.optional(),
+      fields: z.record(text, fieldSchema),
+    }),
+  ),
+});
+
+export const operationSchema = z.strictObject({
+  ...identity,
+  kind: z.enum(["read", "write"]),
+  store: label,
+  collection: label,
+  field: label.optional(),
+  actor: label,
+  label,
+  detail: label.optional(),
+  source: anchorSchema,
+  pins: elementPins,
+});
+
+// The legacy MDX audit rejected these empty forms after a lens with
+// unresolved operations published clean and rendered a blank canvas.
+export const databaseLensSchema = defineBlock("database_lens", {
+  title: label,
+  actors: z.record(text, databaseActorSchema),
+  stores: z
+    .record(text, storeSchema)
+    .refine(
+      (stores) => Object.keys(stores).length > 0,
+      "A database lens needs at least one store.",
+    ),
+  useCases: z
+    .array(
+      z.strictObject({
+        ...identity,
+        label,
+        summary: text.optional(),
+        operations: z
+          .array(operationSchema)
+          .min(1, "A use case needs at least one operation."),
+      }),
+    )
+    .min(1, "A database lens needs at least one use case."),
+  pins: elementPins,
+});
+
+export type DatabaseLensBlock = z.infer<typeof databaseLensSchema>;
+
+export const database_lens = {
+  type: "database_lens",
+  schema: databaseLensSchema,
+  check(block: DatabaseLensBlock) {
+    const field = (store: string, collection: string, name?: string) => {
+      requireKey(block.stores, store);
+      const collections = block.stores[store]!.collections;
+      requireKey(collections, collection);
+
+      if (name === undefined) return;
+
+      // Nested document fields are addressed by dotted path.
+      let fields: Record<string, DatabaseField> | undefined =
+        collections[collection]!.fields;
+
+      for (const part of name.split(".")) {
+        if (!fields)
+          throw new ReviewInputError(`Unknown component name: ${name}`);
+        requireKey(fields, part);
+        fields = fields[part]!.fields;
+      }
+    };
+
+    for (const useCase of block.useCases)
+      for (const op of useCase.operations) {
+        requireKey(block.actors, op.actor);
+        field(op.store, op.collection, op.field);
+      }
+
+    for (const store of Object.values(block.stores))
+      for (const collection of Object.values(store.collections))
+        for (const value of Object.values(collection.fields))
+          if (value.references)
+            field(
+              value.references.store,
+              value.references.collection,
+              value.references.field,
+            );
+  },
+} satisfies BlockDefinition<DatabaseLensBlock>;
+
+export type DatabaseActor = z.infer<typeof databaseActorSchema>;
+
+export type DatabaseStore = z.infer<typeof storeSchema>;
+
+export type DatabaseOperation = z.infer<typeof operationSchema>;

package/src/review-api/blocks/definition.ts

@@ -0,0 +1,40 @@
+import { ReviewInputError } from "@review/review-api/input-error.js";
+import { sourcePinsSchema } from "@review/source.js";
+import { z } from "zod";
+
+export const text = z.string();
+
+export const label = text.trim().min(1);
+
+export const identity = { id: text.optional() };
+
+/** The repository and commits an element's anchors quote. A step, frame,
+ * attachment or operation without them reads its block's; a block without
+ * them reads its document's. */
+export const elementPins = sourcePinsSchema
+  .optional()
+  .describe("Pins for the anchors here; needed on the scratchpad.");
+
+/**
+ * One block kind: the strict schema the store parses with, and the rules a
+ * field schema cannot express. `check` throws ReviewInputError.
+ */
+export interface BlockDefinition<Content extends { type: string }> {
+  type: Content["type"];
+  schema: z.ZodType<Content>;
+  check?(block: Content): void;
+}
+
+/** The strict schema for a block's own fields; id and type are added here. */
+export function defineBlock<
+  Type extends string,
+  Props extends Record<string, z.ZodType>,
+>(type: Type, props: Props) {
+  return z.strictObject({ ...identity, type: z.literal(type), ...props });
+}
+
+/** Shared by every check that resolves a component-local name. */
+export function requireKey<T>(record: Record<string, T>, name: string): void {
+  if (!Object.hasOwn(record, name))
+    throw new ReviewInputError(`Unknown component name: ${name}`);
+}

package/src/review-api/blocks/divider.ts

@@ -0,0 +1,6 @@
+import { defineBlock } from "./definition.js";
+
+export const divider = {
+  type: "divider",
+  schema: defineBlock("divider", {}),
+} as const;

package/src/review-api/blocks/flow_diagram.ts

@@ -0,0 +1,111 @@
+import {
+  type DiffSelection,
+  anchorSchema,
+  anchorSelection,
+} from "@review/lens-selection.js";
+import { ReviewInputError } from "@review/review-api/input-error.js";
+import { z } from "zod";
+
+import {
+  type BlockDefinition,
+  defineBlock,
+  elementPins,
+  identity,
+  label,
+} from "./definition.js";
+
+/** Nodes and edges are the diagram's children: each is its own edit target,
+ * so an agent can draw a diagram one unit at a time. Edges still name nodes
+ * by their diagram-local key. */
+export const flowNodeSchema = z.strictObject({
+  ...identity,
+  type: z.literal("flow_node").default("flow_node"),
+  key: label,
+  label,
+  description: z.string().optional(),
+  kind: z.enum(["process", "decision", "terminal"]).optional(),
+  attachments: z
+    .array(
+      z.strictObject({
+        label,
+        sources: z.array(anchorSchema).min(1),
+        pins: elementPins,
+      }),
+    )
+    .default([])
+    .describe(
+      "Code evidence for this node. Omit for nodes no code backs, such as start or exit states.",
+    ),
+});
+
+export const flowEdgeSchema = z.strictObject({
+  ...identity,
+  type: z.literal("flow_edge").default("flow_edge"),
+  from: label,
+  to: label,
+  label: z.string().optional(),
+  style: z.enum(["solid", "dashed"]).optional(),
+});
+
+/** The edge a new node arrives with: `from` a node already drawn to this
+ * one, or from this one `to` a node already drawn. Insert-time only; the
+ * server stores it as an ordinary edge. */
+export const flowLinkSchema = z.strictObject({
+  from: label.optional(),
+  to: label.optional(),
+  label: z.string().optional(),
+  style: z.enum(["solid", "dashed"]).optional(),
+});
+
+export const flowNodeInsertSchema = flowNodeSchema.extend({
+  link: flowLinkSchema.optional(),
+});
+
+export const flowDiagramSchema = defineBlock("flow_diagram", {
+  title: label,
+  description: z.string().optional(),
+  direction: z.enum(["right", "down"]).optional(),
+  nodes: z.array(flowNodeSchema).min(1).max(100),
+  edges: z.array(flowEdgeSchema).max(300),
+  pins: elementPins,
+});
+
+export type FlowDiagramBlock = z.infer<typeof flowDiagramSchema>;
+
+export type FlowDiagramNode = z.infer<typeof flowNodeSchema>;
+
+/** A node's evidence, each anchor read at its attachment's pins, else the
+ * diagram's. */
+export function nodeSources(
+  node: FlowDiagramNode,
+  diagramPins: FlowDiagramBlock["pins"],
+): { label: string; source: DiffSelection }[] {
+  return node.attachments.flatMap((attachment) =>
+    attachment.sources.map((anchor) => ({
+      label: attachment.label,
+      source: anchorSelection(anchor, attachment.pins ?? diagramPins),
+    })),
+  );
+}
+
+export type FlowDiagramEdge = z.infer<typeof flowEdgeSchema>;
+
+export const flow_diagram = {
+  type: "flow_diagram",
+  schema: flowDiagramSchema,
+  check(block: FlowDiagramBlock) {
+    const keys = new Set(block.nodes.map((node) => node.key));
+
+    if (keys.size !== block.nodes.length)
+      throw new ReviewInputError(
+        "Flow node keys must be unique within the diagram.",
+      );
+
+    for (const edge of block.edges) {
+      if (!keys.has(edge.from) || !keys.has(edge.to))
+        throw new ReviewInputError(
+          `Unknown flow endpoint: ${edge.from} → ${edge.to}`,
+        );
+    }
+  },
+} satisfies BlockDefinition<FlowDiagramBlock>;

package/src/review-api/blocks/image.ts

@@ -0,0 +1,10 @@
+import { defineBlock, label, text } from "./definition.js";
+
+export const image = {
+  type: "image",
+  schema: defineBlock("image", {
+    assetId: label,
+    alt: label,
+    caption: text.optional(),
+  }),
+} as const;