@hachej/boring-ui-kit 0.1.111 → 0.2.1

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,85 @@
+# Third-party notices
+
+The Markdown toolbar includes paths from Lucide, including Feather-derived icons.
+The notices below are from lucide-react 1.51.0.
+
+```text
+ISC License
+
+Copyright (c) 2026 Lucide Icons and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---
+
+The following Lucide icons are derived from the Feather project:
+
+airplay, alert-circle, alert-octagon, alert-triangle, aperture, arrow-down-circle, arrow-down-left, arrow-down-right, arrow-down, arrow-left-circle, arrow-left, arrow-right-circle, arrow-right, arrow-up-circle, arrow-up-left, arrow-up-right, arrow-up, at-sign, calendar, cast, check, chevron-down, chevron-left, chevron-right, chevron-up, chevrons-down, chevrons-left, chevrons-right, chevrons-up, circle, clipboard, clock, code, columns, command, compass, corner-down-left, corner-down-right, corner-left-down, corner-left-up, corner-right-down, corner-right-up, corner-up-left, corner-up-right, crosshair, database, divide-circle, divide-square, dollar-sign, download, external-link, feather, frown, hash, headphones, help-circle, info, italic, key, layout, life-buoy, link-2, link, loader, lock, log-in, log-out, maximize, meh, minimize, minimize-2, minus-circle, minus-square, minus, monitor, moon, more-horizontal, more-vertical, move, music, navigation-2, navigation, octagon, pause-circle, percent, plus-circle, plus-square, plus, power, radio, rss, search, server, share, shopping-bag, sidebar, smartphone, smile, square, table-2, tablet, target, terminal, trash-2, trash, triangle, tv, type, upload, x-circle, x-octagon, x-square, x, zoom-in, zoom-out
+
+The MIT License (MIT) (for the icons listed above)
+
+Copyright (c) 2013-present Cole Bemis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+```
+
+## shadcn/ui file tree
+
+The file tree adapts `sidebar-11` and its menu primitives from shadcn/ui at
+commit `6ea090075cd537d3b792c6c1a625e2448b6ede26`:
+https://github.com/shadcn-ui/ui/tree/6ea090075cd537d3b792c6c1a625e2448b6ede26/apps/v4/registry/new-york-v4
+
+The adaptation replaces sample data with the revision controller, adds keyboard
+navigation, and omits the outer sidebar, sidebar-provider tooltip behavior and
+unused menu variants so the same tree can render in a detached container.
+
+```text
+MIT License
+
+Copyright (c) 2023 shadcn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```

package/dist/anchor-conformance.d.ts

@@ -0,0 +1,78 @@
+import type { Anchor, AnchorResolution, Placement } from './contracts.js';
+/** Anchor conformance kit (FEEDBACK.md, FEEDBACK-4). It drives one
+ * `AnchorResolution` over a named corpus and returns structured results; it
+ * imports no test runner, so any runner (or none) can assert on the output.
+ * Its verdict is bounded to the corpus: "zero wrong spots for the named corpus".
+ * The purity trap covers fetch, timers, Date.now, Math.random and
+ * performance.now during `resolve`; it bounds the purity claim, it does not prove it.
+ */
+export type AnchorExpectation<Range> = {
+    readonly kind: 'exact' | 'moved';
+    readonly range: Range;
+} | {
+    readonly kind: 'ambiguous';
+    readonly candidates: readonly Range[];
+} | {
+    readonly kind: 'missing' | 'unsupported';
+};
+export interface AnchorConformanceStep<Snapshot, Range> {
+    readonly name: string;
+    /** The full snapshot this step resolves against. */
+    readonly snapshot: Snapshot;
+    readonly evaluated: string;
+    readonly expect: AnchorExpectation<Range>;
+}
+export interface AnchorConformanceCase<Snapshot, Range> {
+    readonly name: string;
+    /** Rates are reported per group. */
+    readonly group: string;
+    /** The anchor is data as stored; an unknown kind is kept, never parsed. */
+    readonly capture: {
+        readonly snapshot: Snapshot;
+        readonly anchor: unknown;
+    };
+    readonly steps: readonly AnchorConformanceStep<Snapshot, Range>[];
+}
+export interface AnchorConformanceInput<A extends Anchor, Snapshot, Range> {
+    readonly resolution: AnchorResolution<A, Snapshot, Range>;
+    readonly cases: readonly AnchorConformanceCase<Snapshot, Range>[];
+}
+export type PlacementKind = Placement<unknown>['kind'];
+export interface AnchorStepResult<Range> {
+    readonly name: string;
+    readonly expect: AnchorExpectation<Range>;
+    /** Absent when `resolve` threw or returned no placement. */
+    readonly placement?: Placement<Range>;
+    readonly passed: boolean;
+    readonly wrongSpots: number;
+    readonly failures: readonly string[];
+}
+export interface AnchorCaseResult<Range> {
+    readonly name: string;
+    readonly group: string;
+    readonly passed: boolean;
+    readonly wrongSpots: number;
+    /** Case-level checks (schema round-trip, fallback) and every step failure, prefixed. */
+    readonly failures: readonly string[];
+    readonly steps: readonly AnchorStepResult<Range>[];
+}
+export interface AnchorGroupRates {
+    readonly cases: number;
+    readonly passedCases: number;
+    readonly steps: number;
+    readonly wrongSpots: number;
+    readonly placements: Readonly<Record<PlacementKind | 'error', number>>;
+    /** (exact + moved) / steps; reported, never thresholded. */
+    readonly automatic: number;
+}
+export interface AnchorConformanceReport<Range> {
+    readonly results: readonly AnchorCaseResult<Range>[];
+    readonly wrongSpots: number;
+    readonly rates: Readonly<Record<string, AnchorGroupRates>>;
+    /** Every case passed every check. */
+    readonly passed: boolean;
+    readonly verdict: string;
+}
+export declare const ANCHOR_CONFORMANCE_VERDICT = "zero wrong spots for the named corpus";
+export declare function runAnchorConformance<A extends Anchor, Snapshot, Range>(input: AnchorConformanceInput<A, Snapshot, Range>): AnchorConformanceReport<Range>;
+//# sourceMappingURL=anchor-conformance.d.ts.map

package/dist/anchor-conformance.js

@@ -0,0 +1,288 @@
+export const ANCHOR_CONFORMANCE_VERDICT = 'zero wrong spots for the named corpus';
+const DETERMINISM_CALLS = 3;
+export function runAnchorConformance(input) {
+    const results = input.cases.map(item => runCase(input.resolution, item));
+    const wrongSpots = results.reduce((sum, result) => sum + result.wrongSpots, 0);
+    const passed = results.every(result => result.passed);
+    return {
+        results,
+        wrongSpots,
+        rates: groupRates(results),
+        passed,
+        verdict: wrongSpots === 0 ? ANCHOR_CONFORMANCE_VERDICT : `${wrongSpots} wrong spot${wrongSpots === 1 ? '' : 's'} for the named corpus`,
+    };
+}
+function runCase(resolution, item) {
+    const failures = [];
+    const stored = item.capture.anchor;
+    const kind = isRecord(stored) && typeof stored['kind'] === 'string' ? stored['kind'] : undefined;
+    let anchor;
+    if (kind === undefined)
+        failures.push('anchor has no string kind');
+    else if (kind === resolution.kind)
+        anchor = checkSchema(resolution, stored, failures);
+    else
+        checkUnknown(stored, failures);
+    const steps = item.steps.map(step => runStep(resolution, kind, anchor, step));
+    for (const step of steps)
+        for (const failure of step.failures)
+            failures.push(`step "${step.name}": ${failure}`);
+    const wrongSpots = steps.reduce((sum, step) => sum + step.wrongSpots, 0);
+    return {
+        name: item.name,
+        group: item.group,
+        passed: failures.length === 0,
+        wrongSpots,
+        failures: failures.map(failure => `case "${item.name}": ${failure}`),
+        steps,
+    };
+}
+/** Parse, serialize and parse again: the anchor must survive as plain data. */
+function checkSchema(resolution, stored, failures) {
+    let anchor;
+    try {
+        anchor = resolution.schema.parse(stored);
+    }
+    catch (error) {
+        failures.push(`schema rejected the captured anchor: ${message(error)}`);
+        return undefined;
+    }
+    try {
+        const again = resolution.schema.parse(JSON.parse(JSON.stringify(anchor)));
+        if (!deepEqual(again, anchor))
+            failures.push(`schema round-trip changed the anchor: ${show(anchor)} became ${show(again)}`);
+    }
+    catch (error) {
+        failures.push(`schema round-trip failed: ${message(error)}`);
+    }
+    let fallback;
+    try {
+        fallback = resolution.fallback(anchor);
+    }
+    catch (error) {
+        failures.push(`fallback threw: ${message(error)}`);
+    }
+    if (typeof fallback !== 'string' || fallback.trim() === '')
+        failures.push(`fallback is empty: ${show(fallback)}`);
+    return anchor;
+}
+/** An uninstalled kind is preserved as data and still carries its own fallback. */
+function checkUnknown(stored, failures) {
+    let copy;
+    try {
+        copy = JSON.parse(JSON.stringify(stored));
+    }
+    catch (error) {
+        failures.push(`unknown-kind anchor is not plain data: ${message(error)}`);
+        return;
+    }
+    if (!deepEqual(copy, stored))
+        failures.push('unknown-kind anchor does not survive serialization');
+    const fallback = isRecord(stored) ? stored['fallback'] : undefined;
+    if (typeof fallback !== 'string' || fallback.trim() === '')
+        failures.push(`unknown-kind anchor has an empty fallback: ${show(fallback)}`);
+}
+function runStep(resolution, kind, anchor, step) {
+    const failures = [];
+    let placement;
+    if (kind !== undefined && kind !== resolution.kind) {
+        // Uninstalled kinds are placed as `unsupported` without calling another kind's resolver (FEEDBACK-3).
+        placement = { kind: 'unsupported', evaluated: step.evaluated };
+    }
+    else if (anchor !== undefined) {
+        placement = resolveChecked(resolution, anchor, step, failures);
+    }
+    else {
+        failures.push('not resolved: the anchor did not parse');
+    }
+    let wrongSpots = 0;
+    if (placement !== undefined) {
+        if (placement.evaluated !== step.evaluated)
+            failures.push(`reported evaluated ${show(placement.evaluated)}, expected ${show(step.evaluated)}`);
+        const judged = judge(step.expect, placement);
+        wrongSpots = judged.wrongSpots;
+        failures.push(...judged.failures);
+    }
+    const base = { name: step.name, expect: step.expect, passed: failures.length === 0, wrongSpots, failures };
+    return placement === undefined ? base : { ...base, placement };
+}
+/** Three trapped calls on cloned inputs: they must agree, leave inputs untouched and touch no trapped global. */
+function resolveChecked(resolution, anchor, step, failures) {
+    const outputs = [];
+    for (let call = 0; call < DETERMINISM_CALLS; call += 1) {
+        const anchorCopy = structuredClone(anchor);
+        const snapshotCopy = structuredClone(step.snapshot);
+        const { value, touched, error } = trapped(() => resolution.resolve(anchorCopy, snapshotCopy, step.evaluated));
+        if (touched.length)
+            failures.push(`purity trap: resolve touched ${[...new Set(touched)].join(', ')}`);
+        if (error !== undefined) {
+            failures.push(`resolve threw: ${message(error)}`);
+            return undefined;
+        }
+        if (!deepEqual(anchorCopy, anchor) || !deepEqual(snapshotCopy, step.snapshot))
+            failures.push('resolve mutated its anchor or snapshot');
+        outputs.push(value);
+    }
+    const [first] = outputs;
+    if (outputs.some(output => !deepEqual(output, first)))
+        failures.push(`not deterministic over ${DETERMINISM_CALLS} calls: ${outputs.map(show).join(' / ')}`);
+    if (!isPlacement(first)) {
+        failures.push(`resolve returned no placement: ${show(first)}`);
+        return undefined;
+    }
+    return first;
+}
+function judge(expect, placement) {
+    const failures = [];
+    let wrongSpots = 0;
+    const expectedSet = expect.kind === 'exact' || expect.kind === 'moved' ? [expect.range] : expect.kind === 'ambiguous' ? expect.candidates : [];
+    const wanted = describe(expect);
+    if (placement.kind === 'exact' || placement.kind === 'moved' || placement.kind === 'partial') {
+        const sameRange = (expect.kind === 'exact' || expect.kind === 'moved') && deepEqual(placement.range, expect.range);
+        if (!sameRange) {
+            wrongSpots += 1;
+            failures.push(`wrong spot: ${placement.kind} at ${show(placement.range)} but expected ${wanted}`);
+        }
+        else if (placement.kind !== expect.kind) {
+            failures.push(`placed ${placement.kind} at the right range but expected ${wanted}`);
+        }
+        return { wrongSpots, failures };
+    }
+    if (placement.kind === 'ambiguous') {
+        for (const candidate of placement.candidates) {
+            if (!expectedSet.some(range => deepEqual(range, candidate))) {
+                wrongSpots += 1;
+                failures.push(`wrong spot: candidate ${show(candidate)} is outside the expected set ${show(expectedSet)}`);
+            }
+        }
+        if (expect.kind !== 'ambiguous')
+            failures.push(`ambiguous ${show(placement.candidates)} but expected ${wanted}`);
+        else if (!sameSet(placement.candidates, expect.candidates))
+            failures.push(`incomplete candidate set ${show(placement.candidates)}, expected ${show(expect.candidates)}`);
+        return { wrongSpots, failures };
+    }
+    if (placement.kind !== expect.kind)
+        failures.push(`${placement.kind} but expected ${wanted}`);
+    return { wrongSpots, failures };
+}
+function describe(expect) {
+    if (expect.kind === 'exact' || expect.kind === 'moved')
+        return `${expect.kind} at ${show(expect.range)}`;
+    if (expect.kind === 'ambiguous')
+        return `ambiguous ${show(expect.candidates)}`;
+    return expect.kind;
+}
+function groupRates(results) {
+    const groups = new Map();
+    for (const result of results)
+        groups.set(result.group, [...(groups.get(result.group) ?? []), result]);
+    const rates = {};
+    for (const [group, members] of groups) {
+        const placements = { exact: 0, moved: 0, ambiguous: 0, partial: 0, missing: 0, unsupported: 0, error: 0 };
+        let steps = 0;
+        for (const member of members)
+            for (const step of member.steps) {
+                steps += 1;
+                placements[step.placement?.kind ?? 'error'] += 1;
+            }
+        rates[group] = {
+            cases: members.length,
+            passedCases: members.filter(member => member.passed).length,
+            steps,
+            wrongSpots: members.reduce((sum, member) => sum + member.wrongSpots, 0),
+            placements,
+            automatic: steps === 0 ? 0 : (placements.exact + placements.moved) / steps,
+        };
+    }
+    return rates;
+}
+// --- purity trap -----------------------------------------------------------
+const TRAPS = [
+    [() => globalThis, 'fetch', 'fetch'],
+    [() => globalThis, 'setTimeout', 'setTimeout'],
+    [() => globalThis, 'setInterval', 'setInterval'],
+    [() => globalThis, 'setImmediate', 'setImmediate'],
+    [() => globalThis, 'requestAnimationFrame', 'requestAnimationFrame'],
+    [() => globalThis, 'requestIdleCallback', 'requestIdleCallback'],
+    [() => Date, 'now', 'Date.now'],
+    [() => Math, 'random', 'Math.random'],
+    [() => (typeof performance === 'object' && performance !== null ? performance : undefined), 'now', 'performance.now'],
+];
+/** Runs `run` with each trapped global replaced by a recorder that throws.
+ * Every replaced property is restored in `finally`, also when `run` throws.
+ */
+function trapped(run) {
+    const touched = [];
+    const restore = [];
+    try {
+        for (const [ownerOf, property, label] of TRAPS) {
+            const owner = ownerOf();
+            if (owner === undefined || !(property in owner))
+                continue;
+            const own = Object.getOwnPropertyDescriptor(owner, property);
+            if (own !== undefined && !own.configurable)
+                continue;
+            Object.defineProperty(owner, property, {
+                configurable: true, writable: true, enumerable: own?.enumerable ?? false,
+                value: () => { touched.push(label); throw new Error(`purity trap: ${label} is not allowed in resolve`); },
+            });
+            restore.push(own === undefined ? () => { delete owner[property]; } : () => { Object.defineProperty(owner, property, own); });
+        }
+        return { value: run(), touched };
+    }
+    catch (error) {
+        return { touched, error };
+    }
+    finally {
+        for (const undo of restore.reverse())
+            undo();
+    }
+}
+// --- plain-data helpers ----------------------------------------------------
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isPlacement(value) {
+    if (!isRecord(value) || typeof value['evaluated'] !== 'string')
+        return false;
+    switch (value['kind']) {
+        case 'exact':
+        case 'moved': return 'range' in value;
+        case 'partial': return 'range' in value && Array.isArray(value['missing']);
+        case 'ambiguous': return Array.isArray(value['candidates']);
+        case 'missing':
+        case 'unsupported': return true;
+        default: return false;
+    }
+}
+function sameSet(actual, expected) {
+    return actual.length === expected.length
+        && actual.every(item => expected.some(other => deepEqual(item, other)))
+        && expected.every(item => actual.some(other => deepEqual(item, other)));
+}
+/** Structural equality for plain data: primitives, arrays and plain objects. */
+function deepEqual(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (typeof left !== 'object' || typeof right !== 'object' || left === null || right === null)
+        return false;
+    if (Array.isArray(left) !== Array.isArray(right))
+        return false;
+    if (Array.isArray(left) && Array.isArray(right))
+        return left.length === right.length && left.every((item, index) => deepEqual(item, right[index]));
+    const a = left;
+    const b = right;
+    const keys = Object.keys(a);
+    return keys.length === Object.keys(b).length && keys.every(key => Object.prototype.hasOwnProperty.call(b, key) && deepEqual(a[key], b[key]));
+}
+function show(value) {
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/canvas-document.d.ts

@@ -0,0 +1,25 @@
+import type { TLBinding, TLShape, TLStoreSchema, TLStoreSnapshot } from '@tldraw/tlschema';
+export declare const canvasMediaType = "application/vnd.tldraw+json";
+export type CanvasEditableRecord = TLShape | TLBinding;
+/** Updates replace complete native records. Removing a shape also removes its descendants and connected arrows. */
+export type CanvasEdit = {
+    readonly kind: 'create' | 'update';
+    readonly record: CanvasEditableRecord;
+} | {
+    readonly kind: 'remove';
+    readonly id: CanvasEditableRecord['id'];
+};
+export type CanvasEditResult = {
+    readonly kind: 'applied';
+    readonly document: TLStoreSnapshot;
+} | {
+    readonly kind: 'rejected';
+    readonly reason: string;
+};
+/** Parse a complete document without mounting an editor, migrating records or repairing the graph. */
+export declare function parseCanvasDocument(value: unknown, schema: TLStoreSchema): TLStoreSnapshot;
+/** Parse edit inputs with the selected native schema, without changing a document. */
+export declare function parseCanvasEdits(value: unknown, schema: TLStoreSchema): readonly CanvasEdit[];
+/** Apply one atomic edit batch to a detached candidate. The caller owns conditional publication. */
+export declare function applyCanvasEdits(document: TLStoreSnapshot, edits: readonly CanvasEdit[], schema: TLStoreSchema): CanvasEditResult;
+//# sourceMappingURL=canvas-document.d.ts.map

package/dist/canvas-document.js

@@ -0,0 +1,141 @@
+import { isBindingId, isShapeId, TLDOCUMENT_ID } from '@tldraw/tlschema';
+import { parseCanvasRecords } from './canvas-records.js';
+export const canvasMediaType = 'application/vnd.tldraw+json';
+/** Parse a complete document without mounting an editor, migrating records or repairing the graph. */
+export function parseCanvasDocument(value, schema) {
+    const document = parseCanvasRecords(value, schema), records = Object.values(document.store);
+    const documents = records.filter(record => record.typeName === 'document');
+    if (documents.length !== 1 || documents[0]?.id !== TLDOCUMENT_ID || !records.some(record => record.typeName === 'page')) {
+        throw new TypeError('Canvas requires its native document record and at least one page');
+    }
+    const pages = new Map();
+    function pageOf(shape) {
+        const known = pages.get(shape.id);
+        if (known !== undefined)
+            return known;
+        const visited = new Set();
+        let current = shape;
+        while (true) {
+            const cached = pages.get(current.id);
+            if (cached !== undefined) {
+                for (const id of visited)
+                    pages.set(id, cached);
+                return cached;
+            }
+            if (visited.has(current.id))
+                throw new TypeError('Canvas shape parents contain a cycle');
+            visited.add(current.id);
+            const parent = document.store[current.parentId];
+            if (parent?.typeName === 'page') {
+                for (const id of visited)
+                    pages.set(id, parent.id);
+                return parent.id;
+            }
+            if (parent?.typeName !== 'shape' || (parent.type !== 'group' && parent.type !== 'frame')) {
+                throw new TypeError('Canvas shape parent must be an existing page, group or frame');
+            }
+            current = parent;
+        }
+    }
+    for (const record of records)
+        if (record.typeName === 'shape')
+            pageOf(record);
+    const terminals = new Set();
+    for (const record of records) {
+        if (record.typeName !== 'binding')
+            continue;
+        const from = document.store[record.fromId], to = document.store[record.toId];
+        if (from?.typeName !== 'shape' || from.type !== 'arrow' || to?.typeName !== 'shape' || to.type === 'arrow') {
+            throw new TypeError('Canvas arrow binding must connect an existing arrow to a non-arrow shape');
+        }
+        if (pageOf(from) !== pageOf(to))
+            throw new TypeError('Canvas arrow binding cannot cross pages');
+        const terminal = JSON.stringify([record.fromId, record.props['terminal']]);
+        if (terminals.has(terminal))
+            throw new TypeError('Canvas arrow has duplicate terminal bindings');
+        terminals.add(terminal);
+    }
+    return document;
+}
+/** Parse edit inputs with the selected native schema, without changing a document. */
+export function parseCanvasEdits(value, schema) {
+    if (!Array.isArray(value) || value.length === 0)
+        throw new TypeError('Canvas edits must be a nonempty array');
+    const edits = [], requested = new Set();
+    for (const item of structuredClone(value)) {
+        const edit = item;
+        if (!edit || typeof edit !== 'object' || !('kind' in edit))
+            throw new TypeError('Invalid canvas edit');
+        let parsed;
+        if (edit.kind === 'remove') {
+            if (Object.keys(edit).some(key => key !== 'kind' && key !== 'id') || !('id' in edit) || typeof edit.id !== 'string'
+                || (!isShapeId(edit.id) && !isBindingId(edit.id)))
+                throw new TypeError('Invalid canvas removal');
+            parsed = { kind: 'remove', id: edit.id };
+        }
+        else if (edit.kind === 'create' || edit.kind === 'update') {
+            if (Object.keys(edit).some(key => key !== 'kind' && key !== 'record') || !('record' in edit) || !edit.record || typeof edit.record !== 'object'
+                || !('typeName' in edit.record))
+                throw new TypeError('Invalid canvas edit record');
+            const record = edit.record.typeName === 'shape' ? schema.types.shape.validate(edit.record)
+                : edit.record.typeName === 'binding' ? schema.types.binding.validate(edit.record) : undefined;
+            if (!record || (record.typeName !== 'shape' && record.typeName !== 'binding'))
+                throw new TypeError('Canvas edits accept only shapes and bindings');
+            parsed = { kind: edit.kind, record };
+        }
+        else
+            throw new TypeError('Unknown canvas edit kind');
+        const id = parsed.kind === 'remove' ? parsed.id : parsed.record.id;
+        if (requested.has(id))
+            throw new TypeError('Canvas batch edits an identity more than once');
+        requested.add(id);
+        edits.push(parsed);
+    }
+    return edits;
+}
+/** Apply one atomic edit batch to a detached candidate. The caller owns conditional publication. */
+export function applyCanvasEdits(document, edits, schema) {
+    try {
+        const candidate = parseCanvasDocument(document, schema);
+        const removed = new Set(), written = new Set();
+        for (const edit of parseCanvasEdits(edits, schema)) {
+            if (edit.kind === 'remove') {
+                const current = candidate.store[edit.id];
+                if (current?.typeName !== 'shape' && current?.typeName !== 'binding')
+                    throw new TypeError('Canvas removal requires an existing shape or binding');
+                removed.add(edit.id);
+            }
+            else {
+                const record = edit.record, current = candidate.store[record.id];
+                if (edit.kind === 'create' ? current !== undefined : current?.typeName !== record.typeName || !('type' in current) || current.type !== record.type) {
+                    throw new TypeError('Canvas create requires absence; update requires an existing record of the same type');
+                }
+                written.add(record.id);
+                candidate.store[record.id] = record;
+            }
+        }
+        const records = Object.values(candidate.store);
+        let previousSize = -1;
+        while (removed.size !== previousSize) {
+            previousSize = removed.size;
+            for (const record of records) {
+                if (record.typeName === 'shape' && removed.has(record.parentId))
+                    removed.add(record.id);
+                if (record.typeName === 'binding' && !removed.has(record.id) && removed.has(record.toId))
+                    removed.add(record.fromId);
+            }
+        }
+        for (const record of records)
+            if (record.typeName === 'binding' && (removed.has(record.fromId) || removed.has(record.toId)))
+                removed.add(record.id);
+        for (const id of removed) {
+            if (written.has(id))
+                throw new TypeError('Canvas batch writes a record removed by its deletion cascade');
+            delete candidate.store[id];
+        }
+        return { kind: 'applied', document: parseCanvasDocument(candidate, schema) };
+    }
+    catch (error) {
+        return { kind: 'rejected', reason: error instanceof Error ? error.message : 'Invalid canvas edit batch' };
+    }
+}

package/dist/canvas-editor-native.d.ts

@@ -0,0 +1,22 @@
+import type { CSSProperties } from 'react';
+import type { TLOnMountHandler } from '@tldraw/editor';
+import type { TLDefaultFonts, TLUiAssetUrls } from 'tldraw';
+import type { CanvasController } from './canvas.js';
+import type { CanvasMountedTools } from './canvas-mounted.js';
+export type CanvasFontUrls = Readonly<Record<`${keyof TLDefaultFonts}${'' | '_italic' | '_bold' | '_italic_bold'}`, string>>;
+export type CanvasAssetUrls = Omit<TLUiAssetUrls, 'fonts' | 'embedIcons'> & {
+    readonly fonts: CanvasFontUrls;
+    readonly embedIcons: Required<TLUiAssetUrls['embedIcons']>;
+};
+export interface CanvasEditorProps {
+    readonly controller: CanvasController;
+    readonly assetUrls: CanvasAssetUrls;
+    readonly title?: string;
+    readonly className?: string;
+    readonly height?: CSSProperties['height'];
+    readonly licenseKey?: string;
+    readonly onMount?: TLOnMountHandler;
+    readonly onMountedTools?: (tools: CanvasMountedTools | null) => void;
+}
+export default function NativeCanvas({ controller, assetUrls, title, className, height, licenseKey, onMount, onMountedTools }: CanvasEditorProps): import("react").JSX.Element;
+//# sourceMappingURL=canvas-editor-native.d.ts.map