chalkbridge 1.0.0

package/dist/chunk-HFKCLTVU.js

@@ -0,0 +1,1494 @@
+import { z } from 'zod';
+
+// src/domain/result.ts
+var ok = (value) => ({ ok: true, value });
+var fail = (error) => ({ ok: false, error });
+var isOk = (r) => r.ok;
+var isFail = (r) => !r.ok;
+var partition = (results) => {
+  const applied = [];
+  const rejected = [];
+  for (const r of results) {
+    if (r.ok) applied.push(r.value);
+    else rejected.push(r.error);
+  }
+  return { applied, rejected };
+};
+var nonEmpty = z.string().min(1);
+var SceneId = nonEmpty.brand();
+var ElementId = nonEmpty.brand();
+var GroupId = nonEmpty.brand();
+var FrameId = nonEmpty.brand();
+var IconId = nonEmpty.brand();
+var PackName = z.string().regex(/^[a-z0-9][a-z0-9-]*$/, "pack names are lowercase kebab-case").brand();
+var SnapshotId = nonEmpty.brand();
+var frameIdOf = (id) => FrameId.parse(id);
+
+// ../shared/dist/element.js
+var isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
+var isNonEmptyString = (v) => typeof v === "string" && v.length > 0;
+var Angle = z.custom(isFiniteNumber, {
+  message: "angle must be a finite number of radians"
+});
+var Index = z.custom(isNonEmptyString, {
+  message: "index must be a non-empty fractional-index string"
+});
+var LineHeight = z.custom(isFiniteNumber, {
+  message: "lineHeight is unitless \u2014 multiply by fontSize to get px"
+});
+var Point = z.custom((v) => Array.isArray(v) && v.length === 2 && v.every(isFiniteNumber), { message: "a point is [x, y]" });
+var point = (x, y) => Point.parse([x, y]);
+var FileId = z.custom(isNonEmptyString, {
+  message: "fileId must be a non-empty string"
+});
+var FillStyle = z.enum(["hachure", "cross-hatch", "solid", "zigzag"]);
+var StrokeStyle = z.enum(["solid", "dashed", "dotted"]);
+var TextAlign = z.enum(["left", "center", "right"]);
+var VerticalAlign = z.enum(["top", "middle", "bottom"]);
+var Arrowhead = z.enum([
+  "arrow",
+  "bar",
+  "dot",
+  "circle",
+  "circle_outline",
+  "triangle",
+  "triangle_outline",
+  "diamond",
+  "diamond_outline",
+  "crowfoot_one",
+  "crowfoot_many",
+  "crowfoot_one_or_many"
+]);
+var ROUNDNESS = {
+  LEGACY: 1,
+  PROPORTIONAL_RADIUS: 2,
+  ADAPTIVE_RADIUS: 3
+};
+var RoundnessType = z.union([z.literal(1), z.literal(2), z.literal(3)]);
+var Roundness = z.object({
+  type: RoundnessType,
+  value: z.number().optional()
+});
+var FONT_FAMILY = {
+  Excalifont: 5};
+var FontFamily = z.number().int();
+var BoundElementRef = z.object({
+  id: ElementId,
+  type: z.enum(["arrow", "text"])
+});
+var PointBinding = z.object({
+  elementId: ElementId,
+  focus: z.number(),
+  gap: z.number()
+});
+var ChalkAuthor = z.enum(["human", "claude"]);
+var ChalkMeta = z.object({
+  author: ChalkAuthor,
+  kind: z.enum(["icon", "note", "embed"]).optional(),
+  iconId: IconId.optional(),
+  anchorIds: z.array(ElementId).optional()
+});
+var CustomData = z.looseObject({ chalk: ChalkMeta.optional() });
+var base = {
+  id: ElementId,
+  x: z.number(),
+  y: z.number(),
+  width: z.number(),
+  height: z.number(),
+  angle: Angle,
+  strokeColor: z.string(),
+  backgroundColor: z.string(),
+  fillStyle: FillStyle,
+  strokeWidth: z.number(),
+  strokeStyle: StrokeStyle,
+  roughness: z.number(),
+  opacity: z.number(),
+  roundness: Roundness.nullable(),
+  groupIds: z.array(GroupId),
+  frameId: FrameId.nullable(),
+  /**
+   * Defaulted rather than required: a file written by another tool may leave it out,
+   * and `null` is what "no bindings" means. It also keeps every caller out of the
+   * business of *assigning* a binding field — the one thing invariant 16 exists to stop,
+   * and what `tooling/lint-rules/no-hand-bindings.test.ts` checks for by name.
+   */
+  boundElements: z.array(BoundElementRef).nullable().default(null),
+  link: z.string().nullable(),
+  locked: z.boolean(),
+  index: Index.nullable(),
+  // Server-managed. Parsed here because the browser and the disk send them;
+  // rejected from Claude by the tool input schemas (invariant 29), not by this file.
+  seed: z.number(),
+  version: z.number(),
+  versionNonce: z.number(),
+  updated: z.number(),
+  isDeleted: z.boolean(),
+  customData: CustomData.optional()
+};
+var linear = {
+  ...base,
+  points: z.array(Point),
+  lastCommittedPoint: Point.nullable(),
+  startBinding: PointBinding.nullable(),
+  endBinding: PointBinding.nullable(),
+  startArrowhead: Arrowhead.nullable(),
+  endArrowhead: Arrowhead.nullable()
+};
+var RectangleElement = z.looseObject({ ...base, type: z.literal("rectangle") });
+var DiamondElement = z.looseObject({ ...base, type: z.literal("diamond") });
+var EllipseElement = z.looseObject({ ...base, type: z.literal("ellipse") });
+var EmbeddableElement = z.looseObject({ ...base, type: z.literal("embeddable") });
+var TextElement = z.looseObject({
+  ...base,
+  type: z.literal("text"),
+  text: z.string(),
+  originalText: z.string(),
+  fontSize: z.number(),
+  fontFamily: FontFamily,
+  textAlign: TextAlign,
+  verticalAlign: VerticalAlign,
+  lineHeight: LineHeight,
+  autoResize: z.boolean(),
+  containerId: ElementId.nullable()
+});
+var LineElement = z.looseObject({ ...linear, type: z.literal("line") });
+var ArrowElement = z.looseObject({
+  ...linear,
+  type: z.literal("arrow"),
+  elbowed: z.boolean().default(false)
+});
+var FreedrawElement = z.looseObject({
+  ...base,
+  type: z.literal("freedraw"),
+  points: z.array(Point),
+  pressures: z.array(z.number()),
+  simulatePressure: z.boolean(),
+  lastCommittedPoint: Point.nullable()
+});
+var ImageElement = z.looseObject({
+  ...base,
+  type: z.literal("image"),
+  fileId: FileId.nullable(),
+  status: z.enum(["pending", "saved", "error"]),
+  scale: z.tuple([z.number(), z.number()]),
+  crop: z.object({
+    x: z.number(),
+    y: z.number(),
+    width: z.number(),
+    height: z.number(),
+    naturalWidth: z.number(),
+    naturalHeight: z.number()
+  }).nullable()
+});
+var FrameElement = z.looseObject({
+  ...base,
+  type: z.literal("frame"),
+  name: z.string().nullable()
+});
+var SceneElement = z.discriminatedUnion("type", [
+  RectangleElement,
+  DiamondElement,
+  EllipseElement,
+  TextElement,
+  LineElement,
+  ArrowElement,
+  FreedrawElement,
+  ImageElement,
+  FrameElement,
+  EmbeddableElement
+]);
+var ElementType = z.enum([
+  "rectangle",
+  "diamond",
+  "ellipse",
+  "text",
+  "line",
+  "arrow",
+  "freedraw",
+  "image",
+  "frame",
+  "embeddable"
+]);
+var SERVER_MANAGED_FIELDS = [
+  "seed",
+  "version",
+  "versionNonce",
+  "updated",
+  "isDeleted",
+  "index"
+];
+var BINDING_FIELDS = [
+  "boundElements",
+  "containerId",
+  "startBinding",
+  "endBinding"
+];
+var SceneFile = z.object({
+  id: FileId,
+  mimeType: z.string(),
+  dataURL: z.string(),
+  created: z.number(),
+  lastRetrieved: z.number().optional()
+});
+var SceneFiles = z.record(z.string(), SceneFile);
+var skeletonStyle = {
+  width: z.number().optional(),
+  height: z.number().optional(),
+  angle: Angle.optional(),
+  strokeColor: z.string().optional(),
+  backgroundColor: z.string().optional(),
+  fillStyle: FillStyle.optional(),
+  strokeWidth: z.number().optional(),
+  strokeStyle: StrokeStyle.optional(),
+  roughness: z.number().optional(),
+  opacity: z.number().optional(),
+  roundness: Roundness.nullish(),
+  groupIds: z.array(GroupId).optional(),
+  frameId: FrameId.nullish(),
+  link: z.string().nullish(),
+  locked: z.boolean().optional(),
+  customData: CustomData.optional()
+};
+var SkeletonLabel = z.object({
+  text: z.string(),
+  fontSize: z.number().optional(),
+  fontFamily: FontFamily.optional(),
+  textAlign: TextAlign.optional(),
+  verticalAlign: VerticalAlign.optional(),
+  strokeColor: z.string().optional()
+});
+var SkeletonEndpoint = z.union([
+  z.object({ id: ElementId, type: z.enum(["rectangle", "diamond", "ellipse"]).optional() }),
+  z.object({ type: z.enum(["rectangle", "diamond", "ellipse"]), id: ElementId.optional() })
+]);
+var ContainerSkeleton = z.strictObject({
+  ...skeletonStyle,
+  type: z.enum(["rectangle", "diamond", "ellipse"]),
+  id: ElementId,
+  x: z.number(),
+  y: z.number(),
+  label: SkeletonLabel.optional()
+});
+var LinearSkeleton = z.strictObject({
+  ...skeletonStyle,
+  type: z.enum(["arrow", "line"]),
+  id: ElementId,
+  x: z.number(),
+  y: z.number(),
+  label: SkeletonLabel.optional(),
+  start: SkeletonEndpoint.optional(),
+  end: SkeletonEndpoint.optional(),
+  points: z.array(Point).optional(),
+  startArrowhead: Arrowhead.nullish(),
+  endArrowhead: Arrowhead.nullish(),
+  elbowed: z.boolean().optional()
+});
+var TextSkeleton = z.strictObject({
+  ...skeletonStyle,
+  type: z.literal("text"),
+  id: ElementId,
+  x: z.number(),
+  y: z.number(),
+  text: z.string(),
+  fontSize: z.number().optional(),
+  fontFamily: FontFamily.optional(),
+  textAlign: TextAlign.optional(),
+  verticalAlign: VerticalAlign.optional()
+});
+var FrameSkeleton = z.strictObject({
+  type: z.literal("frame"),
+  id: ElementId,
+  children: z.array(ElementId),
+  name: z.string().optional(),
+  x: z.number().optional(),
+  y: z.number().optional(),
+  width: z.number().optional(),
+  height: z.number().optional(),
+  customData: CustomData.optional()
+});
+var ImageSkeleton = z.strictObject({
+  ...skeletonStyle,
+  type: z.literal("image"),
+  id: ElementId,
+  x: z.number(),
+  y: z.number(),
+  fileId: FileId
+});
+var EmbeddableSkeleton = z.strictObject({
+  ...skeletonStyle,
+  type: z.literal("embeddable"),
+  id: ElementId,
+  x: z.number(),
+  y: z.number(),
+  link: z.string()
+});
+z.union([
+  ContainerSkeleton,
+  LinearSkeleton,
+  TextSkeleton,
+  FrameSkeleton,
+  ImageSkeleton,
+  EmbeddableSkeleton
+]);
+
+// ../shared/dist/describe.js
+var DetailLevel = z.enum(["compact", "full"]);
+var ElementFlag = z.enum(["selected", "link", "locked"]);
+var FLAG_GLYPH = {
+  selected: "*",
+  link: "\u2197link",
+  locked: "\u{1F512}"
+};
+var Bounds = z.object({
+  x: z.number(),
+  y: z.number(),
+  width: z.number(),
+  height: z.number()
+});
+var DescribedKind = z.object({
+  type: ElementType,
+  iconId: IconId.nullish()
+});
+var DescribedFrame = z.object({
+  id: FrameId,
+  /** The stable short handle shown in the DSL — `F1`, `F2`. */
+  handle: z.string(),
+  name: z.string().nullable(),
+  bounds: Bounds
+});
+var DescribedStyle = z.object({
+  strokeColor: z.string(),
+  backgroundColor: z.string(),
+  strokeStyle: z.string(),
+  fillStyle: z.string(),
+  opacity: z.number(),
+  fontSize: z.number().nullish(),
+  fontFamily: z.number().nullish()
+});
+var DescribedElement = z.object({
+  id: ElementId,
+  /** Short, human-quotable id prefix — what Claude and the user say out loud. */
+  shortId: z.string(),
+  kind: DescribedKind,
+  label: z.string().nullable(),
+  bounds: Bounds.nullable(),
+  version: z.number().int(),
+  author: ChalkAuthor,
+  frameHandle: z.string().nullable(),
+  flags: z.array(ElementFlag),
+  /** Populated for arrows and lines only. */
+  from: ElementId.nullish(),
+  to: ElementId.nullish(),
+  style: DescribedStyle.nullish()
+});
+var SceneDescription = z.object({
+  sceneId: SceneId,
+  name: z.string(),
+  sceneVersion: z.number().int(),
+  elementCount: z.number().int(),
+  updatedAgoMs: z.number().int(),
+  frames: z.array(DescribedFrame),
+  elements: z.array(DescribedElement),
+  detail: DetailLevel
+});
+var DescribedEdge = z.object({
+  id: ElementId,
+  shortId: z.string(),
+  from: ElementId,
+  fromLabel: z.string().nullable(),
+  to: ElementId,
+  toLabel: z.string().nullable(),
+  label: z.string().nullable()
+});
+var SelectionDescription = z.object({
+  sceneId: SceneId,
+  elements: z.array(DescribedElement),
+  edgesInside: z.array(DescribedEdge),
+  edgesCrossingBoundary: z.array(DescribedEdge),
+  frames: z.array(DescribedFrame),
+  selectedAgoMs: z.number().int().nullable(),
+  /** True past `STALE_SELECTION_MS`; the renderer appends the confirm-with-the-user note. */
+  stale: z.boolean()
+});
+var STALE_SELECTION_MS = 12e4;
+var KIND_ABBREVIATION = {
+  rectangle: "rect",
+  diamond: "diamond",
+  ellipse: "ellipse",
+  text: "text",
+  line: "line",
+  arrow: "arrow",
+  freedraw: "draw",
+  image: "image",
+  frame: "frame",
+  embeddable: "embed"
+};
+var PackKind = z.enum(["bundled", "npm", "vendor", "library"]);
+var iconIdOf = (pack, name) => IconId.parse(`${pack}/${name}`);
+var IconSummary = z.object({
+  id: IconId,
+  pack: PackName,
+  name: z.string(),
+  tags: z.array(z.string()),
+  license: z.string()
+});
+var IconArt = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("svg"),
+    svg: z.string().min(1),
+    width: z.number().positive(),
+    height: z.number().positive()
+  }),
+  z.object({
+    kind: z.literal("elements"),
+    elements: z.array(SceneElement).min(1),
+    width: z.number().positive(),
+    height: z.number().positive()
+  })
+]);
+var IconItem = IconSummary.extend({ art: IconArt });
+var PackReceipt = z.object({
+  pack: PackName,
+  kind: PackKind,
+  version: z.string(),
+  source: z.string(),
+  license: z.string(),
+  iconCount: z.number().int().nonnegative(),
+  installedAt: z.number().int()
+});
+var PackRecipe = z.object({
+  name: PackName,
+  kind: PackKind.default("vendor"),
+  license: z.string(),
+  source: z.string(),
+  /**
+   * The npm package to install for `kind: npm`. Defaults to the `@chalkbridge/pack-<name>`
+   * convention (§2.6), and named explicitly when an upstream project already publishes
+   * its own SVGs — Devicon and Simple Icons both do, and re-publishing them under our
+   * scope would be a fork of somebody else artwork for no reason.
+   */
+  npmPackage: z.string().optional(),
+  /** Where the SVGs are, inside the installed package or the unzipped folder. */
+  svgDir: z.string().default(""),
+  /**
+   * Only ingest files whose path contains one of these, case-insensitively.
+   *
+   * Icon sets routinely ship four variants of every glyph. Without this, `react-line`,
+   * `react-original` and `react-plain` all normalise to `react`, two of the three are
+   * skipped as duplicates, and *which* one survives depends on directory order.
+   */
+  include: z.array(z.string()).default([]),
+  /** Shown verbatim by `chalk_install_pack` and `chalkbridge icons install`. */
+  instructions: z.array(z.string()).default([]),
+  tagRules: z.object({
+    fromPathSegments: z.boolean().default(true),
+    strip: z.array(z.string()).default([])
+  }).default({ fromPathSegments: true, strip: [] }),
+  synonyms: z.record(z.string(), z.array(z.string())).default({})
+});
+var PackHealth = z.object({
+  pack: PackName,
+  kind: PackKind,
+  /** What the receipt claims. */
+  expected: z.number().int().nonnegative(),
+  /** What the `icons` table actually holds. */
+  indexed: z.number().int().nonnegative(),
+  /** Whether the pack's directory is still where the receipt says. `null` for bundled. */
+  filesPresent: z.boolean().nullable(),
+  problems: z.array(z.string())
+});
+var AppState = z.looseObject({
+  viewBackgroundColor: z.string().optional(),
+  gridSize: z.number().nullish(),
+  gridModeEnabled: z.boolean().optional(),
+  theme: z.enum(["light", "dark"]).optional(),
+  name: z.string().nullish()
+});
+var SceneResolvedVia = z.enum(["requested", "browser", "most-recent"]);
+var SceneSettings = z.object({
+  viewBackgroundColor: z.string().nullable(),
+  gridSize: z.number().nullable(),
+  gridModeEnabled: z.boolean().nullable(),
+  theme: z.enum(["light", "dark"]).nullable(),
+  name: z.string().nullable()
+});
+var SceneSettingsPatch = z.strictObject({
+  viewBackgroundColor: z.string().optional(),
+  gridSize: z.number().nullish(),
+  gridModeEnabled: z.boolean().optional(),
+  theme: z.enum(["light", "dark"]).optional(),
+  name: z.string().optional()
+}, {
+  // The refusal has to teach, and it has to do it *from the schema*: an MCP client
+  // validates against the published `inputSchema` and never reaches a handler, so a
+  // message written in `interfaces/` would never be seen. Zod's default here is
+  // "Unrecognized key: scrollX", which says what happened and nothing about what to do.
+  error: (issue) => issue.code === "unrecognized_keys" ? `${issue.keys.join(", ")} is not a scene setting \u2014 the viewport belongs to the user, and chalk_focus is how you draw their attention to something` : void 0
+});
+var Scene = z.object({
+  id: SceneId,
+  name: z.string(),
+  /** Where it lives in the repo, relative to the repo root. `null` until first saved. */
+  repoPath: z.string().nullable(),
+  elements: z.array(SceneElement),
+  appState: AppState,
+  files: SceneFiles,
+  /**
+   * Bumped on every mutation, independent of per-element `version`. This is what the
+   * browser reconciles against and what `chalk_describe_scene` reports.
+   */
+  sceneVersion: z.number().int().nonnegative(),
+  updatedAt: z.number().int(),
+  /**
+   * The mtime of the `.excalidraw` file as Chalkbridge last wrote it, or `null` if it
+   * has never been written. A watcher event carrying a different mtime is somebody
+   * else's edit, which is how invariant 24 tells "our own write echoing back" from "a
+   * change that must not silently win".
+   */
+  diskMtime: z.number().int().nullable(),
+  /**
+   * The `sceneVersion` that last reached the `.excalidraw` file, or `null` if none has.
+   *
+   * This is what makes "is the repo file up to date?" answerable after a restart. It
+   * matters because a bridge does not always get to shut down gracefully — on Windows a
+   * `SIGTERM` from another process terminates it outright, and the handler that flushes
+   * pending writes never runs. The work is safe either way (it is in `chalk.db`), but
+   * without this the file would stay behind until the next edit.
+   */
+  writtenSceneVersion: z.number().int().nullable()
+});
+var SceneSummary = z.object({
+  id: SceneId,
+  name: z.string(),
+  repoPath: z.string().nullable(),
+  elementCount: z.number().int().nonnegative(),
+  sceneVersion: z.number().int().nonnegative(),
+  updatedAt: z.number().int()
+});
+z.object({
+  sceneId: SceneId,
+  elementIds: z.array(ElementId),
+  at: z.number().int()
+});
+var HealthResponse = z.object({
+  service: z.literal("chalkbridge"),
+  version: z.string(),
+  pid: z.number().int(),
+  repoRoot: z.string(),
+  port: z.number().int(),
+  /** How many browser tabs are subscribed. Zero is what triggers auto-open. */
+  uiClients: z.number().int().nonnegative(),
+  sceneCount: z.number().int().nonnegative(),
+  uptimeMs: z.number().int().nonnegative()
+});
+var DebugElementRequest = z.object({
+  sceneId: SceneId.optional(),
+  x: z.number().default(120),
+  y: z.number().default(140),
+  label: z.string().default("hello from the bridge")
+});
+z.object({
+  sceneId: SceneId,
+  sceneVersion: z.number().int(),
+  created: z.array(ElementId),
+  /** Browsers the patch was pushed to. Zero is a success, not a failure — §4. */
+  broadcastTo: z.number().int().nonnegative()
+});
+var EXCALIDRAW_FILE_TYPE = "excalidraw";
+var EXCALIDRAW_FILE_VERSION = 2;
+var ExcalidrawFile = z.looseObject({
+  type: z.literal(EXCALIDRAW_FILE_TYPE),
+  version: z.number().int(),
+  /** Which app wrote it. Informational — Excalidraw's `restore` ignores it. */
+  source: z.string(),
+  elements: z.array(SceneElement),
+  appState: AppState.default({}),
+  files: SceneFiles.default({})
+});
+var ApiError = z.object({
+  code: z.string(),
+  message: z.string(),
+  hint: z.string().optional(),
+  tool: z.string().optional()
+});
+
+// ../shared/dist/protocol.js
+var PROTOCOL_VERSION = 1;
+var PatchOrigin = z.enum(["claude", "restore", "import", "disk"]);
+var ClaudeActivity = z.enum(["idle", "reading", "writing"]);
+var ExportFormat = z.enum(["png", "svg"]);
+var AppStatePatch = AppState;
+var Hello = z.object({
+  t: z.literal("hello"),
+  protocolVersion: z.number().int(),
+  clientId: z.string().min(1),
+  sceneId: SceneId.nullish()
+});
+var SceneDelta = z.object({
+  t: z.literal("scene_delta"),
+  sceneId: SceneId,
+  elements: z.array(SceneElement),
+  appState: AppStatePatch.optional(),
+  files: SceneFiles.optional(),
+  at: z.number().int()
+});
+var Selection = z.object({
+  t: z.literal("selection"),
+  sceneId: SceneId,
+  elementIds: z.array(ElementId),
+  at: z.number().int()
+});
+var ExportResult = z.object({
+  t: z.literal("export_result"),
+  requestId: z.string().min(1),
+  ok: z.boolean(),
+  dataUrl: z.string().optional(),
+  error: z.string().optional()
+});
+var ClientMessage = z.discriminatedUnion("t", [
+  Hello,
+  SceneDelta,
+  Selection,
+  ExportResult
+]);
+var ScenePatch = z.object({
+  t: z.literal("scene_patch"),
+  sceneId: SceneId,
+  origin: PatchOrigin,
+  sceneVersion: z.number().int(),
+  elements: z.array(SceneElement),
+  removedIds: z.array(ElementId).optional(),
+  appState: AppStatePatch.optional(),
+  files: SceneFiles.optional()
+});
+var ExportRequest = z.object({
+  t: z.literal("export_request"),
+  requestId: z.string().min(1),
+  sceneId: SceneId,
+  format: ExportFormat,
+  elementIds: z.array(ElementId).optional(),
+  scale: z.number().optional(),
+  background: z.boolean().optional(),
+  darkMode: z.boolean().optional(),
+  padding: z.number().optional(),
+  embedScene: z.boolean().optional()
+});
+var Presence = z.object({
+  t: z.literal("presence"),
+  activity: ClaudeActivity,
+  lastReadAt: z.number().int().nullish()
+});
+var Focus = z.object({
+  t: z.literal("focus"),
+  sceneId: SceneId,
+  elementIds: z.array(ElementId),
+  zoomToFit: z.boolean()
+});
+var DiskConflict = z.object({
+  t: z.literal("disk_conflict"),
+  sceneId: SceneId,
+  path: z.string(),
+  diskMtime: z.number().int(),
+  message: z.string()
+});
+z.discriminatedUnion("t", [
+  ScenePatch,
+  ExportRequest,
+  Presence,
+  Focus,
+  DiskConflict
+]);
+function assertNever(value) {
+  throw new Error(`unhandled variant: ${JSON.stringify(value)}`);
+}
+var ROLES = ["compute", "storage", "edge", "external", "hotspot"];
+var Role = z.enum(ROLES, {
+  error: (issue) => `unknown role ${JSON.stringify(issue.input)} \u2014 valid: ${ROLES.join(", ")}`
+});
+var HOUSE = {
+  roughness: 1,
+  strokeWidth: 2,
+  fillStyle: "solid",
+  /**
+   * 5 = Excalifont, the installed `DEFAULT_FONT_FAMILY`. BUILD-SPEC §12.2 originally
+   * said 1 (Virgil), which is the *legacy* hand-drawn face — text drawn by Claude
+   * would not have matched text drawn by the user in the same scene. Verified against
+   * the installed 0.18.1; see `style.test.ts`.
+   */
+  fontFamily: FONT_FAMILY.Excalifont,
+  fontSize: 20,
+  /** 3 = ADAPTIVE_RADIUS. The expander leaves `roundness: null`, so this is explicit. */
+  roundness: { type: ROUNDNESS.ADAPTIVE_RADIUS },
+  roles: {
+    compute: { strokeColor: "#1971c2", backgroundColor: "#a5d8ff" },
+    storage: { strokeColor: "#2f9e44", backgroundColor: "#b2f2bb" },
+    edge: { strokeColor: "#f08c00", backgroundColor: "#ffec99" },
+    external: { strokeColor: "#1e1e1e", backgroundColor: "transparent" },
+    hotspot: { strokeColor: "#e03131", backgroundColor: "#ffc9c9" }
+  },
+  sizes: { service: [180, 80], icon: 64, framePad: 40 },
+  spacing: { h: 60, v: 100 }
+};
+var CreatableType = z.enum(["rectangle", "diamond", "ellipse", "text", "line"], {
+  error: (issue) => issue.input === "arrow" ? "arrow rejected \u2014 use chalk_connect(fromId, toId), it handles the bindings" : `unknown element type ${JSON.stringify(issue.input)} \u2014 valid: rectangle, diamond, ellipse, text, line, and chalk_connect for arrows`
+});
+var refusedFieldMessage = (keys) => {
+  const bindings = keys.filter((key) => BINDING_FIELDS.includes(key));
+  const managed = keys.filter((key) => SERVER_MANAGED_FIELDS.includes(key));
+  if (bindings.length > 0) {
+    return `${bindings.join(", ")} is server-managed \u2014 pass label: { text } for a caption, and use chalk_connect for an arrow`;
+  }
+  if (managed.length > 0) {
+    return `${managed.join(", ")} is server-managed \u2014 Chalkbridge assigns it; use expectedVersion on chalk_update_elements to say what you read`;
+  }
+  return `${keys.join(", ")} is not an element property`;
+};
+var ElementInput = z.strictObject({
+  type: CreatableType,
+  id: ElementId.optional(),
+  x: z.number(),
+  y: z.number(),
+  // ---- Tier 1 -------------------------------------------------------------
+  role: Role.optional(),
+  label: z.string().optional(),
+  // ---- Tier 2 -------------------------------------------------------------
+  width: z.number().positive().optional(),
+  height: z.number().positive().optional(),
+  text: z.string().optional(),
+  strokeColor: z.string().optional(),
+  backgroundColor: z.string().optional(),
+  fillStyle: FillStyle.optional(),
+  strokeWidth: z.union([z.literal(1), z.literal(2), z.literal(4)]).optional(),
+  strokeStyle: StrokeStyle.optional(),
+  roughness: z.union([z.literal(0), z.literal(1), z.literal(2)]).optional(),
+  opacity: z.number().min(0).max(100).optional(),
+  roundness: Roundness.nullish(),
+  /** Radians, not degrees — EXCALIDRAW-SURFACE §3. */
+  angle: z.number().optional(),
+  fontSize: z.number().positive().optional(),
+  fontFamily: FontFamily.optional(),
+  textAlign: TextAlign.optional(),
+  verticalAlign: VerticalAlign.optional(),
+  link: z.string().nullish(),
+  locked: z.boolean().optional(),
+  groupIds: z.array(GroupId).optional(),
+  frameId: FrameId.nullish()
+}, {
+  error: (issue) => issue.code === "unrecognized_keys" ? refusedFieldMessage(issue.keys) : void 0
+});
+var ElementPatch = ElementInput.partial().omit({ type: true, id: true });
+[...SERVER_MANAGED_FIELDS, ...BINDING_FIELDS];
+var VersionedUpdate = z.object({
+  id: ElementId,
+  expectedVersion: z.number().int().nonnegative(),
+  patch: ElementPatch
+});
+var ALIGN_OPS = [
+  "align-left",
+  "align-right",
+  "align-top",
+  "align-bottom",
+  "align-center-h",
+  "align-center-v"
+];
+var DISTRIBUTE_OPS = ["distribute-h", "distribute-v"];
+var Z_ORDER_OPS = [
+  "bring-to-front",
+  "send-to-back",
+  "bring-forward",
+  "send-backward"
+];
+var FLIP_OPS = ["flip-horizontal", "flip-vertical"];
+var ARRANGE_OPS = [
+  ...ALIGN_OPS,
+  ...DISTRIBUTE_OPS,
+  ...Z_ORDER_OPS,
+  ...FLIP_OPS,
+  "grid",
+  /**
+   * The layered graph layout — §12.5, and the replacement for `chalk_from_mermaid`,
+   * which was cut. Ranks from edge direction, ordering within a rank to reduce
+   * crossings, spacing from `HOUSE.spacing`. It reads the arrows among the named
+   * elements out of the scene, so the caller names boxes, not edges.
+   */
+  "layout-layered"
+];
+var ArrangeOp = z.enum(ARRANGE_OPS);
+var ArrangeInput = z.object({
+  elementIds: z.array(ElementId).min(1),
+  op: ArrangeOp,
+  /** Gap in px for distribute and grid. Defaults to `HOUSE.spacing`. */
+  spacing: z.number().positive().optional(),
+  /** `grid` only. */
+  columns: z.number().int().positive().optional()
+});
+var ConnectInput = z.object({
+  fromId: ElementId,
+  toId: ElementId,
+  label: z.string().optional(),
+  startArrowhead: Arrowhead.nullish(),
+  endArrowhead: Arrowhead.nullish(),
+  strokeStyle: StrokeStyle.optional(),
+  /**
+   * Element-level arrow shape. `sharp` and `round` set `roundness`; `elbow` sets
+   * `elbowed` — there is no single upstream field for this (EXCALIDRAW-SURFACE §5).
+   */
+  arrowType: z.enum(["sharp", "round", "elbow"]).optional()
+});
+var RawElementJson = z.looseObject({ id: ElementId });
+var ListScenesInput = z.object({});
+var ListScenesOutput = z.object({
+  scenes: z.array(SceneSummary)
+});
+var DescribeSceneInput = z.object({
+  sceneId: SceneId.optional(),
+  detail: DetailLevel.default("compact")
+});
+var DescribeSceneOutput = z.object({
+  description: SceneDescription,
+  resolvedVia: SceneResolvedVia
+});
+var GetSelectionInput = z.object({
+  neighborDepth: z.number().int().min(0).max(3).default(1),
+  sceneId: SceneId.optional(),
+  detail: DetailLevel.default("compact")
+});
+var GetSelectionOutput = z.object({
+  selection: SelectionDescription,
+  /** Invariant 30 — an empty selection is a normal result, never an error. */
+  empty: z.boolean(),
+  /**
+   * The sentence §11.3 requires: the staleness warning past 120 s, or what to do when
+   * nothing is selected. `null` when the selection is fresh and non-empty.
+   */
+  note: z.string().nullable()
+});
+var GetElementsInput = z.object({
+  ids: z.array(ElementId).min(1),
+  sceneId: SceneId.optional()
+});
+var GetElementsOutput = z.object({
+  sceneId: SceneId,
+  elements: z.array(RawElementJson),
+  /** Asked for and not in the scene. A normal result — ids go stale. */
+  missing: z.array(ElementId)
+});
+var SceneSettingsInput = z.object({
+  sceneId: SceneId.optional(),
+  patch: SceneSettingsPatch.optional()
+});
+var SceneSettingsOutput = z.object({
+  sceneId: SceneId,
+  settings: SceneSettings,
+  /** False for a read, and for a patch that asked for what was already true. */
+  changed: z.boolean(),
+  sceneVersion: z.number().int()
+});
+var GUIDE_TOPICS = ["elements", "styling", "layout", "arrows", "icons"];
+var GuideTopic = z.enum(GUIDE_TOPICS);
+var ReadMeInput = z.object({
+  topics: z.array(GuideTopic).min(1)
+});
+var ReadMeOutput = z.object({
+  guides: z.array(z.object({ topic: GuideTopic, markdown: z.string() })),
+  /** Every topic this build ships, so a wrong guess costs one call rather than two. */
+  available: z.array(GuideTopic),
+  missing: z.array(GuideTopic)
+});
+var writeResult = {
+  sceneId: SceneId,
+  sceneVersion: z.number().int(),
+  broadcastTo: z.number().int().nonnegative()
+};
+var ToolRejection = z.object({
+  id: ElementId,
+  code: z.string(),
+  message: z.string(),
+  hint: z.string().nullable(),
+  tool: z.string().nullable()
+});
+var CreateElementsInput = z.object({
+  elements: z.array(ElementInput).min(1),
+  sceneId: SceneId.optional()
+});
+var CreateElementsOutput = z.object({
+  ...writeResult,
+  created: z.array(ElementId),
+  /**
+   * BUILD-SPEC §12.5 — placing many boxes by hand comes out looking like it was done one
+   * pair of coordinates at a time. Past a handful of elements dropped at the same spot,
+   * the tool says so and names the op that fixes it (§12.6).
+   */
+  layoutHint: z.string().nullable()
+});
+var ConnectToolInput = ConnectInput.extend({ sceneId: SceneId.optional() });
+var ConnectOutput = z.object({
+  ...writeResult,
+  arrowId: ElementId
+});
+var UpdateElementsInput = z.object({
+  updates: z.array(VersionedUpdate).min(1),
+  sceneId: SceneId.optional()
+});
+var UpdateElementsOutput = z.object({
+  ...writeResult,
+  applied: z.array(ElementId),
+  rejected: z.array(ToolRejection)
+});
+var VersionedDelete = z.object({
+  id: ElementId,
+  expectedVersion: z.number().int().nonnegative().optional()
+});
+var DeleteElementsInput = z.object({
+  deletions: z.array(VersionedDelete).min(1),
+  sceneId: SceneId.optional()
+});
+var DeleteElementsOutput = z.object({
+  ...writeResult,
+  deleted: z.array(ElementId),
+  rejected: z.array(ToolRejection)
+});
+var ArrangeToolInput = ArrangeInput.extend({ sceneId: SceneId.optional() });
+var ArrangeOutput = z.object({
+  ...writeResult,
+  moved: z.array(ElementId)
+});
+var GroupInput = z.object({
+  elementIds: z.array(ElementId).min(2),
+  sceneId: SceneId.optional()
+});
+var GroupOutput = z.object({
+  ...writeResult,
+  groupId: GroupId,
+  grouped: z.array(ElementId)
+});
+var UngroupInput = z.object({
+  groupId: GroupId,
+  sceneId: SceneId.optional()
+});
+var UngroupOutput = z.object({
+  ...writeResult,
+  ungrouped: z.array(ElementId)
+});
+var FrameInput = z.object({
+  op: z.enum(["create", "add", "remove"]),
+  elementIds: z.array(ElementId).default([]),
+  name: z.string().optional(),
+  frameId: FrameId.optional(),
+  sceneId: SceneId.optional()
+});
+var FrameOutput = z.object({
+  ...writeResult,
+  frameId: FrameId,
+  children: z.array(ElementId)
+});
+var AnnotateInput = z.object({
+  elementIds: z.array(ElementId).min(1),
+  text: z.string().min(1),
+  sceneId: SceneId.optional()
+});
+var AnnotateOutput = z.object({
+  ...writeResult,
+  noteId: ElementId
+});
+var EmbedInput = z.object({
+  link: z.string().min(1),
+  x: z.number(),
+  y: z.number(),
+  width: z.number().positive().optional(),
+  height: z.number().positive().optional(),
+  sceneId: SceneId.optional()
+});
+var EmbedOutput = z.object({
+  ...writeResult,
+  elementId: ElementId
+});
+var FocusInput = z.object({
+  elementIds: z.array(ElementId).min(1),
+  zoomToFit: z.boolean().default(false),
+  sceneId: SceneId.optional()
+});
+var FocusOutput = z.object({
+  sceneId: SceneId,
+  focused: z.array(ElementId),
+  broadcastTo: z.number().int().nonnegative()
+});
+var RawElementInput = z.looseObject({
+  type: ElementType,
+  x: z.number(),
+  y: z.number(),
+  id: ElementId.optional()
+});
+var RawElementsInput = z.object({
+  elements: z.array(RawElementInput).min(1),
+  sceneId: SceneId.optional()
+});
+var RawElementsOutput = z.object({
+  ...writeResult,
+  created: z.array(ElementId),
+  rejected: z.array(ToolRejection)
+});
+var SearchIconsInput = z.object({
+  query: z.string().min(1),
+  pack: PackName.optional(),
+  limit: z.number().int().min(1).max(50).default(12),
+  offset: z.number().int().min(0).default(0)
+});
+var SearchIconsOutput = z.object({
+  items: z.array(IconSummary),
+  total: z.number().int().nonnegative(),
+  offset: z.number().int().nonnegative(),
+  limit: z.number().int().positive(),
+  /** `null` when this page is the last — one less thing to compute at the call site. */
+  nextOffset: z.number().int().nonnegative().nullable(),
+  /** Every pack in the catalog, so an empty result tells an empty query from an empty machine. */
+  packs: z.array(PackName),
+  /**
+   * What to do when nothing matched. Invariant 31 in its softest form: a search that
+   * comes back empty on a machine carrying only `generic` should say
+   * `chalk_install_pack` out loud rather than leave Claude to infer it.
+   */
+  note: z.string().nullable()
+});
+var PlaceIconInput = z.object({
+  iconId: IconId,
+  x: z.number(),
+  y: z.number(),
+  /** Longest side in px. Defaults to `HOUSE.sizes.icon`; the aspect comes from the icon. */
+  size: z.number().positive().optional(),
+  /** A caption centred beneath it. An unlabelled icon says "a thing was here". */
+  label: z.string().optional(),
+  sceneId: SceneId.optional()
+});
+var PlaceIconOutput = z.object({
+  ...writeResult,
+  elementId: ElementId,
+  /** The caption element, or `null` when no `label` was given. */
+  labelId: ElementId.nullable(),
+  iconId: IconId
+});
+var InstallPackInput = z.object({
+  pack: PackName,
+  /**
+   * A local archive or directory the user downloaded themselves — the second step of a
+   * vendor install. Absent for a permissive pack, which has no second step.
+   */
+  from: z.string().optional()
+});
+var InstallPackOutput = z.object({
+  pack: PackName,
+  /** False for a vendor set with no `from`: nothing was fetched, and that is correct. */
+  installed: z.boolean(),
+  kind: PackKind,
+  iconCount: z.number().int().nonnegative(),
+  license: z.string(),
+  source: z.string(),
+  /**
+   * For a vendor set, the steps the user takes. Empty for anything installed. Structured
+   * rather than prose so Claude relays them verbatim.
+   */
+  instructions: z.array(z.string()),
+  note: z.string().nullable()
+});
+var ListPacksInput = z.object({});
+var ListPacksOutput = z.object({
+  packs: z.array(PackReceipt),
+  /** Recipes and npm packs this build knows about that are not installed. */
+  available: z.array(z.object({ pack: PackName, kind: PackKind, license: z.string() })),
+  catalogPath: z.string(),
+  health: z.array(PackHealth)
+});
+var RemovePackInput = z.object({ pack: PackName });
+var RemovePackOutput = z.object({
+  pack: PackName,
+  removed: z.boolean(),
+  iconsDropped: z.number().int().nonnegative()
+});
+var SnapshotInput = z.object({
+  label: z.string().min(1).optional(),
+  sceneId: SceneId.optional()
+});
+var SnapshotSummary = z.object({
+  id: SnapshotId,
+  sceneId: SceneId,
+  label: z.string(),
+  createdAt: z.number().int(),
+  elementCount: z.number().int().nonnegative()
+});
+var SnapshotOutput = z.object({
+  sceneId: SceneId,
+  /** The one just taken, or `null` when this was a listing. */
+  created: SnapshotSummary.nullable(),
+  snapshots: z.array(SnapshotSummary)
+});
+var RestoreSnapshotInput = z.object({
+  snapshotId: SnapshotId,
+  sceneId: SceneId.optional()
+});
+var RestoreSnapshotOutput = z.object({
+  ...writeResult,
+  snapshotId: SnapshotId,
+  label: z.string(),
+  restored: z.number().int().nonnegative()
+});
+var ExportSceneInput = z.object({
+  /** Repo-relative or absolute. Defaults to where the scene already lives. */
+  path: z.string().optional(),
+  sceneId: SceneId.optional()
+});
+var ExportSceneOutput = z.object({
+  sceneId: SceneId,
+  path: z.string(),
+  repoPath: z.string(),
+  bytes: z.number().int().nonnegative(),
+  sceneVersion: z.number().int()
+});
+var ImportSceneInput = z.object({
+  path: z.string().optional(),
+  sceneId: SceneId.optional()
+});
+var ImportSceneOutput = z.object({
+  sceneId: SceneId,
+  path: z.string(),
+  sceneVersion: z.number().int(),
+  elementCount: z.number().int().nonnegative(),
+  broadcastTo: z.number().int().nonnegative()
+});
+var exportImageOptions = {
+  /** Absent means the whole scene. */
+  elementIds: z.array(ElementId).optional(),
+  background: z.boolean().default(true),
+  padding: z.number().min(0).max(200).default(16),
+  sceneId: SceneId.optional()
+};
+var ExportImageInput = z.object({
+  ...exportImageOptions,
+  format: ExportFormat.default("png"),
+  scale: z.number().min(0.5).max(4).default(2),
+  darkMode: z.boolean().default(false),
+  /** Embeds the scene in the PNG, so the image reopens as a diagram. */
+  embedScene: z.boolean().default(false),
+  /**
+   * Where to write it. Repo-relative or absolute; defaults to the scene name with the
+   * format extension, beside the `.excalidraw` file.
+   *
+   * A path rather than a data URL, because a 2× PNG of a real diagram is megabytes and a
+   * tool result is a context window. `chalk_screenshot` is the one that hands Claude
+   * pixels, and it is capped for exactly this reason.
+   */
+  path: z.string().optional()
+});
+var ExportImageOutput = z.object({
+  sceneId: SceneId,
+  format: ExportFormat,
+  path: z.string(),
+  repoPath: z.string(),
+  bytes: z.number().int().nonnegative(),
+  elementCount: z.number().int().nonnegative()
+});
+var ScreenshotInput = z.object({
+  ...exportImageOptions,
+  theme: z.enum(["light", "dark"]).default("light"),
+  scale: z.number().min(0.5).max(2).default(1)
+});
+var ScreenshotOutput = z.object({
+  sceneId: SceneId,
+  bytes: z.number().int().nonnegative(),
+  elementCount: z.number().int().nonnegative(),
+  /** What was actually shot — the whole scene, or the ids that were asked for. */
+  scope: z.enum(["scene", "elements"])
+});
+var ScreenshotResponse = ScreenshotOutput.extend({
+  base64: z.string(),
+  mimeType: z.string()
+});
+
+// src/domain/equal.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((value, index) => deepEqual(value, b[index]));
+  }
+  if (!isRecord(a) || !isRecord(b)) return false;
+  const entries = Object.entries(a);
+  const other = new Map(Object.entries(b));
+  if (entries.length !== other.size) return false;
+  return entries.every(([key, value]) => other.has(key) && deepEqual(value, other.get(key)));
+}
+
+// src/domain/errors.ts
+var err = (code, message, extra) => ({ code, message, ...extra });
+var expanderUnavailable = (reason) => err("EXPANDER_UNAVAILABLE", `could not load the Excalidraw element expander: ${reason}`, {
+  hint: "this is a Chalkbridge bug, not something to retry \u2014 report it with the reason above"
+});
+var expansionFailed = (reason) => err("EXPANSION_FAILED", `Excalidraw could not expand these elements: ${reason}`, {
+  hint: "check that every arrow endpoint refers to an element in the same batch or already in the scene",
+  tool: "chalk_describe_scene"
+});
+var unknownScene = (requested, available) => err("UNKNOWN_SCENE", `no scene with id "${requested}" in this project`, {
+  hint: available.length === 0 ? "this project has no scenes yet" : `known scenes: ${available.join(", ")}`,
+  tool: "chalk_list_scenes"
+});
+var noScenes = () => err("NO_SCENES", "this project has no scenes yet", {
+  hint: "draw something, or ask the user to open a canvas \u2014 a scene is created on first write",
+  tool: "chalk_create_elements"
+});
+var notARepo = (startDir) => err("NOT_A_REPO", `no git repository found at or above ${startDir}`, {
+  hint: "Chalkbridge binds to a repo \u2014 run `git init` here, or start Claude Code from inside one"
+});
+var bridgeSpawnFailed = (reason) => err("BRIDGE_SPAWN_FAILED", `could not start the Chalkbridge bridge: ${reason}`, {
+  hint: "start it yourself with `chalkbridge serve` and check the output, or set CHALK_NO_AUTOSTART=1 if you manage it another way"
+});
+var bridgeUnreachable = (port) => port === null ? err("BRIDGE_UNREACHABLE", "no bridge is running for this project", {
+  hint: "start one with `chalkbridge serve`, or unset CHALK_NO_AUTOSTART and Chalkbridge will start it for you",
+  detail: { port: null }
+}) : err("BRIDGE_UNREACHABLE", `nothing is answering on 127.0.0.1:${port}`, {
+  hint: "the bridge may have exited \u2014 `chalkbridge health` reports what is running",
+  detail: { port }
+});
+var portUnavailable = (from, tried) => err("PORT_UNAVAILABLE", `no free port between ${from} and ${from + tried - 1}`, {
+  hint: "something is occupying the whole range \u2014 set CHALK_PORT to pick a different one",
+  detail: { from, tried }
+});
+var staleVersion = (id, expected, actual) => err(
+  "STALE_VERSION",
+  `element ${id} changed since your read (expected v${expected}, now v${actual})`,
+  {
+    hint: "re-read with chalk_get_elements, then retry \u2014 the rest of this batch was applied",
+    tool: "chalk_get_elements",
+    detail: { id, expected, actual }
+  }
+);
+var unknownElement = (id) => err("UNKNOWN_ELEMENT", `no element ${id} in this scene`, {
+  hint: "the id may be from another scene, or mistyped \u2014 chalk_describe_scene lists what is there",
+  tool: "chalk_describe_scene",
+  detail: { id }
+});
+var emptySelection = (tool) => err("EMPTY_SELECTION", "no elements named \u2014 there is nothing to act on", {
+  hint: "pass the ids you mean, or call chalk_get_selection to find out what the user is pointing at",
+  tool: "chalk_get_selection",
+  detail: { tool }
+});
+var idCollision = (id) => err("ID_COLLISION", `element ${id} already exists`, {
+  hint: "to change it, use chalk_update_elements with its current version",
+  tool: "chalk_update_elements",
+  detail: { id }
+});
+var diskConflict = (path, diskMtime) => err("DISK_CONFLICT", `${path} changed on disk outside Chalkbridge`, {
+  hint: "the canvas is unchanged \u2014 reload the file with chalk_import_scene to take the disk version, or save over it with chalk_export_scene",
+  tool: "chalk_import_scene",
+  detail: { path, diskMtime }
+});
+var unreadableSceneFile = (path, reason) => err("UNREADABLE_SCENE_FILE", `${path} is not a readable Excalidraw file: ${reason}`, {
+  hint: "it was left alone \u2014 open it in Excalidraw to check it, or delete it",
+  detail: { path }
+});
+var storeUnavailable = (path, reason) => err("STORE_UNAVAILABLE", `could not open the project database at ${path}: ${reason}`, {
+  hint: "delete .chalk/chalk.db and Chalkbridge will rebuild it from the .excalidraw files in the repo"
+});
+var catalogUnavailable = (path, reason) => err("CATALOG_UNAVAILABLE", `could not open the icon catalog at ${path}: ${reason}`, {
+  hint: "delete that file and Chalkbridge will rebuild it \u2014 the bundled pack re-ingests on the next search, and any installed pack can be reinstalled with chalk_install_pack",
+  tool: "chalk_install_pack",
+  detail: { path }
+});
+var unknownIcon = (id, packs) => err("UNKNOWN_ICON", `no icon "${id}" in the catalog`, {
+  hint: packs.length === 0 ? "no packs are installed yet \u2014 chalk_search_icons will ingest the bundled generic set on its first call" : `search for one with chalk_search_icons; installed packs: ${packs.join(", ")}`,
+  tool: "chalk_search_icons",
+  detail: { id }
+});
+var packInstallFailed = (pack, reason) => err("PACK_INSTALL_FAILED", `could not install the icon pack "${pack}": ${reason}`, {
+  hint: "check the machine can reach the npm registry, or install the package yourself and point chalk_install_pack at it with `from`",
+  tool: "chalk_install_pack",
+  detail: { pack }
+});
+var notAPack = (path, reason) => err("NOT_A_PACK", `${path} is not an icon pack: ${reason}`, {
+  hint: "point at the unzipped folder that contains the SVGs, not at the archive itself",
+  tool: "chalk_install_pack",
+  detail: { path }
+});
+var noBrowser = (what) => err("NO_BROWSER", `${what} needs the canvas open in a browser, and no tab is connected`, {
+  hint: "ask the user to open the canvas \u2014 Chalkbridge opens one automatically on the next tool call unless CHALK_NO_OPEN is set \u2014 then retry",
+  tool: "chalk_describe_scene"
+});
+var exportFailed = (reason) => err("EXPORT_FAILED", `the browser could not render that export: ${reason}`, {
+  hint: "try a smaller scale, or export the whole scene rather than a subset",
+  tool: "chalk_export_image"
+});
+var exportTimedOut = (ms) => err("EXPORT_TIMED_OUT", `the browser did not answer the export within ${ms} ms`, {
+  hint: "a very large scene at a high scale can outrun this \u2014 retry with a lower scale, or with elementIds naming the part you need",
+  tool: "chalk_export_image",
+  detail: { ms }
+});
+var unknownSnapshot = (id, available) => err("UNKNOWN_SNAPSHOT", `no snapshot with id "${id}" for this scene`, {
+  hint: available.length === 0 ? "this scene has no snapshots \u2014 chalk_snapshot with a label takes one" : `snapshots for this scene: ${available.join(", ")}`,
+  tool: "chalk_snapshot",
+  detail: { id }
+});
+var sceneFileMissing = (path) => err("SCENE_FILE_MISSING", `no file at ${path}`, {
+  hint: "check the path \u2014 chalk_list_scenes reports where each scene lives in the repo",
+  tool: "chalk_list_scenes",
+  detail: { path }
+});
+var pathOutsideRepo = (path, repoRoot) => err("PATH_OUTSIDE_REPO", `${path} is outside this project`, {
+  hint: `Chalkbridge writes inside ${repoRoot} \u2014 give a path relative to the repository root`,
+  detail: { path, repoRoot }
+});
+var describeThrown = (thrown) => {
+  if (thrown instanceof Error) return thrown.message;
+  if (typeof thrown === "string") return thrown;
+  return JSON.stringify(thrown);
+};
+
+// src/adapters/excalidraw/dom-shim.ts
+var ASSET_BASE = "http://127.0.0.1/chalkbridge-assets/";
+var noop = () => void 0;
+var fakeContext = () => ({
+  measureText: (text) => ({
+    width: text.length * 10,
+    actualBoundingBoxAscent: 8,
+    actualBoundingBoxDescent: 2
+  }),
+  font: "",
+  save: noop,
+  restore: noop,
+  fillText: noop
+});
+var fakeElement = () => ({
+  style: {},
+  getContext: fakeContext,
+  setAttribute: noop,
+  appendChild: noop,
+  remove: noop
+});
+var fakeDocument = () => ({
+  createElement: fakeElement,
+  createElementNS: fakeElement,
+  documentElement: fakeElement(),
+  body: fakeElement(),
+  head: fakeElement(),
+  fonts: { addEventListener: noop, load: async () => [], ready: Promise.resolve(), add: noop },
+  addEventListener: noop,
+  removeEventListener: noop,
+  querySelector: () => null,
+  querySelectorAll: () => []
+});
+var ShimFontFace = class {
+  family;
+  source;
+  unicodeRange = "U+0-10FFFF";
+  constructor(family, source) {
+    this.family = family;
+    this.source = source;
+  }
+  load() {
+    return Promise.resolve(this);
+  }
+};
+var ShimElement = class {
+};
+function installDomShim() {
+  const target = globalThis;
+  const previous = /* @__PURE__ */ new Map();
+  const set = (key, value) => {
+    previous.set(key, { present: key in target, value: target[key] });
+    target[key] = value;
+  };
+  const documentShim = fakeDocument();
+  set("document", documentShim);
+  set("window", {
+    EXCALIDRAW_ASSET_PATH: ASSET_BASE,
+    location: { origin: "http://127.0.0.1", href: "http://127.0.0.1/" },
+    document: documentShim,
+    devicePixelRatio: 1,
+    matchMedia: () => ({ matches: false, addEventListener: noop, removeEventListener: noop }),
+    addEventListener: noop,
+    removeEventListener: noop
+  });
+  set("devicePixelRatio", 1);
+  set("FontFace", ShimFontFace);
+  set("Element", ShimElement);
+  return () => {
+    for (const [key, { present, value }] of previous) {
+      if (present) target[key] = value;
+      else delete target[key];
+    }
+  };
+}
+
+// src/adapters/excalidraw/node-expander.ts
+var WARM_UP = [
+  { type: "rectangle", id: "warmup-a", x: 0, y: 0, width: 10, height: 10, label: { text: "a" } },
+  {
+    type: "arrow",
+    id: "warmup-e",
+    x: 20,
+    y: 5,
+    label: { text: "e" },
+    start: { id: "warmup-a" },
+    end: { type: "ellipse" }
+  },
+  { type: "text", id: "warmup-t", x: 0, y: 40, text: "t" }
+];
+var converter = null;
+async function loadConverter() {
+  const uninstall = installDomShim();
+  try {
+    const { convertToExcalidrawElements } = await import('./prod-KHI2WQT3.js');
+    convertToExcalidrawElements([...WARM_UP], { regenerateIds: false });
+    return ok(convertToExcalidrawElements);
+  } catch (thrown) {
+    return fail(expanderUnavailable(describeThrown(thrown)));
+  } finally {
+    uninstall();
+  }
+}
+function createNodeSkeletonExpander() {
+  return {
+    async expand(skeletons, context) {
+      if (skeletons.length === 0) return ok({ created: [], changed: [] });
+      converter ??= loadConverter();
+      const loaded = await converter;
+      if (!loaded.ok) return loaded;
+      let raw;
+      try {
+        raw = loaded.value([...context ?? [], ...skeletons], { regenerateIds: false });
+      } catch (thrown) {
+        return fail(expansionFailed(describeThrown(thrown)));
+      }
+      const parsed = SceneElement.array().safeParse(raw);
+      if (!parsed.success) {
+        return fail(expansionFailed(parsed.error.issues.map((i) => i.message).join("; ")));
+      }
+      return ok(split(parsed.data, context ?? []));
+    }
+  };
+}
+function split(elements, context) {
+  const before = new Map(context.map((element) => [element.id, element]));
+  const created = [];
+  const changed = [];
+  for (const element of elements) {
+    const original = before.get(element.id);
+    if (original === void 0) {
+      created.push(element);
+      continue;
+    }
+    const merged = {
+      ...original,
+      boundElements: element.boundElements,
+      frameId: element.frameId
+    };
+    if (!deepEqual(stable(merged), stable(original))) changed.push(merged);
+  }
+  return { created, changed };
+}
+var stable = (element) => {
+  const { version, versionNonce, updated, ...rest } = element;
+  return rest;
+};
+
+export { AnnotateInput, AnnotateOutput, ApiError, ArrangeOutput, ArrangeToolInput, BINDING_FIELDS, ClientMessage, ConnectOutput, ConnectToolInput, CreateElementsInput, CreateElementsOutput, DebugElementRequest, DeleteElementsInput, DeleteElementsOutput, DescribeSceneInput, DescribeSceneOutput, DetailLevel, EXCALIDRAW_FILE_TYPE, EXCALIDRAW_FILE_VERSION, ElementId, EmbedInput, EmbedOutput, ExcalidrawFile, ExportImageInput, ExportImageOutput, ExportSceneInput, ExportSceneOutput, FLAG_GLYPH, FileId, FocusInput, FocusOutput, FrameId, FrameInput, FrameOutput, GUIDE_TOPICS, GetElementsInput, GetElementsOutput, GetSelectionInput, GetSelectionOutput, GroupId, GroupInput, GroupOutput, GuideTopic, HOUSE, HealthResponse, IconId, IconItem, ImportSceneInput, ImportSceneOutput, Index, InstallPackInput, InstallPackOutput, KIND_ABBREVIATION, ListPacksInput, ListPacksOutput, ListScenesInput, ListScenesOutput, PROTOCOL_VERSION, PackKind, PackName, PackRecipe, PlaceIconInput, PlaceIconOutput, ROUNDNESS, RawElementsInput, RawElementsOutput, ReadMeInput, ReadMeOutput, RemovePackInput, RemovePackOutput, RestoreSnapshotInput, RestoreSnapshotOutput, SERVER_MANAGED_FIELDS, STALE_SELECTION_MS, Scene, SceneElement, SceneId, SceneSettingsInput, SceneSettingsOutput, ScreenshotInput, ScreenshotOutput, ScreenshotResponse, SearchIconsInput, SearchIconsOutput, SnapshotId, SnapshotInput, SnapshotOutput, UngroupInput, UngroupOutput, UpdateElementsInput, UpdateElementsOutput, assertNever, bridgeSpawnFailed, bridgeUnreachable, catalogUnavailable, createNodeSkeletonExpander, deepEqual, describeThrown, diskConflict, emptySelection, expansionFailed, exportFailed, exportTimedOut, fail, frameIdOf, iconIdOf, idCollision, isFail, isOk, noBrowser, noScenes, notAPack, notARepo, ok, packInstallFailed, partition, pathOutsideRepo, point, portUnavailable, refusedFieldMessage, sceneFileMissing, staleVersion, storeUnavailable, unknownElement, unknownIcon, unknownScene, unknownSnapshot, unreadableSceneFile };
+//# sourceMappingURL=chunk-HFKCLTVU.js.map
+//# sourceMappingURL=chunk-HFKCLTVU.js.map