@dxos/plugin-illustrator 0.10.0 → 0.11.1

package/src/operations/create.ts

@@ -7,19 +7,19 @@ import * as Effect from 'effect/Effect';
 import { Capability } from '@dxos/app-framework';
 import { Operation } from '@dxos/compute';
 
-import { IllustratorCapabilities, Sketch, SketchOperation } from '../types';
-import { UnknownSketchVariantError } from '../util/load-sketch';
+import { Drawing, DrawingOperation, IllustratorCapabilities } from '../types';
+import { UnknownDrawingVariantError } from '../util/load-drawing';
 
-const handler: Operation.WithHandler<typeof SketchOperation.Create> = SketchOperation.Create.pipe(
+const handler: Operation.WithHandler<typeof DrawingOperation.Create> = DrawingOperation.Create.pipe(
   Operation.withHandler(
     Effect.fn(function* ({ name, variant: variantId }) {
       const variants = yield* Capability.getAll(IllustratorCapabilities.VariantProvider);
       const variant = variantId ? variants.find((entry) => entry.id === variantId) : variants[0];
       if (!variant) {
-        return yield* Effect.fail(new UnknownSketchVariantError(variantId ?? '(none registered)'));
+        return yield* Effect.fail(new UnknownDrawingVariantError(variantId ?? '(none registered)'));
       }
-      const canvas = yield* variant.createCanvas();
-      return { object: Sketch.make({ name, canvas }) };
+      const canvas = variant.createCanvas ? yield* variant.createCanvas() : Drawing.makeCanvas({ schema: variant.id });
+      return { object: Drawing.make({ name, canvas }) };
     }),
   ),
 );

package/src/operations/edit.ts

@@ -6,13 +6,13 @@ import * as Effect from 'effect/Effect';
 
 import { Operation } from '@dxos/compute';
 
-import { SketchOperation } from '../types';
-import { resolveVariant } from '../util/load-sketch';
+import { DrawingOperation } from '../types';
+import { resolveVariant } from '../util/load-drawing';
 
-const handler: Operation.WithHandler<typeof SketchOperation.Edit> = SketchOperation.Edit.pipe(
+const handler: Operation.WithHandler<typeof DrawingOperation.Edit> = DrawingOperation.Edit.pipe(
   Operation.withHandler(
-    Effect.fn(function* ({ sketch, commands }) {
-      const { canvas, variant } = yield* resolveVariant(sketch);
+    Effect.fn(function* ({ drawing, commands }) {
+      const { canvas, variant } = yield* resolveVariant(drawing);
       const { upserted, removed } = variant.builder.apply(canvas, commands);
       const { scene, unmanaged } = variant.builder.read(canvas);
       return { scene, unmanaged, upserted, removed };

package/src/operations/generate.ts

@@ -0,0 +1,25 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+
+import { Mermaid } from '#model';
+
+import { DrawingOperation } from '../types';
+import { resolveVariant } from '../util/load-drawing';
+
+const handler: Operation.WithHandler<typeof DrawingOperation.Generate> = DrawingOperation.Generate.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ drawing, source }) {
+      const { canvas, variant } = yield* resolveVariant(drawing);
+      const { upserted } = variant.builder.apply(canvas, Mermaid.compile(source));
+      const { scene, unmanaged } = variant.builder.read(canvas);
+      return { scene, unmanaged, upserted };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/index.ts

@@ -7,5 +7,6 @@ import { OperationHandlerSet } from '@dxos/compute';
 export const IllustratorOperationHandlerSet = OperationHandlerSet.lazy(
   () => import('./create'),
   () => import('./edit'),
+  () => import('./generate'),
   () => import('./read'),
 );

package/src/operations/read.ts

@@ -6,13 +6,13 @@ import * as Effect from 'effect/Effect';
 
 import { Operation } from '@dxos/compute';
 
-import { SketchOperation } from '../types';
-import { resolveVariant } from '../util/load-sketch';
+import { DrawingOperation } from '../types';
+import { resolveVariant } from '../util/load-drawing';
 
-const handler: Operation.WithHandler<typeof SketchOperation.Read> = SketchOperation.Read.pipe(
+const handler: Operation.WithHandler<typeof DrawingOperation.Read> = DrawingOperation.Read.pipe(
   Operation.withHandler(
-    Effect.fn(function* ({ sketch }) {
-      const { canvas, variant } = yield* resolveVariant(sketch);
+    Effect.fn(function* ({ drawing }) {
+      const { canvas, variant } = yield* resolveVariant(drawing);
       return variant.builder.read(canvas);
     }),
   ),

package/src/skills/{sketch-skill.ts → drawing-skill.ts}

@@ -5,20 +5,20 @@
 import { Skill, Template } from '@dxos/compute';
 import { trim } from '@dxos/util';
 
-import { SketchOperation } from '#types';
+import { DrawingOperation } from '#types';
 
-const SKILL_KEY = 'org.dxos.skill.sketch';
+const SKILL_KEY = 'org.dxos.skill.drawing';
 
-const operations = [SketchOperation.Create, SketchOperation.Read, SketchOperation.Edit];
+const operations = [DrawingOperation.Create, DrawingOperation.Read, DrawingOperation.Edit];
 
 const make = () =>
   Skill.make({
     key: SKILL_KEY,
-    name: 'Sketch',
+    name: 'Drawing',
     tools: Skill.toolDefinitions({ operations }),
     instructions: Template.make({
       source: trim`
-        {{! Sketch }}
+        {{! Drawing }}
 
         You can draw and edit diagrams on a shared canvas using a scene DSL.
 
@@ -44,8 +44,8 @@ const make = () =>
 
         ## Workflow
 
-        1. If no sketch exists in context, create one first.
-        2. ALWAYS call read before editing an existing sketch — it returns the scene as you
+        1. If no drawing exists in context, create one first.
+        2. ALWAYS call read before editing an existing drawing — it returns the scene as you
            (or the user) last left it, with origins derived from the live canvas, so it stays
            correct even after the user drags shapes around. Note "unmanaged" counts shapes the
            user drew by hand that are not part of the scene.

package/src/skills/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2026 DXOS.org
 //
 
-export { default as SketchSkill } from './sketch-skill';
+export { default as DrawingSkill } from './drawing-skill';

package/src/translations.ts

@@ -6,27 +6,27 @@ import { Type } from '@dxos/echo';
 import { type Resource } from '@dxos/react-ui';
 
 import { meta } from '#meta';
-import { Sketch } from '#types';
+import { Drawing } from '#types';
 
 export const translations = [
   {
     'en-US': {
-      [Type.getTypename(Sketch.Sketch)]: {
-        'typename.label': 'Sketch',
-        'typename.label_zero': 'Sketches',
-        'typename.label_one': 'Sketch',
-        'typename.label_other': 'Sketches',
-        'object-name.placeholder': 'New sketch',
-        'add-object.label': 'Add sketch',
-        'rename-object.label': 'Rename sketch',
-        'delete-object.label': 'Delete sketch',
-        'object-deleted.label': 'Sketch deleted',
+      [Type.getTypename(Drawing.Drawing)]: {
+        'typename.label': 'Drawing',
+        'typename.label_zero': 'Drawings',
+        'typename.label_one': 'Drawing',
+        'typename.label_other': 'Drawings',
+        'object-name.placeholder': 'New drawing',
+        'add-object.label': 'Add drawing',
+        'rename-object.label': 'Rename drawing',
+        'delete-object.label': 'Delete drawing',
+        'object-deleted.label': 'Drawing deleted',
       },
       [meta.profile.key]: {
         'plugin.name': 'Illustrator',
         'create-panel.variant.label': 'Select renderer',
         'create-panel.variant.placeholder': 'Search renderers...',
-        'unsupported-variant.label': 'Unsupported sketch variant',
+        'unsupported-variant.label': 'Unsupported drawing variant',
       },
     },
   },

package/src/types/Drawing.ts

@@ -0,0 +1,69 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+import { Annotation, DXN, Obj, Ref, Type } from '@dxos/echo';
+import { FormInputAnnotation, HiddenAnnotation, LabelAnnotation } from '@dxos/echo/Annotation';
+import { CardAnnotation, CollectionItemAnnotation } from '@dxos/schema';
+
+/**
+ * Canvas content shared by every renderer: an opaque map of record id → record, managed by the
+ * renderer's store adapter and CRDT-merged by ECHO without knowing its shape. `schema` identifies
+ * the renderer dialect (e.g. `tldraw.com/2`, `excalidraw.com/2`) and is how a `Drawing` is matched
+ * to the variant that can render it.
+ *
+ * Hidden: reached through `Drawing.canvas`, never listed on its own.
+ */
+export class Canvas extends Type.makeObject<Canvas>(DXN.make('org.dxos.type.canvas', '0.1.0'))(
+  Schema.Struct({
+    schema: Schema.String.pipe(Schema.optional),
+    content: Schema.Record({ key: Schema.String, value: Schema.Any }),
+  }).pipe(HiddenAnnotation.set(true)),
+) {}
+
+export type MakeCanvasOptions = Omit<Partial<Obj.MakeProps<typeof Canvas>>, 'schema'> & {
+  /** Required at construction: matches the canvas to a renderer variant. */
+  schema: string;
+};
+
+/** Creates a {@link Canvas} for the given renderer schema. */
+export const makeCanvas = ({ schema, content = {} }: MakeCanvasOptions): Canvas =>
+  Obj.make(Canvas, { schema, content });
+
+/** Type guard for {@link Canvas} objects. */
+export const isCanvas = (object: unknown): object is Canvas => Obj.instanceOf(Canvas, object);
+
+/**
+ * Base Drawing object. Renderer-specific behaviour lives in the variant that claims the canvas's
+ * `schema`, so all renderers (tldraw, excalidraw, ...) share one typename, graph node, create
+ * flow, and surface scaffolding.
+ */
+export class Drawing extends Type.makeObject<Drawing>(DXN.make('org.dxos.type.drawing', '0.1.0'))(
+  Schema.Struct({
+    name: Schema.optional(Schema.String),
+    canvas: Ref.Ref(Canvas)
+      .annotations({ description: 'Reference to the canvas holding the renderer-specific content.' })
+      .pipe(FormInputAnnotation.set(false)),
+  }).pipe(
+    LabelAnnotation.set(['name']),
+    Annotation.IconAnnotation.set({ icon: 'ph--compass-tool--regular', hue: 'indigo' }),
+    CardAnnotation.set(true),
+    CollectionItemAnnotation.set(true),
+  ),
+) {}
+
+/**
+ * Build a `Drawing` referencing the given canvas.
+ *
+ * @param name Optional display name shown in the graph node and Properties form.
+ * @param canvas Canvas holding the renderer's content.
+ */
+export const make = ({ name, canvas }: { name?: string; canvas: Canvas }): Drawing =>
+  Obj.make(Drawing, { name, canvas: Ref.make(canvas) });
+
+/** Type guard for {@link Drawing} objects. */
+export const isDrawing = (object: unknown): object is Drawing => Obj.instanceOf(Drawing, object);

package/src/types/{SketchOperation.ts → DrawingOperation.ts}

@@ -14,12 +14,12 @@ import { DXN } from '@dxos/keys';
 import { meta } from '#meta';
 import { Scene } from '#model';
 
-import * as Sketch from './Sketch';
+import * as Drawing from './Drawing';
 
 const makeKey = (name: string) => DXN.make(`${meta.profile.key}.operation.${name}`);
 
 export const Create = Operation.make({
-  meta: { key: makeKey('create'), name: 'Create Sketch', icon: 'ph--pencil-simple--regular' },
+  meta: { key: makeKey('create'), name: 'Create Drawing', icon: 'ph--pencil-simple--regular' },
   input: Schema.Struct({
     name: Schema.optional(Schema.String),
     variant: Schema.optional(Schema.String).annotations({
@@ -27,7 +27,7 @@ export const Create = Operation.make({
     }),
   }),
   output: Schema.Struct({
-    object: Type.getSchema(Sketch.Sketch),
+    object: Type.getSchema(Drawing.Drawing),
   }),
   services: [Capability.Service, Database.Service],
 });
@@ -43,13 +43,13 @@ const SceneOutput = {
 export const Read = Operation.make({
   meta: {
     key: makeKey('read'),
-    name: 'Read Sketch',
+    name: 'Read Drawing',
     description:
-      'Returns the current scene of a sketch: world objects (by id) with their elements in object-local units. Call before editing an existing sketch.',
+      'Returns the current scene of a drawing: world objects (by id) with their elements in object-local units. Call before editing an existing drawing.',
     icon: 'ph--eye--regular',
   },
   input: Schema.Struct({
-    sketch: Ref.Ref(Sketch.Sketch).annotations({ description: 'The sketch to read.' }),
+    drawing: Ref.Ref(Drawing.Drawing).annotations({ description: 'The drawing to read.' }),
   }),
   output: Schema.Struct(SceneOutput),
   services: [Capability.Service, Database.Service],
@@ -58,13 +58,13 @@ export const Read = Operation.make({
 export const Edit = Operation.make({
   meta: {
     key: makeKey('edit'),
-    name: 'Edit Sketch',
+    name: 'Edit Drawing',
     description:
-      'Applies scene commands to a sketch: upsert/move/remove world objects or individual elements by id. Returns the resulting scene.',
+      'Applies scene commands to a drawing: upsert/move/remove world objects or individual elements by id. Returns the resulting scene.',
     icon: 'ph--pencil-simple-line--regular',
   },
   input: Schema.Struct({
-    sketch: Ref.Ref(Sketch.Sketch).annotations({ description: 'The sketch to edit.' }),
+    drawing: Ref.Ref(Drawing.Drawing).annotations({ description: 'The drawing to edit.' }),
     commands: Schema.Array(Scene.Command).annotations({ description: 'Commands applied in order, atomically.' }),
   }),
   output: Schema.Struct({
@@ -74,3 +74,22 @@ export const Edit = Operation.make({
   }),
   services: [Capability.Service, Database.Service],
 });
+
+export const Generate = Operation.make({
+  meta: {
+    key: makeKey('generate'),
+    name: 'Generate Drawing',
+    description:
+      'Replaces a drawing with a diagram compiled from a mermaid flowchart description. The dialect owns layout, so no coordinates are supplied.',
+    icon: 'ph--graph--regular',
+  },
+  input: Schema.Struct({
+    drawing: Ref.Ref(Drawing.Drawing).annotations({ description: 'The drawing to generate into.' }),
+    source: Schema.String.annotations({ description: 'Mermaid flowchart source.' }),
+  }),
+  output: Schema.Struct({
+    ...SceneOutput,
+    upserted: Schema.Array(Schema.String).annotations({ description: 'Object ids created or modified.' }),
+  }),
+  services: [Capability.Service, Database.Service],
+});

package/src/types/IllustratorCapabilities.ts

@@ -8,12 +8,12 @@ import { Capability } from '@dxos/app-framework';
 
 import { meta } from '#meta';
 
-import type { SketchVariant } from './types';
+import type { DrawingVariant } from './types';
 
 /**
- * A sketch variant contribution. Each renderer plugin (tldraw, excalidraw, ...)
- * contributes one of these via `Capability.contributes(IllustratorCapabilities.VariantProvider, variant)`.
+ * A drawing variant contribution. Each renderer plugin (tldraw, excalidraw, ...) contributes one
+ * via `Capability.contributes(IllustratorCapabilities.VariantProvider, variant)`.
  * Consumers iterate via `Capability.getAll(IllustratorCapabilities.VariantProvider)` (Effect) or
  * `useCapabilities(IllustratorCapabilities.VariantProvider)` (React).
  */
-export const VariantProvider = Capability.make<SketchVariant>(`${meta.profile.key}.capability.variant`);
+export const VariantProvider = Capability.make<DrawingVariant>(`${meta.profile.key}.capability.variant`);

package/src/types/LegacySketch.ts

@@ -0,0 +1,25 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+import { DXN, Ref, Type } from '@dxos/echo';
+
+import * as Drawing from './Drawing';
+
+/**
+ * The pre-rename `Sketch` object, kept solely so `Migration.define` can read existing data and
+ * convert it to {@link Drawing}. Never constructed by this plugin.
+ *
+ * Its canvas already points at `org.dxos.type.canvas` carrying `schema: 'tldraw.com/2'`, which is
+ * exactly the base `Drawing.Canvas` — so only the wrapper needs migrating.
+ */
+export class Sketch extends Type.makeObject<Sketch>(DXN.make('org.dxos.type.sketch', '0.1.0'))(
+  Schema.Struct({
+    name: Schema.optional(Schema.String),
+    canvas: Ref.Ref(Drawing.Canvas),
+  }),
+) {}

package/src/types/index.ts

@@ -4,6 +4,7 @@
 
 export * from './types';
 
+export * as Drawing from './Drawing';
+export * as LegacySketch from './LegacySketch';
+export * as DrawingOperation from './DrawingOperation';
 export * as IllustratorCapabilities from './IllustratorCapabilities';
-export * as Sketch from './Sketch';
-export * as SketchOperation from './SketchOperation';

package/src/types/types.ts

@@ -7,41 +7,41 @@ import type { ComponentType } from 'react';
 
 import type { Database, Obj, Type } from '@dxos/echo';
 
-import { type SketchBuilder } from '#model';
+import { type DrawingBuilder } from '#model';
 
-import type * as Sketch from './Sketch';
+import type * as Drawing from './Drawing';
 
 /**
- * Contribution from a canvas renderer plugin (e.g. plugin-tldraw, plugin-excalidraw).
- * Defines how a sketch variant is created, rendered, and how the scene DSL maps onto it.
+ * Contribution from a renderer plugin (e.g. plugin-tldraw, plugin-excalidraw).
+ * Defines how a drawing variant is created, rendered, and how the scene DSL maps onto it.
  */
-export type SketchVariant = {
-  /** Stable id, typically the canvas typename (e.g. 'org.dxos.type.canvas'). */
+export type DrawingVariant = {
+  /** Renderer dialect claimed by this variant; matched against `Canvas.schema` (e.g. 'tldraw.com/2'). */
   id: string;
   /** Human-readable variant name (e.g. 'tldraw'). */
   label: string;
   /** Optional Phosphor icon name (e.g. 'ph--compass-tool--regular'). */
   icon?: string;
-  /** ECHO Type entity of the canvas object referenced by `Sketch.canvas`. */
-  canvasType: Type.AnyObj;
   /**
-   * Build an empty canvas object. May allocate ECHO objects, run effects, etc.
-   * Returned object is added to the database alongside the Sketch.
+   * Canvas type, when the renderer extends the base `Drawing.Canvas` with its own fields.
+   * Omit to use the base type — the common case, since `schema` already discriminates.
    */
-  createCanvas: (input?: Record<string, any>) => Effect.Effect<Obj.Any, Error, Database.Service>;
+  canvasType?: Type.AnyObj;
+  /** Build an empty canvas. Defaults to a base `Drawing.Canvas` stamped with `id` as its schema. */
+  createCanvas?: (input?: Record<string, any>) => Effect.Effect<Drawing.Canvas, Error, Database.Service>;
   /** Maps the scene DSL onto this variant's canvas records. */
-  builder: SketchBuilder;
+  builder: DrawingBuilder;
   /** Optional Card surface component for this variant. */
-  card?: ComponentType<SketchVariantSurfaceProps>;
+  card?: ComponentType<DrawingVariantSurfaceProps>;
   /** Optional Article/Section/Slide surface component for this variant. */
-  article?: ComponentType<SketchVariantSurfaceProps>;
+  article?: ComponentType<DrawingVariantSurfaceProps>;
 };
 
-export type SketchVariantSurfaceProps = {
-  /** The base Sketch object (may be a snapshot from useObject/Surface). */
-  sketch: Obj.Snapshot<Sketch.Sketch> | Sketch.Sketch;
+export type DrawingVariantSurfaceProps = {
+  /** The base Drawing object (may be a snapshot from useObject/Surface). */
+  drawing: Obj.Snapshot<Drawing.Drawing> | Drawing.Drawing;
   /** The resolved LIVE canvas object — variant store adapters need `Doc.createAccessor`. */
-  canvas: Obj.Unknown;
+  canvas: Drawing.Canvas;
   /** Surface role passed through from the host. */
   role?: string;
   /** Attendable id passed through from the host. */

package/src/util/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2026 DXOS.org
 //
 
-export * from './load-sketch';
+export * from './load-drawing';

package/src/util/load-drawing.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Database, type Ref } from '@dxos/echo';
+
+import * as Drawing from '../types/Drawing';
+import * as IllustratorCapabilities from '../types/IllustratorCapabilities';
+import { type DrawingVariant } from '../types/types';
+
+export class UnknownDrawingVariantError extends Error {
+  readonly _tag = 'UnknownDrawingVariantError';
+  constructor(readonly schema: string) {
+    super(`No drawing variant registered for canvas schema: ${schema}.`);
+  }
+}
+
+/**
+ * Loads a Drawing and resolves the variant claiming its canvas `schema`.
+ * Used by the renderer-agnostic read/edit operations.
+ */
+export const resolveVariant = (
+  ref: Ref.Ref<Drawing.Drawing>,
+): Effect.Effect<
+  { drawing: Drawing.Drawing; canvas: Drawing.Canvas; variant: DrawingVariant },
+  Error,
+  Database.Service | Capability.Service
+> =>
+  Effect.gen(function* () {
+    const drawing = yield* Database.load(ref);
+    const canvas = yield* Database.load(drawing.canvas);
+    const schema = canvas.schema ?? '';
+    const variants = yield* Capability.getAll(IllustratorCapabilities.VariantProvider);
+    const variant = variants.find((entry) => entry.id === schema);
+    if (!variant) {
+      return yield* Effect.fail(new UnknownDrawingVariantError(schema));
+    }
+    return { drawing, canvas, variant };
+  });
+
+/** Resolve a variant by canvas schema, for callers that already hold the canvas. */
+export const findVariant = (
+  variants: readonly DrawingVariant[],
+  canvas: Pick<Drawing.Canvas, 'schema'> | undefined,
+): DrawingVariant | undefined => variants.find((entry) => entry.id === (canvas?.schema ?? ''));

package/dist/lib/chunk-load-sketch.mjs

@@ -1,64 +0,0 @@
-import { n as VariantProvider } from "./chunk-IllustratorCapabilities.mjs";
-import { Capability } from "@dxos/app-framework";
-import * as Effect from "effect/Effect";
-import { Database, Obj, Type } from "@dxos/echo";
-//#region src/util/load-sketch.ts
-var SketchVariantMismatchError = class extends Error {
-	sketchId;
-	expectedTypename;
-	actualTypename;
-	_tag = "SketchVariantMismatchError";
-	constructor(sketchId, expectedTypename, actualTypename) {
-		super(`Sketch ${sketchId} canvas typename mismatch: expected ${expectedTypename}, got ${actualTypename}.`);
-		this.sketchId = sketchId;
-		this.expectedTypename = expectedTypename;
-		this.actualTypename = actualTypename;
-	}
-};
-var UnknownSketchVariantError = class extends Error {
-	typename;
-	_tag = "UnknownSketchVariantError";
-	constructor(typename) {
-		super(`No sketch variant registered for canvas type: ${typename}.`);
-		this.typename = typename;
-	}
-};
-/**
-* Loads a Sketch from a Ref and resolves its canvas, asserting the canvas matches
-* the expected type. Returns the typed pair.
-*
-* Use in operation handlers that declare `input.sketch: SketchRef<MyCanvas>`.
-*/
-var loadSketch = (ref, canvasType) => Effect.gen(function* () {
-	const sketch = yield* Database.load(ref);
-	const canvas = yield* Database.load(sketch.canvas);
-	if (!Obj.instanceOf(canvasType, canvas)) {
-		const expected = Type.getTypename(canvasType) ?? "unknown";
-		const actual = Obj.getTypename(canvas) ?? "unknown";
-		return yield* Effect.fail(new SketchVariantMismatchError(sketch.id, expected, actual));
-	}
-	return {
-		sketch,
-		canvas
-	};
-});
-/**
-* Loads a Sketch and resolves the variant provider matching its canvas typename.
-* Used by the renderer-agnostic read/edit operations.
-*/
-var resolveVariant = (ref) => Effect.gen(function* () {
-	const sketch = yield* Database.load(ref);
-	const canvas = yield* Database.load(sketch.canvas);
-	const typename = Obj.getTypename(canvas) ?? "unknown";
-	const variant = (yield* Capability.getAll(VariantProvider)).find((entry) => entry.id === typename);
-	if (!variant) return yield* Effect.fail(new UnknownSketchVariantError(typename));
-	return {
-		sketch,
-		canvas,
-		variant
-	};
-});
-//#endregion
-export { resolveVariant as i, UnknownSketchVariantError as n, loadSketch as r, SketchVariantMismatchError as t };
-
-//# sourceMappingURL=chunk-load-sketch.mjs.map

package/dist/lib/chunk-load-sketch.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk-load-sketch.mjs","names":[],"sources":["../../src/util/load-sketch.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capability } from '@dxos/app-framework';\nimport { Database, Obj, type Ref, Type } from '@dxos/echo';\n\nimport * as IllustratorCapabilities from '../types/IllustratorCapabilities';\nimport * as Sketch from '../types/Sketch';\nimport { type SketchVariant } from '../types/types';\n\nexport class SketchVariantMismatchError extends Error {\n  readonly _tag = 'SketchVariantMismatchError';\n  constructor(\n    readonly sketchId: string,\n    readonly expectedTypename: string,\n    readonly actualTypename: string,\n  ) {\n    super(`Sketch ${sketchId} canvas typename mismatch: expected ${expectedTypename}, got ${actualTypename}.`);\n  }\n}\n\nexport class UnknownSketchVariantError extends Error {\n  readonly _tag = 'UnknownSketchVariantError';\n  constructor(readonly typename: string) {\n    super(`No sketch variant registered for canvas type: ${typename}.`);\n  }\n}\n\n/**\n * Loads a Sketch from a Ref and resolves its canvas, asserting the canvas matches\n * the expected type. Returns the typed pair.\n *\n * Use in operation handlers that declare `input.sketch: SketchRef<MyCanvas>`.\n */\nexport const loadSketch = <S extends Type.AnyObj>(\n  ref: Ref.Ref<Sketch.Sketch>,\n  canvasType: S,\n): Effect.Effect<{ sketch: Sketch.Sketch; canvas: Type.InstanceType<S> }, Error, Database.Service> =>\n  Effect.gen(function* () {\n    const sketch = yield* Database.load(ref);\n    const canvas = yield* Database.load(sketch.canvas);\n    if (!Obj.instanceOf(canvasType, canvas)) {\n      const expected = Type.getTypename(canvasType) ?? 'unknown';\n      const actual = Obj.getTypename(canvas as Obj.Any) ?? 'unknown';\n      return yield* Effect.fail(new SketchVariantMismatchError(sketch.id, expected, actual));\n    }\n    return { sketch, canvas: canvas as Type.InstanceType<S> };\n  });\n\n/**\n * Loads a Sketch and resolves the variant provider matching its canvas typename.\n * Used by the renderer-agnostic read/edit operations.\n */\nexport const resolveVariant = (\n  ref: Ref.Ref<Sketch.Sketch>,\n): Effect.Effect<\n  { sketch: Sketch.Sketch; canvas: Obj.Any; variant: SketchVariant },\n  Error,\n  Database.Service | Capability.Service\n> =>\n  Effect.gen(function* () {\n    const sketch = yield* Database.load(ref);\n    const canvas = (yield* Database.load(sketch.canvas)) as Obj.Any;\n    const typename = Obj.getTypename(canvas) ?? 'unknown';\n    const variants = yield* Capability.getAll(IllustratorCapabilities.VariantProvider);\n    const variant = variants.find((entry) => entry.id === typename);\n    if (!variant) {\n      return yield* Effect.fail(new UnknownSketchVariantError(typename));\n    }\n    return { sketch, canvas, variant };\n  });\n"],"mappings":";;;;;AAaA,IAAa,6BAAb,cAAgD,MAAM;CAGzC;CACA;CACA;CAJX,OAAgB;CAChB,YACE,UACA,kBACA,gBACA;EACA,MAAM,UAAU,SAAS,sCAAsC,iBAAiB,QAAQ,eAAe,EAAE;EAJhG,KAAA,WAAA;EACA,KAAA,mBAAA;EACA,KAAA,iBAAA;CAGX;AACF;AAEA,IAAa,4BAAb,cAA+C,MAAM;CAE9B;CADrB,OAAgB;CAChB,YAAY,UAA2B;EACrC,MAAM,iDAAiD,SAAS,EAAE;EAD/C,KAAA,WAAA;CAErB;AACF;;;;;;;AAQA,IAAa,cACX,KACA,eAEA,OAAO,IAAI,aAAa;CACtB,MAAM,SAAS,OAAO,SAAS,KAAK,GAAG;CACvC,MAAM,SAAS,OAAO,SAAS,KAAK,OAAO,MAAM;CACjD,IAAI,CAAC,IAAI,WAAW,YAAY,MAAM,GAAG;EACvC,MAAM,WAAW,KAAK,YAAY,UAAU,KAAK;EACjD,MAAM,SAAS,IAAI,YAAY,MAAiB,KAAK;EACrD,OAAO,OAAO,OAAO,KAAK,IAAI,2BAA2B,OAAO,IAAI,UAAU,MAAM,CAAC;CACvF;CACA,OAAO;EAAE;EAAgB;CAA+B;AAC1D,CAAC;;;;;AAMH,IAAa,kBACX,QAMA,OAAO,IAAI,aAAa;CACtB,MAAM,SAAS,OAAO,SAAS,KAAK,GAAG;CACvC,MAAM,SAAU,OAAO,SAAS,KAAK,OAAO,MAAM;CAClD,MAAM,WAAW,IAAI,YAAY,MAAM,KAAK;CAE5C,MAAM,WAAU,OADQ,WAAW,OAAO,eAAuC,EAAA,CACxD,MAAM,UAAU,MAAM,OAAO,QAAQ;CAC9D,IAAI,CAAC,SACH,OAAO,OAAO,OAAO,KAAK,IAAI,0BAA0B,QAAQ,CAAC;CAEnE,OAAO;EAAE;EAAQ;EAAQ;CAAQ;AACnC,CAAC"}

package/dist/types/src/components/CreateSketchPanel.d.ts

@@ -1,15 +0,0 @@
-import React from 'react';
-import { type SpaceCapabilities } from '@dxos/plugin-space';
-import { type SketchVariant } from '#types';
-export type CreateSketchPanelProps = SpaceCapabilities.CreateObjectCustomPanelProps & {
-    /** Optional override (primarily for stories/tests). Defaults to IllustratorCapabilities.VariantProvider. */
-    variants?: SketchVariant[];
-};
-/**
- * Variant picker for sketches (SearchList over contributed `SketchVariant[]`).
- * On select, calls `onCreateObject({ variantId })`; plugin-illustrator's
- * CreateObjectEntry.createObject resolves the variantId, builds the canvas via
- * variant.createCanvas, then wraps it in a Sketch.
- */
-export declare const CreateSketchPanel: ({ onCreateObject, variants: variantsProp }: CreateSketchPanelProps) => React.JSX.Element;
-//# sourceMappingURL=CreateSketchPanel.d.ts.map

package/dist/types/src/components/CreateSketchPanel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CreateSketchPanel.d.ts","sourceRoot":"","sources":["../../../../src/components/CreateSketchPanel.tsx"],"names":[],"mappings":"AAIA,OAAO,KAA+B,MAAM,OAAO,CAAC;AAGpD,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAK5D,OAAO,EAA2B,KAAK,aAAa,EAAE,MAAM,QAAQ,CAAC;AAErE,MAAM,MAAM,sBAAsB,GAAG,iBAAiB,CAAC,4BAA4B,GAAG;IACpF,4GAA4G;IAC5G,QAAQ,CAAC,EAAE,aAAa,EAAE,CAAC;CAC5B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,+CAAgD,sBAAsB,sBA0CnG,CAAC"}

package/dist/types/src/containers/SketchArticle/SketchArticle.d.ts

@@ -1,11 +0,0 @@
-import React from 'react';
-import { type AppSurface } from '@dxos/app-toolkit/ui';
-import { type Sketch } from '#types';
-export type SketchArticleProps = AppSurface.ObjectArticleProps<Sketch.Sketch> & {
-    extrinsic?: boolean;
-};
-export declare function SketchArticle({ role, attendableId, subject: sketch, extrinsic }: SketchArticleProps): React.JSX.Element | null;
-export declare namespace SketchArticle {
-    var displayName: string;
-}
-//# sourceMappingURL=SketchArticle.d.ts.map

package/dist/types/src/containers/SketchArticle/SketchArticle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SketchArticle.d.ts","sourceRoot":"","sources":["../../../../../src/containers/SketchArticle/SketchArticle.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAMvD,OAAO,EAA2B,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAE9D,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,kBAAkB,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG;IAC9E,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;sCAG4B,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,kBAAkB"}

package/dist/types/src/containers/SketchArticle/index.d.ts

@@ -1,2 +0,0 @@
-export * from './SketchArticle';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/src/containers/SketchArticle/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/containers/SketchArticle/index.ts"],"names":[],"mappings":"AAIA,cAAc,iBAAiB,CAAC"}

package/dist/types/src/containers/SketchCard/SketchCard.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import { type AppSurface } from '@dxos/app-toolkit/ui';
-import { type Sketch } from '#types';
-export type SketchCardProps = AppSurface.ObjectCardProps<Sketch.Sketch>;
-export declare function SketchCard({ role, subject: sketch, editable }: SketchCardProps): React.JSX.Element | null;
-export declare namespace SketchCard {
-    var displayName: string;
-}
-export default SketchCard;
-//# sourceMappingURL=SketchCard.d.ts.map