@mica-js/core 0.0.1 → 0.1.1

package/dist/canvas/index.d.ts

@@ -1,74 +1,39 @@
-/**
- * Applies a canvas command to a copy of `canvas`.
- *
- * @throws {SchematicError} when the command is invalid; the input canvas is never mutated.
- */
-export declare function applyCanvasCommand(canvas: CanvasDocument, command: CanvasCommand, options?: ApplyCanvasCommandOptions): CanvasDocument;
-
-export declare interface ApplyCanvasCommandOptions {
-    /** Bound schematic; symbol references are validated against it when provided. */
-    readonly schematic?: SchematicDocument;
-}
-
-/** Where an image / binary property value lives (#7). */
-declare type AssetMode = 'file' | 'inline' | 'store';
-
-/**
- * Reference to a project asset instead of inline bytes (#7): `file` is a project-root relative
- * POSIX path, `inline` is base64 text and `store` is a host resource identifier.
- */
-declare interface AssetReference {
-    readonly src: string;
-    readonly mode: AssetMode;
-}
-
 /**
  * Schema version of the `.cnv` canvas contract (see x-botlab/mica-js#67).
  *
- * A canvas is a 2D layout: one `.cnv` binds exactly one `.sch` (see x-botlab/mica-js#6) and keeps
- * a placement per symbol id. Schematic connections stay in the `.sch`; the canvas only adds 2D
- * coordinates and rotation.
+ * A canvas is an independent 2D plane: it records widget instances with their placement, property
+ * overrides and port-to-symbol bindings. Electrical topology stays in the `.sch` the canvas binds
+ * (see x-botlab/mica-js#6); the two coordinate spaces are unrelated.
  */
 export declare const CANVAS_VERSION = 1;
 
-export declare type CanvasCommand = {
-    readonly type: 'set-placement';
-    readonly symbolId: string;
-    readonly x: number;
-    readonly y: number;
-    readonly rotation?: number;
-} | {
-    readonly type: 'remove-placement';
-    readonly symbolId: string;
-} | {
-    readonly type: 'bind-schematic';
-    readonly schematic: string;
-};
-
-export declare interface CanvasDocument {
-    readonly version: CanvasVersion;
-    /** Canvas identity, unique within one project's `.cnv` files. */
-    readonly id: string;
-    /** Project-root relative POSIX path of the bound `.sch`. */
-    readonly schematic: string;
-    /** Symbol id → placement; ids are stable, so renaming a designator keeps the entry. */
-    readonly layout: Readonly<Record<string, CanvasPlacement>>;
+/** Endpoint of a widget port: a port of one symbol instance in the bound schematic. */
+export declare interface CanvasBindingTarget {
+    readonly symbol: string;
+    readonly port: string;
 }
 
-export declare interface CanvasLayoutEntry {
-    readonly symbolId: string;
-    readonly placement: CanvasPlacement;
+/** Root of a `.cnv` file; the project-root relative path is the canvas identity. */
+export declare interface CanvasDocument {
+    readonly version: typeof CANVAS_VERSION;
+    /** Project-root relative POSIX path of the `.sch` the canvas draws and simulates against. */
+    readonly schematic?: string;
+    /** Widget instances in drawing order; later instances paint above earlier ones. */
+    readonly widgets: readonly CanvasWidgetInstance[];
 }
 
-/** 2D placement of one symbol in a canvas. */
-export declare interface CanvasPlacement {
-    readonly x: number;
-    readonly y: number;
-    readonly rotation: number;
+/** One widget placed on a canvas; the order in `widgets` is the drawing order (#67). */
+export declare interface CanvasWidgetInstance extends WidgetPlacement {
+    /** Stable identity: UUID v4, unique within the document. */
+    readonly id: string;
+    /** Widget reference `"<package>:<widget>"`; built-ins use the reserved `builtin:` namespace. */
+    readonly widget: string;
+    /** Property overrides keyed by the widget definition; values follow that definition (#7). */
+    readonly properties?: Readonly<Record<string, unknown>>;
+    /** Port key → endpoint; only bound ports take part in messaging (#10). */
+    readonly bindings?: Readonly<Record<string, CanvasBindingTarget>>;
 }
 
-export declare type CanvasVersion = typeof CANVAS_VERSION;
-
 export declare interface Diagnostic {
     readonly severity: DiagnosticSeverity;
     readonly code: DiagnosticCode;
@@ -80,7 +45,7 @@ export declare interface Diagnostic {
     readonly related?: readonly DiagnosticRelated[];
 }
 
-export declare type DiagnosticCode = 'json/invalid' | 'json/not-object' | 'schema/unsupported-version' | 'schema/missing-field' | 'schema/invalid-type' | 'schema/invalid-value' | 'schema/unknown-field' | 'id/duplicate' | 'device/invalid-reference' | 'device/unresolved' | 'device/invalid-package' | 'device/duplicate-package' | 'device/reserved-namespace' | 'device/duplicate-device' | 'device/invalid-description' | 'device/unknown-pin' | 'device/no-symbol' | 'wire/invalid-points' | 'wire/not-orthogonal' | 'junction/unknown-wire' | 'junction/duplicate-wire' | 'junction/off-wire' | 'symbol/missing-net' | 'symbol/unsupported-field' | 'symbol/designator-duplicate' | 'net/naming-conflict' | 'canvas/unknown-symbol' | 'edit/unknown-entity' | 'edit/invalid-command';
+export declare type DiagnosticCode = 'json/invalid' | 'json/not-object' | 'schema/unsupported-version' | 'schema/missing-field' | 'schema/invalid-type' | 'schema/invalid-value' | 'schema/unknown-field' | 'id/duplicate' | 'device/invalid-reference' | 'device/unresolved' | 'device/invalid-package' | 'device/duplicate-package' | 'device/reserved-namespace' | 'device/duplicate-device' | 'device/invalid-description' | 'device/unknown-pin' | 'device/no-symbol' | 'wire/invalid-points' | 'wire/not-orthogonal' | 'junction/unknown-wire' | 'junction/duplicate-wire' | 'junction/off-wire' | 'symbol/missing-net' | 'symbol/unsupported-field' | 'symbol/designator-duplicate' | 'net/naming-conflict' | 'canvas/unknown-symbol' | 'canvas/unknown-widget' | 'canvas/unknown-property' | 'canvas/unknown-port' | 'canvas/unknown-schematic' | 'canvas/unknown-target-port' | 'topic/type-mismatch' | 'type/unknown' | 'edit/unknown-entity' | 'edit/invalid-command';
 
 export declare interface DiagnosticEntity {
     readonly kind: 'symbol' | 'wire' | 'junction';
@@ -93,54 +58,9 @@ export declare interface DiagnosticRelated {
 
 export declare type DiagnosticSeverity = 'error' | 'warning';
 
-/** Parses a canvas and validates its layout against the bound schematic. @throws {SchematicError} */
-export declare function loadCanvas(source: string | CanvasDocument, options?: LoadCanvasOptions): LoadedCanvas;
-
-export declare interface LoadCanvasOptions {
-    /** Bound schematic; layout keys are validated against its symbols when provided. */
-    readonly schematic?: SchematicDocument;
-}
-
-export declare interface LoadedCanvas {
-    readonly document: CanvasDocument;
-    /** Layout entries sorted by symbol id, so loading is deterministic. */
-    readonly placements: readonly CanvasLayoutEntry[];
-}
-
 /** @throws {SchematicError} when the input does not match the `.cnv` contract. */
 export declare function parseCanvas(input: string | unknown): CanvasDocument;
 
-declare interface Placement {
-    readonly x: number;
-    readonly y: number;
-    readonly rotation: number;
-}
-
-declare interface Point {
-    readonly x: number;
-    readonly y: number;
-}
-
-/**
- * Instance property value stored in `symbol.properties` (see #6 / #7): a scalar, a resource
- * reference for `image` / `binary` properties, or `null` for an explicitly cleared nullable one.
- */
-declare type PropertyValue = string | number | boolean | AssetReference | null;
-
-/**
- * Schema version of the `.sch` contract (see x-botlab/mica-js#6).
- *
- * 2D placement lives in the separate `.cnv` canvas contract (see x-botlab/mica-js#67 and
- * `@mica-js/core/canvas`).
- */
-declare const SCHEMATIC_VERSION = 1;
-
-/** Root of a `.sch` file; the file name is the schematic's identity. */
-declare interface SchematicDocument {
-    readonly version: SchematicVersion;
-    readonly sheet: SchematicSheet;
-}
-
 /**
  * Thrown when input violates the schematic format contract.
  * `diagnostics` carries every problem found, so callers can report them all at once.
@@ -152,50 +72,21 @@ export declare class SchematicError extends Error {
     get code(): DiagnosticCode | undefined;
 }
 
-declare interface SchematicJunction {
-    readonly id: string;
+/**
+ * Serializes with a fixed field order and 2-space indentation, matching the example in #67.
+ * `properties` and `bindings` are written whenever the document carries them, even when empty, so
+ * a parse / serialize round trip keeps the original shape.
+ */
+export declare function serializeCanvas(document: CanvasDocument): string;
+
+/** Placement and size of one widget instance, in logical units. */
+export declare interface WidgetPlacement {
     readonly x: number;
     readonly y: number;
-    readonly wires: readonly string[];
-}
-
-declare interface SchematicSheet {
-    readonly symbols: readonly SchematicSymbol[];
-    readonly wires: readonly SchematicWire[];
-    readonly junctions: readonly SchematicJunction[];
-}
-
-declare interface SchematicSymbol extends Placement {
-    /** Stable identity used by selections, undo and `.view` layout keys. */
-    readonly id: string;
-    readonly device: string;
-    /** Instance property overrides; absent means "use device defaults". */
-    readonly properties?: Readonly<Record<string, PropertyValue>>;
-    /**
-     * Reference designator of a component (`U1`, `R2`); defaults to {@link id}.
-     * Only components carry one — the format rejects it elsewhere.
-     */
-    readonly designator?: string;
-    /**
-     * Net name of a net label, power or ground symbol (`VCC`, `N1`). It is the text drawn next to
-     * the anchor and the key same-named ports merge on. Only net-naming symbols carry one.
-     */
-    readonly net?: string;
-    /**
-     * Reference designator anchor in symbol-local coordinates (unrotated, unplaced).
-     * Absent means the default position at the body's top-left corner.
-     */
-    readonly reference?: Point;
-}
-
-declare type SchematicVersion = typeof SCHEMATIC_VERSION;
-
-declare interface SchematicWire {
-    readonly id: string;
-    readonly points: readonly Point[];
+    readonly width: number;
+    readonly height: number;
+    /** Clockwise rotation in degrees around the instance center. */
+    readonly rotation: number;
 }
 
-/** Serializes with a fixed field order and 2-space indentation, matching the example in #67. */
-export declare function serializeCanvas(canvas: CanvasDocument): string;
-
 export { }

package/dist/canvas/index.js

@@ -1,15 +1,38 @@
-import { c as readObjectField, d as readStringField, f as report, h as SchematicError, i as isRecord, m as parseInput, n as forbidUnknownFields, o as readIntegerField, p as toPointer, r as hasErrors, s as readNumberField } from "../validate-COqYIMQg.js";
+import { a as readArrayField, d as readStringField, f as report, h as SchematicError, i as isRecord, m as parseInput, n as forbidUnknownFields, o as readIntegerField, r as hasErrors, s as readNumberField } from "../validate-DuALfDe0.js";
 //#region src/canvas/format/types.ts
 /**
 * Schema version of the `.cnv` canvas contract (see x-botlab/mica-js#67).
 *
-* A canvas is a 2D layout: one `.cnv` binds exactly one `.sch` (see x-botlab/mica-js#6) and keeps
-* a placement per symbol id. Schematic connections stay in the `.sch`; the canvas only adds 2D
-* coordinates and rotation.
+* A canvas is an independent 2D plane: it records widget instances with their placement, property
+* overrides and port-to-symbol bindings. Electrical topology stays in the `.sch` the canvas binds
+* (see x-botlab/mica-js#6); the two coordinate spaces are unrelated.
 */
 var CANVAS_VERSION = 1;
 //#endregion
+//#region src/format/uuid.ts
+var UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+/** Strict UUID v4 check: 8-4-4-4-12 hex with the version and variant bits fixed. */
+function isUuidV4(value) {
+	return UUID_V4.test(value);
+}
+//#endregion
 //#region src/canvas/format/parse.ts
+/**
+* `"<package>:<widget>"`; `builtin` matches the package pattern, so the same expression also
+* accepts the reserved `builtin:<widget>` form (#67).
+*/
+var WIDGET_REFERENCE = /^[a-z0-9][a-z0-9-]*:[a-z0-9][a-z0-9-]*$/;
+var WIDGET_FIELDS = [
+	"id",
+	"widget",
+	"x",
+	"y",
+	"width",
+	"height",
+	"rotation",
+	"properties",
+	"bindings"
+];
 /** @throws {SchematicError} when the input does not match the `.cnv` contract. */
 function parseCanvas(input) {
 	const diagnostics = [];
@@ -26,20 +49,20 @@ function readDocument(value, diagnostics) {
 	}
 	forbidUnknownFields(value, [
 		"version",
-		"id",
 		"schematic",
-		"layout"
+		"widgets"
 	], [], diagnostics);
 	const version = readVersion(value, diagnostics);
-	const id = readStringField(value, "id", [], diagnostics, { nonEmpty: true });
-	const schematic = readStringField(value, "schematic", [], diagnostics, { nonEmpty: true });
-	const layout = readLayout(readObjectField(value, "layout", [], diagnostics), diagnostics);
-	if (version === void 0 || id === void 0 || schematic === void 0 || layout === void 0) return;
-	return {
+	const schematic = readSchematic(value, diagnostics);
+	const widgets = readWidgets(readArrayField(value, "widgets", [], diagnostics), diagnostics);
+	if (version === void 0 || widgets === void 0) return;
+	return schematic === void 0 ? {
+		version,
+		widgets
+	} : {
 		version,
-		id,
 		schematic,
-		layout
+		widgets
 	};
 }
 function readVersion(value, diagnostics) {
@@ -51,173 +74,193 @@ function readVersion(value, diagnostics) {
 	}
 	return 1;
 }
-function readLayout(value, diagnostics) {
-	if (value === void 0) return;
-	const layout = Object.create(null);
-	for (const symbolId of Object.keys(value)) {
-		const path = ["layout", symbolId];
-		if (symbolId.length === 0) {
-			report(diagnostics, "schema/invalid-value", "Layout symbol id must not be empty.", path);
-			continue;
+function readSchematic(value, diagnostics) {
+	if (!hasField(value, "schematic")) return;
+	return readStringField(value, "schematic", [], diagnostics, { nonEmpty: true });
+}
+function readWidgets(raw, diagnostics) {
+	if (raw === void 0) return;
+	const widgets = [];
+	const seen = /* @__PURE__ */ new Set();
+	raw.forEach((item, index) => {
+		const path = ["widgets", String(index)];
+		const widget = readWidget(item, path, diagnostics);
+		if (widget === void 0) return;
+		if (seen.has(widget.id)) {
+			report(diagnostics, "id/duplicate", `Duplicate widget id "${widget.id}".`, [...path, "id"]);
+			return;
 		}
-		const placement = readPlacement(value[symbolId], path, diagnostics);
-		if (placement !== void 0) layout[symbolId] = placement;
-	}
-	return layout;
+		seen.add(widget.id);
+		widgets.push(widget);
+	});
+	return widgets;
 }
-function readPlacement(value, path, diagnostics) {
+function readWidget(value, path, diagnostics) {
 	if (!isRecord(value)) {
-		report(diagnostics, "schema/invalid-type", "Placement must be an object.", path);
+		report(diagnostics, "schema/invalid-type", "Widget instance must be an object.", path);
 		return;
 	}
-	forbidUnknownFields(value, [
-		"x",
-		"y",
-		"rotation"
-	], path, diagnostics);
+	forbidUnknownFields(value, WIDGET_FIELDS, path, diagnostics);
+	const id = readId(value, path, diagnostics);
+	const widget = readWidgetReference(value, path, diagnostics);
+	const placement = readPlacement(value, path, diagnostics);
+	const hasProperties = hasField(value, "properties");
+	const properties = hasProperties ? readProperties(value["properties"], [...path, "properties"], diagnostics) : void 0;
+	const hasBindings = hasField(value, "bindings");
+	const bindings = hasBindings ? readBindings(value["bindings"], [...path, "bindings"], diagnostics) : void 0;
+	if (id === void 0 || widget === void 0 || placement === void 0 || hasProperties && properties === void 0 || hasBindings && bindings === void 0) return;
+	return {
+		id,
+		widget,
+		...placement,
+		...properties === void 0 ? {} : { properties },
+		...bindings === void 0 ? {} : { bindings }
+	};
+}
+function readId(value, path, diagnostics) {
+	const id = readStringField(value, "id", path, diagnostics, { nonEmpty: true });
+	if (id === void 0) return;
+	if (!isUuidV4(id)) {
+		report(diagnostics, "schema/invalid-value", "Field \"id\" must be a UUID v4.", [...path, "id"]);
+		return;
+	}
+	return id;
+}
+function readWidgetReference(value, path, diagnostics) {
+	const widget = readStringField(value, "widget", path, diagnostics, { nonEmpty: true });
+	if (widget === void 0) return;
+	if (!WIDGET_REFERENCE.test(widget)) {
+		report(diagnostics, "schema/invalid-value", "Field \"widget\" must be \"<package>:<widget>\" or \"builtin:<widget>\".", [...path, "widget"]);
+		return;
+	}
+	return widget;
+}
+function readPlacement(value, path, diagnostics) {
 	const x = readNumberField(value, "x", path, diagnostics);
 	const y = readNumberField(value, "y", path, diagnostics);
+	const width = readPositiveNumber(value, "width", path, diagnostics);
+	const height = readPositiveNumber(value, "height", path, diagnostics);
 	const rotation = readNumberField(value, "rotation", path, diagnostics);
-	if (x === void 0 || y === void 0 || rotation === void 0) return;
+	if (x === void 0 || y === void 0 || width === void 0 || height === void 0 || rotation === void 0) return;
 	return {
 		x,
 		y,
+		width,
+		height,
 		rotation
 	};
 }
-//#endregion
-//#region src/canvas/format/serialize.ts
-/** Serializes with a fixed field order and 2-space indentation, matching the example in #67. */
-function serializeCanvas(canvas) {
-	const layout = Object.create(null);
-	for (const symbolId of Object.keys(canvas.layout).sort()) {
-		const placement = canvas.layout[symbolId];
-		if (placement === void 0) continue;
-		layout[symbolId] = {
-			x: placement.x,
-			y: placement.y,
-			rotation: placement.rotation
-		};
+function readPositiveNumber(value, key, path, diagnostics) {
+	const field = readNumberField(value, key, path, diagnostics);
+	if (field === void 0) return;
+	if (field <= 0) {
+		report(diagnostics, "schema/invalid-value", `Field "${key}" must be a positive number.`, [...path, key]);
+		return;
 	}
-	const serializable = {
-		version: canvas.version,
-		id: canvas.id,
-		schematic: canvas.schematic,
-		layout
-	};
-	return `${JSON.stringify(serializable, null, 2)}\n`;
+	return field;
 }
-//#endregion
-//#region src/canvas/load.ts
-/** Parses a canvas and validates its layout against the bound schematic. @throws {SchematicError} */
-function loadCanvas(source, options = {}) {
-	const document = parseCanvas(source);
-	const diagnostics = [];
-	const symbolIds = options.schematic === void 0 ? void 0 : new Set(options.schematic.sheet.symbols.map((symbol) => symbol.id));
-	const placements = [];
-	for (const symbolId of Object.keys(document.layout).sort()) {
-		const placement = document.layout[symbolId];
-		if (placement === void 0) continue;
-		if (symbolIds !== void 0 && !symbolIds.has(symbolId)) {
-			diagnostics.push({
-				severity: "error",
-				code: "canvas/unknown-symbol",
-				message: `Canvas layout references symbol ${JSON.stringify(symbolId)} which is absent from the bound schematic.`,
-				pointer: toPointer(["layout", symbolId])
-			});
+/**
+* Property values are opaque to the format: their types come from the widget definition (#7), so
+* only the map shape and key spelling are checked here.
+*/
+function readProperties(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		report(diagnostics, "schema/invalid-type", "Field \"properties\" must be an object.", path);
+		return;
+	}
+	const properties = Object.create(null);
+	let failed = false;
+	for (const [key, entry] of Object.entries(value)) {
+		if (key.length === 0) {
+			report(diagnostics, "schema/invalid-value", "Property keys must not be empty.", path);
+			failed = true;
+			continue;
+		}
+		properties[key] = clonePropertyValue(entry);
+	}
+	return failed ? void 0 : properties;
+}
+/** Values are copied so the parsed document never aliases the caller's input object. */
+function clonePropertyValue(value) {
+	if (Array.isArray(value)) return value.map(clonePropertyValue);
+	const prototype = isRecord(value) ? Object.getPrototypeOf(value) : void 0;
+	if (prototype !== Object.prototype && prototype !== null) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, clonePropertyValue(entry)]));
+}
+function readBindings(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		report(diagnostics, "schema/invalid-type", "Field \"bindings\" must be an object.", path);
+		return;
+	}
+	const bindings = Object.create(null);
+	let failed = false;
+	for (const [port, entry] of Object.entries(value)) {
+		if (port.length === 0) {
+			report(diagnostics, "schema/invalid-value", "Binding port keys must not be empty.", path);
+			failed = true;
+			continue;
+		}
+		const target = readBindingTarget(entry, [...path, port], diagnostics);
+		if (target === void 0) {
+			failed = true;
 			continue;
 		}
-		placements.push({
-			symbolId,
-			placement
-		});
+		bindings[port] = target;
+	}
+	return failed ? void 0 : bindings;
+}
+function readBindingTarget(value, path, diagnostics) {
+	if (!isRecord(value)) {
+		report(diagnostics, "schema/invalid-type", "Binding target must be an object.", path);
+		return;
 	}
-	if (diagnostics.length > 0) throw new SchematicError(diagnostics);
+	forbidUnknownFields(value, ["symbol", "port"], path, diagnostics);
+	const symbol = readStringField(value, "symbol", path, diagnostics, { nonEmpty: true });
+	const port = readStringField(value, "port", path, diagnostics, { nonEmpty: true });
+	if (symbol === void 0 || port === void 0) return;
 	return {
-		document,
-		placements
+		symbol,
+		port
 	};
 }
+function hasField(value, key) {
+	return Object.prototype.hasOwnProperty.call(value, key);
+}
 //#endregion
-//#region src/canvas/edit.ts
+//#region src/canvas/format/serialize.ts
 /**
-* Applies a canvas command to a copy of `canvas`.
-*
-* @throws {SchematicError} when the command is invalid; the input canvas is never mutated.
+* Serializes with a fixed field order and 2-space indentation, matching the example in #67.
+* `properties` and `bindings` are written whenever the document carries them, even when empty, so
+* a parse / serialize round trip keeps the original shape.
 */
-function applyCanvasCommand(canvas, command, options = {}) {
-	const diagnostics = [];
-	const layout = { ...canvas.layout };
-	switch (command.type) {
-		case "set-placement": {
-			if (command.symbolId.length === 0) {
-				diagnostics.push({
-					severity: "error",
-					code: "schema/invalid-value",
-					message: "Placement symbol id must not be empty.",
-					pointer: toPointer(["layout"])
-				});
-				break;
-			}
-			requireKnownSymbol(command.symbolId, options, diagnostics);
-			const existing = layout[command.symbolId];
-			layout[command.symbolId] = {
-				x: command.x,
-				y: command.y,
-				rotation: command.rotation ?? existing?.rotation ?? 0
-			};
-			break;
-		}
-		case "remove-placement":
-			if (!Object.prototype.hasOwnProperty.call(layout, command.symbolId)) {
-				diagnostics.push({
-					severity: "error",
-					code: "edit/unknown-entity",
-					message: `Canvas has no placement for symbol "${command.symbolId}".`,
-					pointer: toPointer(["layout", command.symbolId])
-				});
-				break;
-			}
-			delete layout[command.symbolId];
-			break;
-		case "bind-schematic":
-			if (command.schematic.length === 0) {
-				diagnostics.push({
-					severity: "error",
-					code: "schema/invalid-value",
-					message: "Bound schematic reference must not be empty.",
-					pointer: toPointer(["schematic"])
-				});
-				break;
-			}
-			if (diagnostics.length === 0) return {
-				...canvas,
-				schematic: command.schematic
-			};
-			break;
-		default: diagnostics.push({
-			severity: "error",
-			code: "edit/invalid-command",
-			message: `Unsupported canvas command ${JSON.stringify(command.type)}.`
-		});
-	}
-	if (diagnostics.length > 0) throw new SchematicError(diagnostics);
-	return {
-		...canvas,
-		layout
-	};
+function serializeCanvas(document) {
+	const serializable = { version: document.version };
+	if (document.schematic !== void 0) serializable["schematic"] = document.schematic;
+	serializable["widgets"] = document.widgets.map(serializeWidget);
+	return `${JSON.stringify(serializable, null, 2)}\n`;
 }
-function requireKnownSymbol(symbolId, options, diagnostics) {
-	if (options.schematic === void 0) return;
-	if (options.schematic.sheet.symbols.some((symbol) => symbol.id === symbolId)) return;
-	diagnostics.push({
-		severity: "error",
-		code: "canvas/unknown-symbol",
-		message: `Canvas layout references symbol ${JSON.stringify(symbolId)} which is absent from the bound schematic.`,
-		pointer: toPointer(["layout", symbolId])
-	});
+function serializeWidget(widget) {
+	const serialized = {
+		id: widget.id,
+		widget: widget.widget,
+		x: widget.x,
+		y: widget.y,
+		width: widget.width,
+		height: widget.height,
+		rotation: widget.rotation
+	};
+	if (widget.properties !== void 0) serialized["properties"] = { ...widget.properties };
+	if (widget.bindings !== void 0) {
+		const bindings = Object.create(null);
+		for (const [port, target] of Object.entries(widget.bindings)) bindings[port] = {
+			symbol: target.symbol,
+			port: target.port
+		};
+		serialized["bindings"] = bindings;
+	}
+	return serialized;
 }
 //#endregion
-export { CANVAS_VERSION, SchematicError, applyCanvasCommand, loadCanvas, parseCanvas, serializeCanvas };
+export { CANVAS_VERSION, SchematicError, parseCanvas, serializeCanvas };
 
 //# sourceMappingURL=index.js.map