@abraca/orchestrator 2.3.0

package/dist/abracadabra-orchestrator.esm.js

@@ -0,0 +1,2665 @@
+#!/usr/bin/env node
+import { dirname, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import * as Y from "yjs";
+import { AbracadabraClient, AbracadabraProvider } from "@abraca/dabra";
+import * as ed from "@noble/ed25519";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+
+//#region node_modules/@noble/hashes/utils.js
+/**
+* Checks if something is Uint8Array. Be careful: nodejs Buffer will return true.
+* @param a - value to test
+* @returns `true` when the value is a Uint8Array-compatible view.
+* @example
+* Check whether a value is a Uint8Array-compatible view.
+* ```ts
+* isBytes(new Uint8Array([1, 2, 3]));
+* ```
+*/
+function isBytes(a) {
+	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+/**
+* Asserts something is Uint8Array.
+* @param value - value to validate
+* @param length - optional exact length constraint
+* @param title - label included in thrown errors
+* @returns The validated byte array.
+* @throws On wrong argument types. {@link TypeError}
+* @throws On wrong argument ranges or values. {@link RangeError}
+* @example
+* Validate that a value is a byte array.
+* ```ts
+* abytes(new Uint8Array([1, 2, 3]));
+* ```
+*/
+function abytes(value, length, title = "") {
+	const bytes = isBytes(value);
+	const len = value?.length;
+	const needsLen = length !== void 0;
+	if (!bytes || needsLen && len !== length) {
+		const prefix = title && `"${title}" `;
+		const ofLen = needsLen ? ` of length ${length}` : "";
+		const got = bytes ? `length=${len}` : `type=${typeof value}`;
+		const message = prefix + "expected Uint8Array" + ofLen + ", got " + got;
+		if (!bytes) throw new TypeError(message);
+		throw new RangeError(message);
+	}
+	return value;
+}
+/**
+* Asserts a hash instance has not been destroyed or finished.
+* @param instance - hash instance to validate
+* @param checkFinished - whether to reject finalized instances
+* @throws If the hash instance has already been destroyed or finalized. {@link Error}
+* @example
+* Validate that a hash instance is still usable.
+* ```ts
+* import { aexists } from '@noble/hashes/utils.js';
+* import { sha256 } from '@noble/hashes/sha2.js';
+* const hash = sha256.create();
+* aexists(hash);
+* ```
+*/
+function aexists(instance, checkFinished = true) {
+	if (instance.destroyed) throw new Error("Hash instance has been destroyed");
+	if (checkFinished && instance.finished) throw new Error("Hash#digest() has already been called");
+}
+/**
+* Asserts output is a sufficiently-sized byte array.
+* @param out - destination buffer
+* @param instance - hash instance providing output length
+* Oversized buffers are allowed; downstream code only promises to fill the first `outputLen` bytes.
+* @throws On wrong argument types. {@link TypeError}
+* @throws On wrong argument ranges or values. {@link RangeError}
+* @example
+* Validate a caller-provided digest buffer.
+* ```ts
+* import { aoutput } from '@noble/hashes/utils.js';
+* import { sha256 } from '@noble/hashes/sha2.js';
+* const hash = sha256.create();
+* aoutput(new Uint8Array(hash.outputLen), hash);
+* ```
+*/
+function aoutput(out, instance) {
+	abytes(out, void 0, "digestInto() output");
+	const min = instance.outputLen;
+	if (out.length < min) throw new RangeError("\"digestInto() output\" expected to be of length >=" + min);
+}
+/**
+* Zeroizes typed arrays in place. Warning: JS provides no guarantees.
+* @param arrays - arrays to overwrite with zeros
+* @example
+* Zeroize sensitive buffers in place.
+* ```ts
+* clean(new Uint8Array([1, 2, 3]));
+* ```
+*/
+function clean(...arrays) {
+	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
+}
+/**
+* Creates a DataView for byte-level manipulation.
+* @param arr - source typed array
+* @returns DataView over the same buffer region.
+* @example
+* Create a DataView over an existing buffer.
+* ```ts
+* createView(new Uint8Array(4));
+* ```
+*/
+function createView(arr) {
+	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** Whether the current platform is little-endian. */
+const isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+const hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
+/**
+* Creates a callable hash function from a stateful class constructor.
+* @param hashCons - hash constructor or factory
+* @param info - optional metadata such as DER OID
+* @returns Frozen callable hash wrapper with `.create()`.
+*   Wrapper construction eagerly calls `hashCons(undefined)` once to read
+*   `outputLen` / `blockLen`, so constructor side effects happen at module
+*   init time.
+* @example
+* Wrap a stateful hash constructor into a callable helper.
+* ```ts
+* import { createHasher } from '@noble/hashes/utils.js';
+* import { sha256 } from '@noble/hashes/sha2.js';
+* const wrapped = createHasher(sha256.create, { oid: sha256.oid });
+* wrapped(new Uint8Array([1]));
+* ```
+*/
+function createHasher(hashCons, info = {}) {
+	const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+	const tmp = hashCons(void 0);
+	hashC.outputLen = tmp.outputLen;
+	hashC.blockLen = tmp.blockLen;
+	hashC.canXOF = tmp.canXOF;
+	hashC.create = (opts) => hashCons(opts);
+	Object.assign(hashC, info);
+	return Object.freeze(hashC);
+}
+/**
+* Creates OID metadata for NIST hashes with prefix `06 09 60 86 48 01 65 03 04 02`.
+* @param suffix - final OID byte for the selected hash.
+*   The helper accepts any byte even though only the documented NIST hash
+*   suffixes are meaningful downstream.
+* @returns Object containing the DER-encoded OID.
+* @example
+* Build OID metadata for a NIST hash.
+* ```ts
+* oidNist(0x01);
+* ```
+*/
+const oidNist = (suffix) => ({ oid: Uint8Array.from([
+	6,
+	9,
+	96,
+	134,
+	72,
+	1,
+	101,
+	3,
+	4,
+	2,
+	suffix
+]) });
+
+//#endregion
+//#region node_modules/@noble/hashes/_md.js
+/**
+* Internal Merkle-Damgard hash utils.
+* @module
+*/
+/**
+* Merkle-Damgard hash construction base class.
+* Could be used to create MD5, RIPEMD, SHA1, SHA2.
+* Accepts only byte-aligned `Uint8Array` input, even when the underlying spec describes bit
+* strings with partial-byte tails.
+* @param blockLen - internal block size in bytes
+* @param outputLen - digest size in bytes
+* @param padOffset - trailing length field size in bytes
+* @param isLE - whether length and state words are encoded in little-endian
+* @example
+* Use a concrete subclass to get the shared Merkle-Damgard update/digest flow.
+* ```ts
+* import { _SHA1 } from '@noble/hashes/legacy.js';
+* const hash = new _SHA1();
+* hash.update(new Uint8Array([97, 98, 99]));
+* hash.digest();
+* ```
+*/
+var HashMD = class {
+	blockLen;
+	outputLen;
+	canXOF = false;
+	padOffset;
+	isLE;
+	buffer;
+	view;
+	finished = false;
+	length = 0;
+	pos = 0;
+	destroyed = false;
+	constructor(blockLen, outputLen, padOffset, isLE) {
+		this.blockLen = blockLen;
+		this.outputLen = outputLen;
+		this.padOffset = padOffset;
+		this.isLE = isLE;
+		this.buffer = new Uint8Array(blockLen);
+		this.view = createView(this.buffer);
+	}
+	update(data) {
+		aexists(this);
+		abytes(data);
+		const { view, buffer, blockLen } = this;
+		const len = data.length;
+		for (let pos = 0; pos < len;) {
+			const take = Math.min(blockLen - this.pos, len - pos);
+			if (take === blockLen) {
+				const dataView = createView(data);
+				for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
+				continue;
+			}
+			buffer.set(data.subarray(pos, pos + take), this.pos);
+			this.pos += take;
+			pos += take;
+			if (this.pos === blockLen) {
+				this.process(view, 0);
+				this.pos = 0;
+			}
+		}
+		this.length += data.length;
+		this.roundClean();
+		return this;
+	}
+	digestInto(out) {
+		aexists(this);
+		aoutput(out, this);
+		this.finished = true;
+		const { buffer, view, blockLen, isLE } = this;
+		let { pos } = this;
+		buffer[pos++] = 128;
+		clean(this.buffer.subarray(pos));
+		if (this.padOffset > blockLen - pos) {
+			this.process(view, 0);
+			pos = 0;
+		}
+		for (let i = pos; i < blockLen; i++) buffer[i] = 0;
+		view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+		this.process(view, 0);
+		const oview = createView(out);
+		const len = this.outputLen;
+		if (len % 4) throw new Error("_sha2: outputLen must be aligned to 32bit");
+		const outLen = len / 4;
+		const state = this.get();
+		if (outLen > state.length) throw new Error("_sha2: outputLen bigger than state");
+		for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
+	}
+	digest() {
+		const { buffer, outputLen } = this;
+		this.digestInto(buffer);
+		const res = buffer.slice(0, outputLen);
+		this.destroy();
+		return res;
+	}
+	_cloneInto(to) {
+		to ||= new this.constructor();
+		to.set(...this.get());
+		const { blockLen, buffer, length, finished, destroyed, pos } = this;
+		to.destroyed = destroyed;
+		to.finished = finished;
+		to.length = length;
+		to.pos = pos;
+		if (length % blockLen) to.buffer.set(buffer);
+		return to;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+};
+/** Initial SHA512 state from RFC 6234 §6.3: eight RFC 64-bit `H(0)` words stored as sixteen
+* big-endian 32-bit halves. Derived from the fractional parts of the square roots of the first
+* eight prime numbers. Exported as a shared table; callers must treat it as read-only because
+* constructors copy halves from it by index. */
+const SHA512_IV = /* @__PURE__ */ Uint32Array.from([
+	1779033703,
+	4089235720,
+	3144134277,
+	2227873595,
+	1013904242,
+	4271175723,
+	2773480762,
+	1595750129,
+	1359893119,
+	2917565137,
+	2600822924,
+	725511199,
+	528734635,
+	4215389547,
+	1541459225,
+	327033209
+]);
+
+//#endregion
+//#region node_modules/@noble/hashes/_u64.js
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+	if (le) return {
+		h: Number(n & U32_MASK64),
+		l: Number(n >> _32n & U32_MASK64)
+	};
+	return {
+		h: Number(n >> _32n & U32_MASK64) | 0,
+		l: Number(n & U32_MASK64) | 0
+	};
+}
+function split(lst, le = false) {
+	const len = lst.length;
+	let Ah = new Uint32Array(len);
+	let Al = new Uint32Array(len);
+	for (let i = 0; i < len; i++) {
+		const { h, l } = fromBig(lst[i], le);
+		[Ah[i], Al[i]] = [h, l];
+	}
+	return [Ah, Al];
+}
+const shrSH = (h, _l, s) => h >>> s;
+const shrSL = (h, l, s) => h << 32 - s | l >>> s;
+const rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+const rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+const rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+const rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+function add(Ah, Al, Bh, Bl) {
+	const l = (Al >>> 0) + (Bl >>> 0);
+	return {
+		h: Ah + Bh + (l / 2 ** 32 | 0) | 0,
+		l: l | 0
+	};
+}
+const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+const add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+const add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+const add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+
+//#endregion
+//#region node_modules/@noble/hashes/sha2.js
+/**
+* SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
+* SHA256 is the fastest hash implementable in JS, even faster than Blake3.
+* Check out {@link https://www.rfc-editor.org/rfc/rfc4634 | RFC 4634} and
+* {@link https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf | FIPS 180-4}.
+* @module
+*/
+const K512 = split([
+	"0x428a2f98d728ae22",
+	"0x7137449123ef65cd",
+	"0xb5c0fbcfec4d3b2f",
+	"0xe9b5dba58189dbbc",
+	"0x3956c25bf348b538",
+	"0x59f111f1b605d019",
+	"0x923f82a4af194f9b",
+	"0xab1c5ed5da6d8118",
+	"0xd807aa98a3030242",
+	"0x12835b0145706fbe",
+	"0x243185be4ee4b28c",
+	"0x550c7dc3d5ffb4e2",
+	"0x72be5d74f27b896f",
+	"0x80deb1fe3b1696b1",
+	"0x9bdc06a725c71235",
+	"0xc19bf174cf692694",
+	"0xe49b69c19ef14ad2",
+	"0xefbe4786384f25e3",
+	"0x0fc19dc68b8cd5b5",
+	"0x240ca1cc77ac9c65",
+	"0x2de92c6f592b0275",
+	"0x4a7484aa6ea6e483",
+	"0x5cb0a9dcbd41fbd4",
+	"0x76f988da831153b5",
+	"0x983e5152ee66dfab",
+	"0xa831c66d2db43210",
+	"0xb00327c898fb213f",
+	"0xbf597fc7beef0ee4",
+	"0xc6e00bf33da88fc2",
+	"0xd5a79147930aa725",
+	"0x06ca6351e003826f",
+	"0x142929670a0e6e70",
+	"0x27b70a8546d22ffc",
+	"0x2e1b21385c26c926",
+	"0x4d2c6dfc5ac42aed",
+	"0x53380d139d95b3df",
+	"0x650a73548baf63de",
+	"0x766a0abb3c77b2a8",
+	"0x81c2c92e47edaee6",
+	"0x92722c851482353b",
+	"0xa2bfe8a14cf10364",
+	"0xa81a664bbc423001",
+	"0xc24b8b70d0f89791",
+	"0xc76c51a30654be30",
+	"0xd192e819d6ef5218",
+	"0xd69906245565a910",
+	"0xf40e35855771202a",
+	"0x106aa07032bbd1b8",
+	"0x19a4c116b8d2d0c8",
+	"0x1e376c085141ab53",
+	"0x2748774cdf8eeb99",
+	"0x34b0bcb5e19b48a8",
+	"0x391c0cb3c5c95a63",
+	"0x4ed8aa4ae3418acb",
+	"0x5b9cca4f7763e373",
+	"0x682e6ff3d6b2b8a3",
+	"0x748f82ee5defb2fc",
+	"0x78a5636f43172f60",
+	"0x84c87814a1f0ab72",
+	"0x8cc702081a6439ec",
+	"0x90befffa23631e28",
+	"0xa4506cebde82bde9",
+	"0xbef9a3f7b2c67915",
+	"0xc67178f2e372532b",
+	"0xca273eceea26619c",
+	"0xd186b8c721c0c207",
+	"0xeada7dd6cde0eb1e",
+	"0xf57d4f7fee6ed178",
+	"0x06f067aa72176fba",
+	"0x0a637dc5a2c898a6",
+	"0x113f9804bef90dae",
+	"0x1b710b35131c471b",
+	"0x28db77f523047d84",
+	"0x32caab7b40c72493",
+	"0x3c9ebe0a15c9bebc",
+	"0x431d67c49c100d4c",
+	"0x4cc5d4becb3e42b6",
+	"0x597f299cfc657e2a",
+	"0x5fcb6fab3ad6faec",
+	"0x6c44198c4a475817"
+].map((n) => BigInt(n)));
+const SHA512_Kh = K512[0];
+const SHA512_Kl = K512[1];
+const SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+const SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+/** Internal SHA-384 / SHA-512 compression engine from RFC 6234 §6.4. */
+var SHA2_64B = class extends HashMD {
+	constructor(outputLen) {
+		super(128, outputLen, 16, false);
+	}
+	get() {
+		const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+		return [
+			Ah,
+			Al,
+			Bh,
+			Bl,
+			Ch,
+			Cl,
+			Dh,
+			Dl,
+			Eh,
+			El,
+			Fh,
+			Fl,
+			Gh,
+			Gl,
+			Hh,
+			Hl
+		];
+	}
+	set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+		this.Ah = Ah | 0;
+		this.Al = Al | 0;
+		this.Bh = Bh | 0;
+		this.Bl = Bl | 0;
+		this.Ch = Ch | 0;
+		this.Cl = Cl | 0;
+		this.Dh = Dh | 0;
+		this.Dl = Dl | 0;
+		this.Eh = Eh | 0;
+		this.El = El | 0;
+		this.Fh = Fh | 0;
+		this.Fl = Fl | 0;
+		this.Gh = Gh | 0;
+		this.Gl = Gl | 0;
+		this.Hh = Hh | 0;
+		this.Hl = Hl | 0;
+	}
+	process(view, offset) {
+		for (let i = 0; i < 16; i++, offset += 4) {
+			SHA512_W_H[i] = view.getUint32(offset);
+			SHA512_W_L[i] = view.getUint32(offset += 4);
+		}
+		for (let i = 16; i < 80; i++) {
+			const W15h = SHA512_W_H[i - 15] | 0;
+			const W15l = SHA512_W_L[i - 15] | 0;
+			const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
+			const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
+			const W2h = SHA512_W_H[i - 2] | 0;
+			const W2l = SHA512_W_L[i - 2] | 0;
+			const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
+			const s1l = rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6);
+			const SUMl = add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+			SHA512_W_H[i] = add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]) | 0;
+			SHA512_W_L[i] = SUMl | 0;
+		}
+		let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+		for (let i = 0; i < 80; i++) {
+			const sigma1h = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
+			const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
+			const CHIh = Eh & Fh ^ ~Eh & Gh;
+			const CHIl = El & Fl ^ ~El & Gl;
+			const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+			const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+			const T1l = T1ll | 0;
+			const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
+			const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(Ah, Al, 39);
+			const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
+			const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
+			Hh = Gh | 0;
+			Hl = Gl | 0;
+			Gh = Fh | 0;
+			Gl = Fl | 0;
+			Fh = Eh | 0;
+			Fl = El | 0;
+			({h: Eh, l: El} = add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+			Dh = Ch | 0;
+			Dl = Cl | 0;
+			Ch = Bh | 0;
+			Cl = Bl | 0;
+			Bh = Ah | 0;
+			Bl = Al | 0;
+			const All = add3L(T1l, sigma0l, MAJl);
+			Ah = add3H(All, T1h, sigma0h, MAJh);
+			Al = All | 0;
+		}
+		({h: Ah, l: Al} = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+		({h: Bh, l: Bl} = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+		({h: Ch, l: Cl} = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+		({h: Dh, l: Dl} = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+		({h: Eh, l: El} = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+		({h: Fh, l: Fl} = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+		({h: Gh, l: Gl} = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+		({h: Hh, l: Hl} = add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+		this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+	}
+	roundClean() {
+		clean(SHA512_W_H, SHA512_W_L);
+	}
+	destroy() {
+		this.destroyed = true;
+		clean(this.buffer);
+		this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+	}
+};
+/** Internal SHA-512 hash class grounded in RFC 6234 §6.3 and §6.4. */
+var _SHA512 = class extends SHA2_64B {
+	Ah = SHA512_IV[0] | 0;
+	Al = SHA512_IV[1] | 0;
+	Bh = SHA512_IV[2] | 0;
+	Bl = SHA512_IV[3] | 0;
+	Ch = SHA512_IV[4] | 0;
+	Cl = SHA512_IV[5] | 0;
+	Dh = SHA512_IV[6] | 0;
+	Dl = SHA512_IV[7] | 0;
+	Eh = SHA512_IV[8] | 0;
+	El = SHA512_IV[9] | 0;
+	Fh = SHA512_IV[10] | 0;
+	Fl = SHA512_IV[11] | 0;
+	Gh = SHA512_IV[12] | 0;
+	Gl = SHA512_IV[13] | 0;
+	Hh = SHA512_IV[14] | 0;
+	Hl = SHA512_IV[15] | 0;
+	constructor() {
+		super(64);
+	}
+};
+/**
+* SHA2-512 hash function from RFC 4634.
+* @param msg - message bytes to hash
+* @returns Digest bytes.
+* @example
+* Hash a message with SHA2-512.
+* ```ts
+* sha512(new Uint8Array([97, 98, 99]));
+* ```
+*/
+const sha512 = /* @__PURE__ */ createHasher(() => new _SHA512(), /* @__PURE__ */ oidNist(3));
+
+//#endregion
+//#region packages/orchestrator/src/crypto.ts
+/**
+* Ed25519 key generation, persistence, and challenge signing for actor auth.
+* Copied from packages/mcp/src/crypto.ts
+*/
+ed.hashes.sha512 = sha512;
+ed.hashes.sha512Async = (m) => Promise.resolve(sha512(m));
+function toBase64url(bytes) {
+	return Buffer.from(bytes).toString("base64url");
+}
+function fromBase64url(b64) {
+	return new Uint8Array(Buffer.from(b64, "base64url"));
+}
+/**
+* Load an existing Ed25519 keypair from disk, or generate and persist a new one.
+*/
+async function loadOrCreateKeypair(keyPath) {
+	if (existsSync(keyPath)) {
+		const seed = await readFile(keyPath);
+		if (seed.length !== 32) throw new Error(`Invalid key file at ${keyPath}: expected 32 bytes, got ${seed.length}`);
+		const privateKey = new Uint8Array(seed);
+		return {
+			privateKey,
+			publicKeyB64: toBase64url(ed.getPublicKey(privateKey))
+		};
+	}
+	const privateKey = ed.utils.randomSecretKey();
+	const publicKey = ed.getPublicKey(privateKey);
+	const dir = dirname(keyPath);
+	if (!existsSync(dir)) await mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	await writeFile(keyPath, Buffer.from(privateKey), { mode: 384 });
+	console.error(`[orchestrator] Generated new keypair at ${keyPath}`);
+	return {
+		privateKey,
+		publicKeyB64: toBase64url(publicKey)
+	};
+}
+/**
+* Generate a deterministic Ed25519 keypair from a seed string (e.g. actor name).
+* The same seed always produces the same keypair.
+*/
+function deterministicKeypair(seed) {
+	const privateKey = sha512(new TextEncoder().encode(seed + ":orchestrator-salt")).slice(0, 32);
+	return {
+		privateKey,
+		publicKeyB64: toBase64url(ed.getPublicKey(privateKey))
+	};
+}
+/** Sign a base64url challenge with the agent's private key; returns base64url signature. */
+function signChallenge(challengeB64, privateKey) {
+	const challenge = fromBase64url(challengeB64);
+	return toBase64url(ed.sign(challenge, privateKey));
+}
+
+//#endregion
+//#region packages/orchestrator/src/utils.ts
+/**
+* Utility functions for the orchestrator.
+*/
+/** Wait for a provider's `synced` event with a timeout. Resolves immediately if already synced. */
+function waitForSync(provider, timeoutMs = 15e3) {
+	if (provider.synced) return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			provider.off("synced", handler);
+			reject(/* @__PURE__ */ new Error(`Sync timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+		function handler() {
+			clearTimeout(timer);
+			resolve();
+		}
+		provider.on("synced", handler);
+	});
+}
+/** Sleep for a given number of milliseconds. */
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Log to stderr with [orchestrator] prefix. */
+function log(msg) {
+	console.error(`[orchestrator] ${msg}`);
+}
+
+//#endregion
+//#region packages/orchestrator/src/yjs-utils.ts
+/**
+* Y.js document structure utilities for TipTap-compatible editing.
+*
+* TipTap documents have the structure:
+*   XmlFragment('default') → [documentHeader, documentMeta, ...body paragraphs]
+*
+* All text position functions skip documentHeader and documentMeta —
+* character index 0 maps to the first character of the first body paragraph.
+*/
+const SCHEMA_NODES = new Set(["documentHeader", "documentMeta"]);
+/** Check if an XmlElement is a TipTap schema node (not body content). */
+function isSchemaNode(el) {
+	return SCHEMA_NODES.has(el.nodeName);
+}
+/**
+* Ensure the fragment has documentHeader and documentMeta nodes.
+* Creates them if missing. Idempotent — safe to call multiple times.
+*/
+function ensureDocumentStructure(fragment) {
+	let hasHeader = false;
+	let hasMeta = false;
+	for (let i = 0; i < fragment.length; i++) {
+		const child = fragment.get(i);
+		if (child instanceof Y.XmlElement) {
+			if (child.nodeName === "documentHeader") hasHeader = true;
+			if (child.nodeName === "documentMeta") hasMeta = true;
+		}
+	}
+	if (!hasMeta) {
+		const meta = new Y.XmlElement("documentMeta");
+		fragment.insert(hasHeader ? 1 : 0, [meta]);
+	}
+	if (!hasHeader) {
+		const header = new Y.XmlElement("documentHeader");
+		fragment.insert(0, [header]);
+	}
+}
+/**
+* Find the index where body content starts (after documentHeader + documentMeta).
+*/
+function bodyStartIndex(fragment) {
+	let idx = 0;
+	for (let i = 0; i < fragment.length; i++) {
+		const child = fragment.get(i);
+		if (child instanceof Y.XmlElement && isSchemaNode(child)) idx = i + 1;
+		else break;
+	}
+	return idx;
+}
+/**
+* Walk the XmlFragment body (skipping schema nodes) to find the XmlText node
+* and local offset for a given global character index.
+*/
+function findTextPosition(fragment, globalIndex) {
+	let consumed = 0;
+	for (let i = 0; i < fragment.length; i++) {
+		const child = fragment.get(i);
+		if (child instanceof Y.XmlElement) {
+			if (isSchemaNode(child)) continue;
+			const result = findTextInElement(child, globalIndex - consumed);
+			if (result) return result;
+			consumed += elementTextLength(child);
+		}
+	}
+	return null;
+}
+function findTextInElement(el, remaining) {
+	for (let i = 0; i < el.length; i++) {
+		const child = el.get(i);
+		if (child instanceof Y.XmlText) {
+			if (remaining <= child.length) return {
+				text: child,
+				offset: remaining
+			};
+			remaining -= child.length;
+		} else if (child instanceof Y.XmlElement) {
+			const result = findTextInElement(child, remaining);
+			if (result) return result;
+			remaining -= elementTextLength(child);
+		}
+	}
+	return null;
+}
+/** Total text length of an XmlElement (recursive). */
+function elementTextLength(el) {
+	let len = 0;
+	for (let i = 0; i < el.length; i++) {
+		const child = el.get(i);
+		if (child instanceof Y.XmlText) len += child.length;
+		else if (child instanceof Y.XmlElement) len += elementTextLength(child);
+	}
+	return len;
+}
+/** Total text length of all body paragraphs (skips schema nodes). */
+function fragmentTextLength(fragment) {
+	let len = 0;
+	for (let i = 0; i < fragment.length; i++) {
+		const child = fragment.get(i);
+		if (child instanceof Y.XmlElement && !isSchemaNode(child)) len += elementTextLength(child);
+	}
+	return len;
+}
+/**
+* Compute the global character index of a position within a known XmlText node.
+* Re-derives from current document state — safe under concurrent edits.
+* Only counts body content (skips schema nodes).
+*/
+function globalIndexOf(fragment, targetText, localOffset) {
+	let index = 0;
+	for (let i = 0; i < fragment.length; i++) {
+		const child = fragment.get(i);
+		if (child instanceof Y.XmlElement) {
+			if (isSchemaNode(child)) continue;
+			const result = globalIndexInElement(child, targetText, localOffset, index);
+			if (result !== null) return result;
+			index += elementTextLength(child);
+		}
+	}
+	return index + localOffset;
+}
+function globalIndexInElement(el, targetText, localOffset, base) {
+	for (let i = 0; i < el.length; i++) {
+		const child = el.get(i);
+		if (child instanceof Y.XmlText) {
+			if (child === targetText) return base + localOffset;
+			base += child.length;
+		} else if (child instanceof Y.XmlElement) {
+			const result = globalIndexInElement(child, targetText, localOffset, base);
+			if (result !== null) return result;
+			base += elementTextLength(child);
+		}
+	}
+	return null;
+}
+/**
+* Get or create the last body paragraph's XmlText.
+* Skips documentHeader and documentMeta. Creates a new paragraph if none exist.
+*/
+function getOrCreateLastParagraph(fragment) {
+	for (let i = fragment.length - 1; i >= 0; i--) {
+		const child = fragment.get(i);
+		if (child instanceof Y.XmlElement) {
+			if (isSchemaNode(child)) continue;
+			if (child.nodeName === "paragraph") {
+				for (let j = child.length - 1; j >= 0; j--) {
+					const grandchild = child.get(j);
+					if (grandchild instanceof Y.XmlText) return {
+						text: grandchild,
+						globalOffset: fragmentTextLength(fragment)
+					};
+				}
+				const xt = new Y.XmlText();
+				child.insert(0, [xt]);
+				return {
+					text: xt,
+					globalOffset: fragmentTextLength(fragment)
+				};
+			}
+		}
+	}
+	const para = new Y.XmlElement("paragraph");
+	const xt = new Y.XmlText();
+	para.insert(0, [xt]);
+	fragment.push([para]);
+	return {
+		text: xt,
+		globalOffset: 0
+	};
+}
+/**
+* Insert a new paragraph after the one containing the given global character index.
+* Skips schema nodes when computing positions.
+*/
+function insertParagraphAfter(fragment, afterGlobalIndex) {
+	let offset = 0;
+	let insertAt = fragment.length;
+	for (let i = 0; i < fragment.length; i++) {
+		const child = fragment.get(i);
+		if (child instanceof Y.XmlElement) {
+			if (isSchemaNode(child)) continue;
+			const elLen = elementTextLength(child);
+			if (offset + elLen >= afterGlobalIndex) {
+				insertAt = i + 1;
+				break;
+			}
+			offset += elLen;
+		}
+	}
+	const para = new Y.XmlElement("paragraph");
+	const xt = new Y.XmlText();
+	para.insert(0, [xt]);
+	fragment.insert(insertAt, [para]);
+	return xt;
+}
+
+//#endregion
+//#region packages/orchestrator/src/actor-connection.ts
+/**
+* ActorConnection — manages a single actor's connection to the Abracadabra server.
+* One instance per actor. Handles auth, providers, child caching, awareness, and cursors.
+*/
+var ActorConnection = class {
+	constructor(actor, serverConfig) {
+		this._rootDocId = null;
+		this._rootDoc = null;
+		this._rootProvider = null;
+		this._publicKey = null;
+		this._childCache = /* @__PURE__ */ new Map();
+		this.actor = actor;
+		this.client = new AbracadabraClient({ url: serverConfig.url.replace(/^wss:\/\//, "https://").replace(/^ws:\/\//, "http://") });
+	}
+	get rootProvider() {
+		return this._rootProvider;
+	}
+	get rootDocId() {
+		return this._rootDocId;
+	}
+	/** Connect, authenticate, discover root doc, sync, and set awareness. */
+	async connect(serverConfig) {
+		const keypair = this.actor.keyFile ? await loadOrCreateKeypair(this.actor.keyFile) : deterministicKeypair(this.actor.name);
+		this._publicKey = keypair.publicKeyB64;
+		const signFn = (challenge) => Promise.resolve(signChallenge(challenge, keypair.privateKey));
+		try {
+			await this.client.loginWithKey(keypair.publicKeyB64, signFn);
+		} catch (err) {
+			const status = err?.status ?? err?.response?.status;
+			if (status === 404 || status === 422) {
+				log(`${this.actor.name}: registering new account...`);
+				await this.client.registerWithKey({
+					publicKey: keypair.publicKeyB64,
+					username: this.actor.name.replace(/\s+/g, "-").toLowerCase(),
+					displayName: this.actor.name,
+					deviceName: "Orchestrator Actor",
+					inviteCode: serverConfig.inviteCode
+				});
+				await this.client.loginWithKey(keypair.publicKeyB64, signFn);
+			} else throw err;
+		}
+		log(`${this.actor.name}: authenticated (${keypair.publicKeyB64.slice(0, 12)}...)`);
+		const roots = await this.client.listChildren();
+		const rootDocId = (roots.find((d) => d.kind === "space") ?? roots[0])?.id ?? null;
+		if (!rootDocId) throw new Error(`${this.actor.name}: no root document found`);
+		this._rootDocId = rootDocId;
+		const doc = new Y.Doc({ guid: rootDocId });
+		const provider = new AbracadabraProvider({
+			name: rootDocId,
+			document: doc,
+			client: this.client,
+			disableOfflineStore: true,
+			subdocLoading: "lazy"
+		});
+		await waitForSync(provider);
+		this._rootDoc = doc;
+		this._rootProvider = provider;
+		provider.awareness.setLocalStateField("user", {
+			name: this.actor.name,
+			color: this.actor.color,
+			publicKey: this._publicKey,
+			isAgent: false
+		});
+		provider.awareness.setLocalStateField("status", null);
+		log(`${this.actor.name}: connected to space ${rootDocId}`);
+	}
+	/** Get or create a child provider for a document. Caches and sets awareness. */
+	async getChildProvider(docId) {
+		const cached = this._childCache.get(docId);
+		if (cached) {
+			cached.lastAccessed = Date.now();
+			return cached.provider;
+		}
+		if (!this._rootProvider) throw new Error(`${this.actor.name}: not connected`);
+		const childProvider = await this._rootProvider.loadChild(docId);
+		await waitForSync(childProvider);
+		childProvider.awareness.setLocalStateField("user", {
+			name: this.actor.name,
+			color: this.actor.color,
+			publicKey: this._publicKey,
+			isAgent: false
+		});
+		this._childCache.set(docId, {
+			provider: childProvider,
+			lastAccessed: Date.now()
+		});
+		return childProvider;
+	}
+	/**
+	* Set cursor position in a document (collapsed — anchor = head).
+	*
+	* TipTap's yCursorPlugin reads awareness field 'cursor' as
+	* { anchor: RelativePosJSON, head: RelativePosJSON }.
+	* Positions must point into XmlText nodes (not the fragment) with assoc=-1.
+	*/
+	setCursor(docId, index) {
+		const cached = this._childCache.get(docId);
+		if (!cached) return;
+		const fragment = cached.provider.document.getXmlFragment("default");
+		const relPos = this._charIndexToRelativePosition(fragment, index);
+		if (!relPos) return;
+		const json = Y.relativePositionToJSON(relPos);
+		cached.provider.awareness.setLocalStateField("cursor", {
+			anchor: json,
+			head: json
+		});
+	}
+	/** Set text selection range in a document (anchor != head). */
+	setSelection(docId, anchor, head) {
+		const cached = this._childCache.get(docId);
+		if (!cached) return;
+		const fragment = cached.provider.document.getXmlFragment("default");
+		const anchorPos = this._charIndexToRelativePosition(fragment, anchor);
+		const headPos = this._charIndexToRelativePosition(fragment, head);
+		if (!anchorPos || !headPos) return;
+		cached.provider.awareness.setLocalStateField("cursor", {
+			anchor: Y.relativePositionToJSON(anchorPos),
+			head: Y.relativePositionToJSON(headPos)
+		});
+	}
+	/**
+	* Convert a character index (body text only, skipping schema nodes)
+	* to a Y.js RelativePosition pointing into the correct XmlText node.
+	* Uses assoc=-1 (associate-left) to match TipTap's cursor behavior.
+	*/
+	_charIndexToRelativePosition(fragment, charIndex) {
+		const totalLen = fragmentTextLength(fragment);
+		const clamped = Math.max(0, Math.min(charIndex, totalLen));
+		if (clamped === 0) return Y.createRelativePositionFromTypeIndex(fragment, 0, -1);
+		const pos = findTextPosition(fragment, clamped);
+		if (pos) return Y.createRelativePositionFromTypeIndex(pos.text, pos.offset, -1);
+		return Y.createRelativePositionFromTypeIndex(fragment, fragment.length, -1);
+	}
+	/** Set a field on root awareness. */
+	setRootAwareness(field, value) {
+		this._rootProvider?.awareness.setLocalStateField(field, value);
+	}
+	/** Set a field on a child document's awareness. */
+	setChildAwareness(docId, field, value) {
+		this._childCache.get(docId)?.provider.awareness.setLocalStateField(field, value);
+	}
+	/** Disconnect and clean up all providers. */
+	async disconnect() {
+		for (const [, cached] of this._childCache) cached.provider.awareness.setLocalStateField("cursor", null);
+		if (this._rootProvider) {
+			this._rootProvider.awareness.setLocalStateField("status", null);
+			this._rootProvider.awareness.setLocalStateField("docId", null);
+		}
+		await sleep(150);
+		for (const [, cached] of this._childCache) cached.provider.destroy();
+		this._childCache.clear();
+		if (this._rootProvider) {
+			this._rootProvider.destroy();
+			this._rootProvider = null;
+		}
+		this._rootDoc = null;
+		this._rootDocId = null;
+		log(`${this.actor.name}: disconnected`);
+	}
+};
+
+//#endregion
+//#region packages/orchestrator/src/timeline-runner.ts
+var TimelineRunner = class {
+	constructor(options) {
+		this.sceneStartTime = 0;
+		this.errors = [];
+		this.options = options ?? {};
+	}
+	/** Get elapsed ms since scene start. */
+	get elapsed() {
+		return Date.now() - this.sceneStartTime;
+	}
+	/** Execute all timeline entries in order with proper timing. */
+	async run(timeline, execute) {
+		const sorted = [...timeline].sort((a, b) => (a.at ?? 0) - (b.at ?? 0));
+		const errorStrategy = this.options.onError ?? "log";
+		this.sceneStartTime = Date.now();
+		const pending = [];
+		for (let i = 0; i < sorted.length; i++) {
+			const entry = sorted[i];
+			const targetTime = entry.at ?? 0;
+			const delay = targetTime - (Date.now() - this.sceneStartTime);
+			if (delay > 0) await sleep(delay);
+			log(`[${`${((Date.now() - this.sceneStartTime) / 1e3).toFixed(1)}s`}] ${entry.actor ?? "—"}: ${entry.action.type}`);
+			const actionPromise = execute(entry).catch((err) => {
+				const errorInfo = {
+					entry,
+					error: err,
+					elapsed: Date.now() - this.sceneStartTime
+				};
+				this.errors.push(errorInfo);
+				log(`Error in ${entry.action.type}${entry.actor ? ` for ${entry.actor}` : ""}: ${err.message}`);
+				if (errorStrategy === "abort") throw err;
+			});
+			const nextEntry = sorted[i + 1];
+			if (nextEntry && (nextEntry.at ?? 0) === targetTime) pending.push(actionPromise);
+			else {
+				pending.push(actionPromise);
+				await Promise.all(pending);
+				pending.length = 0;
+			}
+		}
+		if (pending.length) await Promise.all(pending);
+		if (this.errors.length) log(`Timeline finished with ${this.errors.length} error(s)`);
+	}
+};
+
+//#endregion
+//#region packages/orchestrator/src/actions/connect.ts
+async function executeConnect(actor, serverConfig) {
+	await actor.connect(serverConfig);
+}
+async function executeDisconnect(actor) {
+	await actor.disconnect();
+}
+
+//#endregion
+//#region packages/orchestrator/src/actions/navigate.ts
+async function executeNavigate(actor, action) {
+	actor.setRootAwareness("docId", action.docId);
+	await actor.getChildProvider(action.docId);
+}
+
+//#endregion
+//#region packages/orchestrator/src/actions/type.ts
+async function executeType(actor, action) {
+	const speed = action.speed ?? 80;
+	const variance = action.variance ?? 30;
+	const doc = (await actor.getChildProvider(action.docId)).document;
+	const fragment = doc.getXmlFragment("default");
+	doc.transact(() => ensureDocumentStructure(fragment));
+	const startIndex = action.position ?? fragmentTextLength(fragment);
+	let currentText;
+	let currentLocalOffset;
+	const pos = findTextPosition(fragment, startIndex);
+	if (pos) {
+		currentText = pos.text;
+		currentLocalOffset = pos.offset;
+	} else {
+		currentText = getOrCreateLastParagraph(fragment).text;
+		currentLocalOffset = currentText.length;
+	}
+	for (const char of action.text) {
+		await sleep(Math.max(10, speed + (Math.random() * 2 - 1) * variance));
+		if (char === "\n") {
+			const globalIdx = globalIndexOf(fragment, currentText, currentLocalOffset);
+			doc.transact(() => {
+				currentText = insertParagraphAfter(fragment, globalIdx);
+				currentLocalOffset = 0;
+			});
+		} else {
+			doc.transact(() => {
+				currentText.insert(currentLocalOffset, char);
+			});
+			currentLocalOffset++;
+		}
+		const cursorGlobal = globalIndexOf(fragment, currentText, currentLocalOffset);
+		actor.setCursor(action.docId, cursorGlobal);
+	}
+}
+async function executeTypeDelete(actor, action) {
+	const speed = action.speed ?? 60;
+	const variance = action.variance ?? 20;
+	const doc = (await actor.getChildProvider(action.docId)).document;
+	const fragment = doc.getXmlFragment("default");
+	const startIndex = action.position ?? fragmentTextLength(fragment);
+	let remaining = action.count;
+	while (remaining > 0) {
+		await sleep(Math.max(10, speed + (Math.random() * 2 - 1) * variance));
+		const deleteAt = Math.max(0, startIndex - (action.count - remaining) - 1);
+		const pos = findTextPosition(fragment, deleteAt);
+		if (!pos || deleteAt < 0) break;
+		doc.transact(() => {
+			if (pos.offset > 0) pos.text.delete(pos.offset - 1, 1);
+		});
+		remaining--;
+		actor.setCursor(action.docId, Math.max(0, deleteAt));
+	}
+}
+
+//#endregion
+//#region packages/orchestrator/src/easing.ts
+const easings = {
+	linear: (t) => t,
+	easeIn: (t) => t * t,
+	easeOut: (t) => t * (2 - t),
+	easeInOut: (t) => t < .5 ? 2 * t * t : -1 + (4 - 2 * t) * t
+};
+function getEasing(name) {
+	return easings[name ?? "easeInOut"];
+}
+
+//#endregion
+//#region packages/orchestrator/src/actions/cursor.ts
+async function executeMoveCursor(actor, action) {
+	const easing = getEasing(action.easing);
+	const steps = Math.max(1, Math.round(action.duration / 16));
+	const stepDuration = action.duration / steps;
+	for (let i = 0; i <= steps; i++) {
+		const t = easing(i / steps);
+		const pos = Math.round(action.from + (action.to - action.from) * t);
+		actor.setCursor(action.docId, pos);
+		if (i < steps) await sleep(stepDuration);
+	}
+}
+async function executeSelect(actor, action) {
+	actor.setSelection(action.docId, action.anchor, action.head);
+}
+
+//#endregion
+//#region packages/orchestrator/src/converters/markdownToYjs.ts
+/**
+* Markdown → Y.js converter.
+* Ported from cou-sh/app/utils/markdownToYjs.ts with Vue dependency removed.
+*/
+function parseInline(text) {
+	const stripped = text.replace(/\{lang="[^"]*"\}/g, "").replace(/:(?!badge|icon|kbd)(\w[\w-]*)\[([^\]]*)\](\{[^}]*\})?/g, "$2").replace(/:(?!badge|icon|kbd)(\w[\w-]*)(\{[^}]*\})/g, "");
+	const tokens = [];
+	const re = /:badge\[([^\]]*)\](\{[^}]*\})?|:icon\{([^}]*)\}|:kbd\{([^}]*)\}|!?\[\[([^\]|]+?)(?:\|([^\]]+?))?\]\]|~~(.+?)~~|\*\*(.+?)\*\*|\*(.+?)\*|_(.+?)_|`(.+?)`|\[(.+?)\]\((.+?)\)/g;
+	let lastIndex = 0;
+	let match;
+	while ((match = re.exec(stripped)) !== null) {
+		if (match.index > lastIndex) tokens.push({ text: stripped.slice(lastIndex, match.index) });
+		if (match[1] !== void 0) {
+			const badgeProps = parseMdcProps(match[2]);
+			tokens.push({
+				text: match[1] || "Badge",
+				attrs: { badge: {
+					label: match[1] || "Badge",
+					color: badgeProps["color"] || "neutral",
+					variant: badgeProps["variant"] || "subtle"
+				} }
+			});
+		} else if (match[3] !== void 0) {
+			const iconProps = parseMdcProps(`{${match[3]}}`);
+			tokens.push({
+				text: "​",
+				attrs: { proseIcon: { name: iconProps["name"] || "i-lucide-star" } }
+			});
+		} else if (match[4] !== void 0) {
+			const kbdProps = parseMdcProps(`{${match[4]}}`);
+			tokens.push({
+				text: kbdProps["value"] || "",
+				attrs: { kbd: { value: kbdProps["value"] || "" } }
+			});
+		} else if (match[5] !== void 0) tokens.push({
+			text: "",
+			node: "docLink",
+			nodeAttrs: { docId: match[5] }
+		});
+		else if (match[7] !== void 0) tokens.push({
+			text: match[7],
+			attrs: { strike: true }
+		});
+		else if (match[8] !== void 0) tokens.push({
+			text: match[8],
+			attrs: { bold: true }
+		});
+		else if (match[9] !== void 0) tokens.push({
+			text: match[9],
+			attrs: { italic: true }
+		});
+		else if (match[10] !== void 0) tokens.push({
+			text: match[10],
+			attrs: { italic: true }
+		});
+		else if (match[11] !== void 0) tokens.push({
+			text: match[11],
+			attrs: { code: true }
+		});
+		else if (match[12] !== void 0 && match[13] !== void 0) tokens.push({
+			text: match[12],
+			attrs: { link: { href: match[13] } }
+		});
+		lastIndex = match.index + match[0].length;
+	}
+	if (lastIndex < stripped.length) tokens.push({ text: stripped.slice(lastIndex) });
+	return tokens.filter((t) => t.node || t.text.length > 0);
+}
+function parseTableRow(line) {
+	const parts = line.split("|");
+	return parts.slice(1, parts.length - 1).map((c) => c.trim());
+}
+function isTableSeparator(line) {
+	return /^\|[\s|:-]+\|$/.test(line.trim());
+}
+function extractFencedCode(lines) {
+	const result = [];
+	let i = 0;
+	while (i < lines.length) {
+		const fenceMatch = lines[i].match(/^(`{3,})(\w*)/);
+		if (fenceMatch) {
+			const fence = fenceMatch[1];
+			const lang = fenceMatch[2] ?? "";
+			const codeLines = [];
+			i++;
+			while (i < lines.length && !lines[i].startsWith(fence)) {
+				codeLines.push(lines[i]);
+				i++;
+			}
+			i++;
+			result.push({
+				type: "codeBlock",
+				lang,
+				code: codeLines.join("\n")
+			});
+			continue;
+		}
+		i++;
+	}
+	return result;
+}
+function parseMdcProps(propsStr) {
+	if (!propsStr) return {};
+	const result = {};
+	const re = /(\w[\w-]*)="([^"]*)"/g;
+	let m;
+	while ((m = re.exec(propsStr)) !== null) result[m[1]] = m[2];
+	return result;
+}
+function parseMdcChildren(innerLines, slotPrefix) {
+	const items = [];
+	let current = null;
+	const slotRe = new RegExp(`^#${slotPrefix}(\\{[^}]*\\})?\\s*$`);
+	for (const line of innerLines) {
+		const slotMatch = line.match(slotRe);
+		if (slotMatch) {
+			if (current) items.push(current);
+			const props = parseMdcProps(slotMatch[1]);
+			current = {
+				label: props["label"] || props["title"] || `Item ${items.length + 1}`,
+				icon: props["icon"] || "",
+				lines: []
+			};
+			continue;
+		}
+		if (current) current.lines.push(line);
+		else if (!items.length && !current) current = {
+			label: `Item 1`,
+			icon: "",
+			lines: [line]
+		};
+	}
+	if (current) items.push(current);
+	return items.map((item) => ({
+		label: item.label,
+		icon: item.icon,
+		innerBlocks: parseBlocks(item.lines.join("\n"))
+	}));
+}
+const TASK_RE = /^[-*+]\s+\[([ xX])\]\s+(.*)/;
+function parseBlocks(markdown) {
+	const rawLines = markdown.split("\n");
+	let firstContentLine = 0;
+	while (firstContentLine < rawLines.length) {
+		const l = rawLines[firstContentLine];
+		if (l.trim() === "" || /^import\s/.test(l) || /^export\s/.test(l)) firstContentLine++;
+		else break;
+	}
+	const stripped = rawLines.slice(firstContentLine).join("\n");
+	const blocks = [];
+	const lines = stripped.split("\n");
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		const fenceBlockMatch = line.match(/^(`{3,})(.*)$/);
+		if (fenceBlockMatch) {
+			const fence = fenceBlockMatch[1];
+			const lang = fenceBlockMatch[2].trim().replace(/\{[^}]*\}$/, "").replace(/\s*\[.*\]$/, "").trim();
+			const codeLines = [];
+			i++;
+			while (i < lines.length && !lines[i].startsWith(fence)) {
+				codeLines.push(lines[i]);
+				i++;
+			}
+			i++;
+			if (lang === "svg" || lang.startsWith("svg ")) {
+				const svgTitle = lang === "svg" ? "" : lang.slice(4).trim();
+				blocks.push({
+					type: "svgEmbed",
+					svg: codeLines.join("\n"),
+					title: svgTitle
+				});
+			} else blocks.push({
+				type: "codeBlock",
+				lang,
+				code: codeLines.join("\n")
+			});
+			continue;
+		}
+		const headingMatch = line.match(/^(#{1,6})\s+(.*)/);
+		if (headingMatch) {
+			blocks.push({
+				type: "heading",
+				level: headingMatch[1].length,
+				text: headingMatch[2].trim()
+			});
+			i++;
+			continue;
+		}
+		if (/^[-*_]{3,}\s*$/.test(line)) {
+			blocks.push({ type: "hr" });
+			i++;
+			continue;
+		}
+		const docEmbedMatch = line.match(/^!\[\[([^\]|]+?)(?:\|[^\]]*?)?\]\](\{[^}]*\})?\s*$/);
+		if (docEmbedMatch) {
+			const props = parseMdcProps(docEmbedMatch[2]);
+			const seamless = "seamless" in props || props["seamless"] === "true" || /\{[^}]*\bseamless\b[^}]*\}/.test(docEmbedMatch[2] ?? "");
+			blocks.push({
+				type: "docEmbed",
+				docId: docEmbedMatch[1],
+				seamless: seamless || void 0
+			});
+			i++;
+			continue;
+		}
+		const imgMatch = line.match(/^!\[([^\]]*)\]\(([^)]+)\)(\{[^}]*\})?\s*$/);
+		if (imgMatch) {
+			const alt = imgMatch[1] ?? "";
+			const src = imgMatch[2] ?? "";
+			const attrs = parseMdcProps(imgMatch[3]);
+			blocks.push({
+				type: "image",
+				src,
+				alt,
+				width: attrs["width"],
+				height: attrs["height"]
+			});
+			i++;
+			continue;
+		}
+		if (line.startsWith("> ") || line === ">") {
+			const bqLines = [];
+			while (i < lines.length && (lines[i].startsWith("> ") || lines[i] === ">")) {
+				bqLines.push(lines[i].replace(/^>\s?/, ""));
+				i++;
+			}
+			blocks.push({
+				type: "blockquote",
+				lines: bqLines
+			});
+			continue;
+		}
+		if (/^\s*\|/.test(line)) {
+			const tableLines = [];
+			while (i < lines.length && /^\s*\|/.test(lines[i])) {
+				tableLines.push(lines[i]);
+				i++;
+			}
+			if (tableLines.length >= 2 && isTableSeparator(tableLines[1])) {
+				const headerRow = parseTableRow(tableLines[0]);
+				const dataRows = tableLines.slice(2).filter((l) => !isTableSeparator(l)).map(parseTableRow);
+				blocks.push({
+					type: "table",
+					headerRow,
+					dataRows
+				});
+			} else for (const l of tableLines) blocks.push({
+				type: "paragraph",
+				text: l
+			});
+			continue;
+		}
+		const MDC_OPEN = /^\s*(:{2,})(\w[\w-]*)(\{[^}]*\})?\s*$/;
+		if (MDC_OPEN.test(line)) {
+			const colons = line.match(/^\s*(:+)/)?.[1]?.length ?? 2;
+			const componentName = line.match(/^\s*:{2,}(\w[\w-]*)/)?.[1] ?? "";
+			const innerLines = [];
+			i++;
+			while (i < lines.length) {
+				const l = lines[i];
+				if (new RegExp(`^\\s*:{${colons}}\\s*$`).test(l)) {
+					i++;
+					break;
+				}
+				const innerFence = l.match(/^(\s*`{3,})/);
+				if (innerFence) {
+					const fenceStr = innerFence[1].trimStart();
+					innerLines.push(l);
+					i++;
+					while (i < lines.length && !lines[i].trimStart().startsWith(fenceStr)) {
+						innerLines.push(lines[i]);
+						i++;
+					}
+					if (i < lines.length) {
+						innerLines.push(lines[i]);
+						i++;
+					}
+					continue;
+				}
+				innerLines.push(l);
+				i++;
+			}
+			const nonBlank = innerLines.filter((l) => l.trim().length > 0);
+			if (nonBlank.length) {
+				const minIndent = Math.min(...nonBlank.map((l) => l.match(/^(\s*)/)?.[1]?.length ?? 0));
+				if (minIndent > 0) for (let j = 0; j < innerLines.length; j++) innerLines[j] = innerLines[j].slice(Math.min(minIndent, innerLines[j].length));
+			}
+			let contentStart = 0;
+			if (innerLines[0]?.trim() === "---") {
+				const fmEnd = innerLines.findIndex((l, idx) => idx > 0 && l.trim() === "---");
+				if (fmEnd !== -1) contentStart = fmEnd + 1;
+			}
+			const contentLines = innerLines.slice(contentStart);
+			const defaultSlotLines = [];
+			const codeSlotLines = [];
+			let currentSlot = "default";
+			for (const l of contentLines) {
+				if (/^#code\s*$/.test(l)) {
+					currentSlot = "code";
+					continue;
+				}
+				if (/^#\w+/.test(l) && !/^#{2,}\s/.test(l)) {
+					currentSlot = "other";
+					continue;
+				}
+				if (currentSlot === "default") defaultSlotLines.push(l);
+				else if (currentSlot === "code") codeSlotLines.push(l);
+			}
+			const innerBlocks = parseBlocks(defaultSlotLines.join("\n"));
+			const codeBlocks = extractFencedCode(codeSlotLines);
+			if (new Set([
+				"tip",
+				"note",
+				"info",
+				"warning",
+				"caution",
+				"danger",
+				"callout",
+				"alert"
+			]).has(componentName.toLowerCase())) blocks.push({
+				type: "callout",
+				calloutType: componentName.toLowerCase(),
+				innerBlocks
+			});
+			else {
+				const mdcProps = parseMdcProps(line.match(MDC_OPEN)?.[3]);
+				const lc = componentName.toLowerCase();
+				if (lc === "collapsible") blocks.push({
+					type: "collapsible",
+					label: mdcProps["label"] || "Details",
+					open: mdcProps["open"] === "true",
+					innerBlocks
+				});
+				else if (lc === "steps") blocks.push({
+					type: "steps",
+					innerBlocks
+				});
+				else if (lc === "card") blocks.push({
+					type: "card",
+					title: mdcProps["title"] || "",
+					icon: mdcProps["icon"] || "",
+					to: mdcProps["to"] || "",
+					innerBlocks
+				});
+				else if (lc === "card-group") {
+					const cards = innerBlocks.filter((b) => b.type === "card");
+					if (cards.length) blocks.push({
+						type: "cardGroup",
+						cards
+					});
+					else blocks.push(...innerBlocks);
+				} else if (lc === "code-collapse") blocks.push({
+					type: "codeCollapse",
+					codeBlocks: codeBlocks.length ? codeBlocks : innerBlocks.filter((b) => b.type === "codeBlock")
+				});
+				else if (lc === "code-group") {
+					const allCode = [...innerBlocks.filter((b) => b.type === "codeBlock"), ...codeBlocks];
+					blocks.push({
+						type: "codeGroup",
+						codeBlocks: allCode
+					});
+				} else if (lc === "code-preview") blocks.push({
+					type: "codePreview",
+					innerBlocks,
+					codeBlocks
+				});
+				else if (lc === "code-tree") blocks.push({
+					type: "codeTree",
+					files: mdcProps["files"] || "[]"
+				});
+				else if (lc === "accordion") {
+					const items = parseMdcChildren(contentLines, "item");
+					if (items.length) blocks.push({
+						type: "accordion",
+						items
+					});
+					else blocks.push({
+						type: "accordion",
+						items: [{
+							label: "Item 1",
+							icon: "",
+							innerBlocks
+						}]
+					});
+				} else if (lc === "tabs") {
+					const items = parseMdcChildren(contentLines, "tab");
+					if (items.length) blocks.push({
+						type: "tabs",
+						items
+					});
+					else blocks.push({
+						type: "tabs",
+						items: [{
+							label: "Tab 1",
+							icon: "",
+							innerBlocks
+						}]
+					});
+				} else if (lc === "field") blocks.push({
+					type: "field",
+					name: mdcProps["name"] || "",
+					fieldType: mdcProps["type"] || "string",
+					required: mdcProps["required"] === "true",
+					innerBlocks
+				});
+				else if (lc === "field-group") {
+					const fields = innerBlocks.filter((b) => b.type === "field");
+					if (fields.length) blocks.push({
+						type: "fieldGroup",
+						fields
+					});
+					else blocks.push(...innerBlocks);
+				} else {
+					blocks.push(...innerBlocks);
+					blocks.push(...codeBlocks);
+				}
+			}
+			continue;
+		}
+		if (TASK_RE.test(line)) {
+			const items = [];
+			while (i < lines.length && TASK_RE.test(lines[i])) {
+				const m = lines[i].match(TASK_RE);
+				items.push({
+					checked: m[1].toLowerCase() === "x",
+					text: m[2]
+				});
+				i++;
+			}
+			blocks.push({
+				type: "taskList",
+				items
+			});
+			continue;
+		}
+		if (/^[-*+]\s+/.test(line)) {
+			const items = [];
+			while (i < lines.length && /^[-*+]\s+/.test(lines[i]) && !TASK_RE.test(lines[i])) {
+				items.push(lines[i].replace(/^[-*+]\s+/, ""));
+				i++;
+			}
+			if (items.length) {
+				blocks.push({
+					type: "bulletList",
+					items
+				});
+				continue;
+			}
+		}
+		if (/^\d+\.\s+/.test(line)) {
+			const items = [];
+			while (i < lines.length && /^\d+\.\s+/.test(lines[i])) {
+				items.push(lines[i].replace(/^\d+\.\s+/, ""));
+				i++;
+			}
+			blocks.push({
+				type: "orderedList",
+				items
+			});
+			continue;
+		}
+		if (line.trim() === "") {
+			i++;
+			continue;
+		}
+		const paraLines = [];
+		while (i < lines.length && lines[i].trim() !== "" && !/^(#{1,6}\s|[-*+]\s|\d+\.\s|>|`{3,}|\s*\||[-*_]{3,}\s*$|\s*:{2,}\w)/.test(lines[i])) {
+			paraLines.push(lines[i]);
+			i++;
+		}
+		if (paraLines.length) blocks.push({
+			type: "paragraph",
+			text: paraLines.join(" ")
+		});
+	}
+	return blocks;
+}
+function fillTextInto(el, tokens) {
+	const filtered = tokens.filter((t) => t.node || t.text.length > 0);
+	if (!filtered.length) return;
+	const children = filtered.map((tok) => {
+		if (tok.node) {
+			const xe = new Y.XmlElement(tok.node);
+			if (tok.nodeAttrs) for (const [k, v] of Object.entries(tok.nodeAttrs)) xe.setAttribute(k, v);
+			return xe;
+		}
+		return new Y.XmlText();
+	});
+	el.insert(0, children);
+	filtered.forEach((tok, i) => {
+		if (tok.node) return;
+		const xt = children[i];
+		if (tok.attrs) xt.insert(0, tok.text, tok.attrs);
+		else xt.insert(0, tok.text);
+	});
+}
+function blockElName(b) {
+	switch (b.type) {
+		case "heading": return "heading";
+		case "paragraph": return "paragraph";
+		case "bulletList": return "bulletList";
+		case "orderedList": return "orderedList";
+		case "taskList": return "taskList";
+		case "codeBlock": return "codeBlock";
+		case "blockquote": return "blockquote";
+		case "table": return "table";
+		case "hr": return "horizontalRule";
+		case "callout": return "callout";
+		case "collapsible": return "collapsible";
+		case "steps": return "steps";
+		case "card": return "card";
+		case "cardGroup": return "cardGroup";
+		case "codeCollapse": return "codeCollapse";
+		case "codeGroup": return "codeGroup";
+		case "codePreview": return "codePreview";
+		case "codeTree": return "codeTree";
+		case "accordion": return "accordion";
+		case "tabs": return "tabs";
+		case "field": return "field";
+		case "fieldGroup": return "fieldGroup";
+		case "image": return "image";
+		case "docEmbed": return "docEmbed";
+		case "svgEmbed": return "svgEmbed";
+	}
+}
+function fillBlock(el, block) {
+	switch (block.type) {
+		case "heading":
+			el.setAttribute("level", block.level);
+			fillTextInto(el, parseInline(block.text));
+			break;
+		case "paragraph":
+			fillTextInto(el, parseInline(block.text));
+			break;
+		case "bulletList":
+		case "orderedList": {
+			const listItemEls = block.items.map(() => new Y.XmlElement("listItem"));
+			el.insert(0, listItemEls);
+			block.items.forEach((text, i) => {
+				const paraEl = new Y.XmlElement("paragraph");
+				listItemEls[i].insert(0, [paraEl]);
+				fillTextInto(paraEl, parseInline(text));
+			});
+			break;
+		}
+		case "taskList": {
+			const taskItemEls = block.items.map(() => new Y.XmlElement("taskItem"));
+			el.insert(0, taskItemEls);
+			block.items.forEach((item, i) => {
+				taskItemEls[i].setAttribute("checked", item.checked);
+				const paraEl = new Y.XmlElement("paragraph");
+				taskItemEls[i].insert(0, [paraEl]);
+				fillTextInto(paraEl, parseInline(item.text));
+			});
+			break;
+		}
+		case "codeBlock": {
+			if (block.lang) el.setAttribute("language", block.lang);
+			const xt = new Y.XmlText();
+			el.insert(0, [xt]);
+			xt.insert(0, block.code);
+			break;
+		}
+		case "blockquote": {
+			const paraEls = block.lines.map(() => new Y.XmlElement("paragraph"));
+			el.insert(0, paraEls);
+			block.lines.forEach((line, i) => fillTextInto(paraEls[i], parseInline(line)));
+			break;
+		}
+		case "table": {
+			const headerRowEl = new Y.XmlElement("tableRow");
+			const dataRowEls = block.dataRows.map(() => new Y.XmlElement("tableRow"));
+			el.insert(0, [headerRowEl, ...dataRowEls]);
+			const headerCellEls = block.headerRow.map(() => new Y.XmlElement("tableHeader"));
+			headerRowEl.insert(0, headerCellEls);
+			block.headerRow.forEach((cellText, i) => {
+				const paraEl = new Y.XmlElement("paragraph");
+				headerCellEls[i].insert(0, [paraEl]);
+				fillTextInto(paraEl, parseInline(cellText));
+			});
+			block.dataRows.forEach((row, ri) => {
+				const cellEls = row.map(() => new Y.XmlElement("tableCell"));
+				dataRowEls[ri].insert(0, cellEls);
+				row.forEach((cellText, ci) => {
+					const paraEl = new Y.XmlElement("paragraph");
+					cellEls[ci].insert(0, [paraEl]);
+					fillTextInto(paraEl, parseInline(cellText));
+				});
+			});
+			break;
+		}
+		case "hr": break;
+		case "callout": {
+			el.setAttribute("type", block.calloutType);
+			if (!block.innerBlocks.length) {
+				const paraEl = new Y.XmlElement("paragraph");
+				el.insert(0, [paraEl]);
+				break;
+			}
+			const innerEls = block.innerBlocks.map((b) => new Y.XmlElement(blockElName(b)));
+			el.insert(0, innerEls);
+			block.innerBlocks.forEach((b, i) => fillBlock(innerEls[i], b));
+			break;
+		}
+		case "collapsible": {
+			el.setAttribute("label", block.label);
+			el.setAttribute("open", block.open);
+			const inner = block.innerBlocks.length ? block.innerBlocks : [{
+				type: "paragraph",
+				text: ""
+			}];
+			const innerEls = inner.map((b) => new Y.XmlElement(blockElName(b)));
+			el.insert(0, innerEls);
+			inner.forEach((b, i) => fillBlock(innerEls[i], b));
+			break;
+		}
+		case "steps": {
+			const inner = block.innerBlocks.length ? block.innerBlocks : [{
+				type: "paragraph",
+				text: ""
+			}];
+			const innerEls = inner.map((b) => new Y.XmlElement(blockElName(b)));
+			el.insert(0, innerEls);
+			inner.forEach((b, i) => fillBlock(innerEls[i], b));
+			break;
+		}
+		case "card": {
+			if (block.title) el.setAttribute("title", block.title);
+			if (block.icon) el.setAttribute("icon", block.icon);
+			if (block.to) el.setAttribute("to", block.to);
+			const inner = block.innerBlocks.length ? block.innerBlocks : [{
+				type: "paragraph",
+				text: ""
+			}];
+			const innerEls = inner.map((b) => new Y.XmlElement(blockElName(b)));
+			el.insert(0, innerEls);
+			inner.forEach((b, i) => fillBlock(innerEls[i], b));
+			break;
+		}
+		case "cardGroup": {
+			const cardEls = block.cards.map((b) => new Y.XmlElement(blockElName(b)));
+			el.insert(0, cardEls);
+			block.cards.forEach((b, i) => fillBlock(cardEls[i], b));
+			break;
+		}
+		case "codeCollapse": {
+			const codes = block.codeBlocks.length ? block.codeBlocks : [{
+				type: "codeBlock",
+				lang: "",
+				code: ""
+			}];
+			const codeEl = new Y.XmlElement("codeBlock");
+			el.insert(0, [codeEl]);
+			fillBlock(codeEl, codes[0]);
+			break;
+		}
+		case "codeGroup": {
+			const codes = block.codeBlocks.length ? block.codeBlocks : [{
+				type: "codeBlock",
+				lang: "",
+				code: ""
+			}];
+			const codeEls = codes.map(() => new Y.XmlElement("codeBlock"));
+			el.insert(0, codeEls);
+			codes.forEach((b, i) => fillBlock(codeEls[i], b));
+			break;
+		}
+		case "codePreview": {
+			const all = [...block.innerBlocks, ...block.codeBlocks];
+			const inner = all.length ? all : [{
+				type: "paragraph",
+				text: ""
+			}];
+			const innerEls = inner.map((b) => new Y.XmlElement(blockElName(b)));
+			el.insert(0, innerEls);
+			inner.forEach((b, i) => fillBlock(innerEls[i], b));
+			break;
+		}
+		case "codeTree":
+			el.setAttribute("files", block.files);
+			break;
+		case "accordion": {
+			const itemEls = block.items.map(() => new Y.XmlElement("accordionItem"));
+			el.insert(0, itemEls);
+			block.items.forEach((item, i) => {
+				itemEls[i].setAttribute("label", item.label);
+				if (item.icon) itemEls[i].setAttribute("icon", item.icon);
+				const inner = item.innerBlocks.length ? item.innerBlocks : [{
+					type: "paragraph",
+					text: ""
+				}];
+				const childEls = inner.map((b) => new Y.XmlElement(blockElName(b)));
+				itemEls[i].insert(0, childEls);
+				inner.forEach((b, ci) => fillBlock(childEls[ci], b));
+			});
+			break;
+		}
+		case "tabs": {
+			const itemEls = block.items.map(() => new Y.XmlElement("tabsItem"));
+			el.insert(0, itemEls);
+			block.items.forEach((item, i) => {
+				itemEls[i].setAttribute("label", item.label);
+				if (item.icon) itemEls[i].setAttribute("icon", item.icon);
+				const inner = item.innerBlocks.length ? item.innerBlocks : [{
+					type: "paragraph",
+					text: ""
+				}];
+				const childEls = inner.map((b) => new Y.XmlElement(blockElName(b)));
+				itemEls[i].insert(0, childEls);
+				inner.forEach((b, ci) => fillBlock(childEls[ci], b));
+			});
+			break;
+		}
+		case "field": {
+			if (block.name) el.setAttribute("name", block.name);
+			el.setAttribute("type", block.fieldType);
+			el.setAttribute("required", block.required);
+			const inner = block.innerBlocks.length ? block.innerBlocks : [{
+				type: "paragraph",
+				text: ""
+			}];
+			const innerEls = inner.map((b) => new Y.XmlElement(blockElName(b)));
+			el.insert(0, innerEls);
+			inner.forEach((b, i) => fillBlock(innerEls[i], b));
+			break;
+		}
+		case "fieldGroup": {
+			const fieldEls = block.fields.map((b) => new Y.XmlElement(blockElName(b)));
+			el.insert(0, fieldEls);
+			block.fields.forEach((b, i) => fillBlock(fieldEls[i], b));
+			break;
+		}
+		case "image":
+			el.setAttribute("src", block.src);
+			if (block.alt) el.setAttribute("alt", block.alt);
+			if (block.width) el.setAttribute("width", block.width);
+			if (block.height) el.setAttribute("height", block.height);
+			break;
+		case "docEmbed":
+			el.setAttribute("docId", block.docId);
+			if (block.seamless) el.setAttribute("seamless", "true");
+			break;
+		case "svgEmbed":
+			el.setAttribute("svg", block.svg);
+			if (block.title) el.setAttribute("title", block.title);
+			break;
+	}
+}
+function populateYDocFromMarkdown(fragment, markdown, fallbackTitle = "Untitled") {
+	const ydoc = fragment.doc;
+	if (!ydoc) {
+		console.warn("[markdownToYjs] fragment has no doc — skipping population");
+		return;
+	}
+	const blocks = parseBlocks(markdown);
+	let title = fallbackTitle;
+	let contentBlocks = blocks;
+	const h1 = blocks.findIndex((b) => b.type === "heading" && b.level === 1);
+	if (h1 !== -1) {
+		title = blocks[h1].text;
+		contentBlocks = blocks.filter((_, i) => i !== h1);
+	}
+	if (!contentBlocks.length) contentBlocks = [{
+		type: "paragraph",
+		text: ""
+	}];
+	ydoc.transact(() => {
+		const headerEl = new Y.XmlElement("documentHeader");
+		const metaEl = new Y.XmlElement("documentMeta");
+		const bodyEls = contentBlocks.map((b) => {
+			switch (b.type) {
+				case "heading": return new Y.XmlElement("heading");
+				case "paragraph": return new Y.XmlElement("paragraph");
+				case "bulletList": return new Y.XmlElement("bulletList");
+				case "orderedList": return new Y.XmlElement("orderedList");
+				case "taskList": return new Y.XmlElement("taskList");
+				case "codeBlock": return new Y.XmlElement("codeBlock");
+				case "blockquote": return new Y.XmlElement("blockquote");
+				case "table": return new Y.XmlElement("table");
+				case "hr": return new Y.XmlElement("horizontalRule");
+				case "callout": return new Y.XmlElement("callout");
+				case "collapsible": return new Y.XmlElement("collapsible");
+				case "steps": return new Y.XmlElement("steps");
+				case "card": return new Y.XmlElement("card");
+				case "cardGroup": return new Y.XmlElement("cardGroup");
+				case "codeCollapse": return new Y.XmlElement("codeCollapse");
+				case "codeGroup": return new Y.XmlElement("codeGroup");
+				case "codePreview": return new Y.XmlElement("codePreview");
+				case "codeTree": return new Y.XmlElement("codeTree");
+				case "accordion": return new Y.XmlElement("accordion");
+				case "tabs": return new Y.XmlElement("tabs");
+				case "field": return new Y.XmlElement("field");
+				case "fieldGroup": return new Y.XmlElement("fieldGroup");
+				case "image": return new Y.XmlElement("image");
+				case "docEmbed": return new Y.XmlElement("docEmbed");
+				case "svgEmbed": return new Y.XmlElement("svgEmbed");
+			}
+		});
+		fragment.insert(0, [
+			headerEl,
+			metaEl,
+			...bodyEls
+		]);
+		const headerXt = new Y.XmlText();
+		headerEl.insert(0, [headerXt]);
+		headerXt.insert(0, title);
+		contentBlocks.forEach((block, i) => fillBlock(bodyEls[i], block));
+	});
+}
+
+//#endregion
+//#region packages/orchestrator/src/actions/content.ts
+async function executeWriteContent(actor, action) {
+	const provider = await actor.getChildProvider(action.docId);
+	const fragment = provider.document.getXmlFragment("default");
+	provider.document.transact(() => {
+		while (fragment.length > 0) fragment.delete(0, 1);
+	});
+	populateYDocFromMarkdown(fragment, action.markdown);
+}
+async function executeDeleteContent(actor, action) {
+	const provider = await actor.getChildProvider(action.docId);
+	const fragment = provider.document.getXmlFragment("default");
+	provider.document.transact(() => {
+		const adjustedFrom = bodyStartIndex(fragment) + action.from;
+		const count = Math.min(action.length, fragment.length - adjustedFrom);
+		if (count > 0) fragment.delete(adjustedFrom, count);
+	});
+}
+
+//#endregion
+//#region packages/orchestrator/src/actions/awareness.ts
+async function executeSetStatus(actor, action) {
+	actor.setRootAwareness("status", action.status);
+}
+async function executeSetAwareness(actor, action) {
+	if (action.docId) {
+		await actor.getChildProvider(action.docId);
+		for (const [key, value] of Object.entries(action.fields)) actor.setChildAwareness(action.docId, key, value);
+	} else for (const [key, value] of Object.entries(action.fields)) actor.setRootAwareness(key, value);
+}
+async function executeClearAwareness(actor, action) {
+	if (action.docId) for (const field of action.fields) actor.setChildAwareness(action.docId, field, null);
+	else for (const field of action.fields) actor.setRootAwareness(field, null);
+}
+async function executePointerMove(actor, action) {
+	const easing = getEasing(action.easing);
+	const steps = Math.max(1, Math.round(action.duration / 16));
+	const stepDuration = action.duration / steps;
+	for (let i = 0; i <= steps; i++) {
+		const t = easing(i / steps);
+		const x = action.from.x + (action.to.x - action.from.x) * t;
+		const y = action.from.y + (action.to.y - action.from.y) * t;
+		actor.setChildAwareness(action.docId, "pos", {
+			x,
+			y
+		});
+		if (i < steps) await sleep(stepDuration);
+	}
+}
+async function executeScrollTo(actor, action) {
+	actor.setChildAwareness(action.docId, "doc:scroll", action.position);
+}
+async function executeKanbanHover(actor, action) {
+	actor.setChildAwareness(action.docId, "kanban:hovering", action.cardId);
+}
+async function executeKanbanDrag(actor, action) {
+	actor.setChildAwareness(action.docId, "kanban:dragging", {
+		cardId: action.cardId,
+		toColumnId: action.toColumnId
+	});
+	await sleep(action.duration);
+	actor.setChildAwareness(action.docId, "kanban:dragging", null);
+}
+
+//#endregion
+//#region packages/orchestrator/src/actions/document.ts
+async function executeCreateDocument(actor, action, vars) {
+	const rootProvider = actor.rootProvider;
+	if (!rootProvider) throw new Error(`${actor.actor.name}: not connected`);
+	const treeMap = rootProvider.document.getMap("doc-tree");
+	const id = crypto.randomUUID();
+	const now = Date.now();
+	const normalizedParent = action.parentId === actor.rootDocId ? null : action.parentId;
+	rootProvider.document.transact(() => {
+		treeMap.set(id, {
+			label: action.label,
+			parentId: normalizedParent,
+			order: now,
+			type: action.docType,
+			meta: action.meta,
+			createdAt: now,
+			updatedAt: now
+		});
+	});
+	log(`${actor.actor.name}: created document "${action.label}" (${id})`);
+	if (action.assignId) vars.set(action.assignId, id);
+}
+async function executeMoveDocument(actor, action) {
+	const rootProvider = actor.rootProvider;
+	if (!rootProvider) throw new Error(`${actor.actor.name}: not connected`);
+	const treeMap = rootProvider.document.getMap("doc-tree");
+	const entry = treeMap.get(action.docId);
+	if (!entry) {
+		log(`${actor.actor.name}: document ${action.docId} not found in tree`);
+		return;
+	}
+	const normalizedParent = action.newParentId === actor.rootDocId ? null : action.newParentId;
+	rootProvider.document.transact(() => {
+		treeMap.set(action.docId, {
+			...entry,
+			parentId: normalizedParent,
+			order: action.order ?? Date.now(),
+			updatedAt: Date.now()
+		});
+	});
+	log(`${actor.actor.name}: moved document ${action.docId} to ${action.newParentId}`);
+}
+async function executeSetMeta(actor, action) {
+	const rootProvider = actor.rootProvider;
+	if (!rootProvider) throw new Error(`${actor.actor.name}: not connected`);
+	const treeMap = rootProvider.document.getMap("doc-tree");
+	const entry = treeMap.get(action.docId);
+	if (!entry) {
+		log(`${actor.actor.name}: document ${action.docId} not found in tree`);
+		return;
+	}
+	rootProvider.document.transact(() => {
+		const currentMeta = entry.meta ?? {};
+		treeMap.set(action.docId, {
+			...entry,
+			meta: {
+				...currentMeta,
+				...action.meta
+			},
+			updatedAt: Date.now()
+		});
+	});
+}
+async function executeRenameDocument(actor, action) {
+	const rootProvider = actor.rootProvider;
+	if (!rootProvider) throw new Error(`${actor.actor.name}: not connected`);
+	const treeMap = rootProvider.document.getMap("doc-tree");
+	const entry = treeMap.get(action.docId);
+	if (!entry) {
+		log(`${actor.actor.name}: document ${action.docId} not found in tree`);
+		return;
+	}
+	rootProvider.document.transact(() => {
+		treeMap.set(action.docId, {
+			...entry,
+			label: action.label,
+			updatedAt: Date.now()
+		});
+	});
+	log(`${actor.actor.name}: renamed ${action.docId} to "${action.label}"`);
+}
+
+//#endregion
+//#region packages/orchestrator/src/actions/chat.ts
+async function executeSendChat(actor, action) {
+	const rootProvider = actor.rootProvider;
+	if (!rootProvider) throw new Error(`${actor.actor.name}: not connected`);
+	const channel_doc_id = action.channel.startsWith("group:") ? action.channel.slice(6) : action.channel;
+	const payload = JSON.stringify({
+		type: "messages:send",
+		channel_doc_id,
+		content: action.message,
+		mentions: []
+	});
+	rootProvider.sendStateless(payload);
+}
+
+//#endregion
+//#region packages/orchestrator/src/actions/flow.ts
+async function executeWait(action) {
+	await sleep(action.duration);
+}
+async function executeParallel(action, execute) {
+	const promises = action.actions.map(async (entry) => {
+		const delay = entry.at ?? 0;
+		if (delay > 0) await sleep(delay);
+		await execute(entry);
+	});
+	await Promise.all(promises);
+}
+async function executeSequence(action, execute) {
+	for (const entry of action.actions) {
+		const delay = entry.at ?? 0;
+		if (delay > 0) await sleep(delay);
+		await execute(entry);
+	}
+}
+async function executeRepeat(action, execute) {
+	for (let n = 0; n < action.times; n++) for (const entry of action.actions) {
+		const delay = entry.at ?? 0;
+		if (delay > 0) await sleep(delay);
+		await execute(entry);
+	}
+}
+
+//#endregion
+//#region packages/orchestrator/src/actions/index.ts
+/**
+* Resolve variable references in string values.
+* Replaces ${varName} with the value from vars map.
+*/
+function resolveVars(value, vars) {
+	return value.replace(/\$\{(\w+)\}/g, (_, key) => vars.get(key) ?? `\${${key}}`);
+}
+function resolveActionVars(action, vars) {
+	if (vars.size === 0) return action;
+	const a = { ...action };
+	if (a.docId && typeof a.docId === "string") a.docId = resolveVars(a.docId, vars);
+	if (a.parentId && typeof a.parentId === "string") a.parentId = resolveVars(a.parentId, vars);
+	if (a.newParentId && typeof a.newParentId === "string") a.newParentId = resolveVars(a.newParentId, vars);
+	if (a.cardId && typeof a.cardId === "string") a.cardId = resolveVars(a.cardId, vars);
+	if (a.toColumnId && typeof a.toColumnId === "string") a.toColumnId = resolveVars(a.toColumnId, vars);
+	if (a.text && typeof a.text === "string") a.text = resolveVars(a.text, vars);
+	if (a.label && typeof a.label === "string") a.label = resolveVars(a.label, vars);
+	if (a.markdown && typeof a.markdown === "string") a.markdown = resolveVars(a.markdown, vars);
+	if (a.channel && typeof a.channel === "string") a.channel = resolveVars(a.channel, vars);
+	if (a.message && typeof a.message === "string") a.message = resolveVars(a.message, vars);
+	return a;
+}
+function createExecutor(ctx) {
+	const execute = async (entry) => {
+		const action = resolveActionVars(entry.action, ctx.vars);
+		const actor = entry.actor ? ctx.actors.get(entry.actor) : void 0;
+		switch (action.type) {
+			case "connect":
+				if (!actor) throw new Error("connect requires an actor");
+				await executeConnect(actor, ctx.serverConfig);
+				break;
+			case "disconnect":
+				if (!actor) throw new Error("disconnect requires an actor");
+				await executeDisconnect(actor);
+				break;
+			case "navigate":
+				if (!actor) throw new Error("navigate requires an actor");
+				await executeNavigate(actor, action);
+				break;
+			case "type":
+				if (!actor) throw new Error("type requires an actor");
+				await executeType(actor, action);
+				break;
+			case "typeDelete":
+				if (!actor) throw new Error("typeDelete requires an actor");
+				await executeTypeDelete(actor, action);
+				break;
+			case "select":
+				if (!actor) throw new Error("select requires an actor");
+				await executeSelect(actor, action);
+				break;
+			case "moveCursor":
+				if (!actor) throw new Error("moveCursor requires an actor");
+				await executeMoveCursor(actor, action);
+				break;
+			case "setStatus":
+				if (!actor) throw new Error("setStatus requires an actor");
+				await executeSetStatus(actor, action);
+				break;
+			case "setAwareness":
+				if (!actor) throw new Error("setAwareness requires an actor");
+				await executeSetAwareness(actor, action);
+				break;
+			case "clearAwareness":
+				if (!actor) throw new Error("clearAwareness requires an actor");
+				await executeClearAwareness(actor, action);
+				break;
+			case "createDocument":
+				if (!actor) throw new Error("createDocument requires an actor");
+				await executeCreateDocument(actor, action, ctx.vars);
+				break;
+			case "moveDocument":
+				if (!actor) throw new Error("moveDocument requires an actor");
+				await executeMoveDocument(actor, action);
+				break;
+			case "renameDocument":
+				if (!actor) throw new Error("renameDocument requires an actor");
+				await executeRenameDocument(actor, action);
+				break;
+			case "writeContent":
+				if (!actor) throw new Error("writeContent requires an actor");
+				await executeWriteContent(actor, action);
+				break;
+			case "deleteContent":
+				if (!actor) throw new Error("deleteContent requires an actor");
+				await executeDeleteContent(actor, action);
+				break;
+			case "setMeta":
+				if (!actor) throw new Error("setMeta requires an actor");
+				await executeSetMeta(actor, action);
+				break;
+			case "pointerMove":
+				if (!actor) throw new Error("pointerMove requires an actor");
+				await executePointerMove(actor, action);
+				break;
+			case "scrollTo":
+				if (!actor) throw new Error("scrollTo requires an actor");
+				await executeScrollTo(actor, action);
+				break;
+			case "kanbanHover":
+				if (!actor) throw new Error("kanbanHover requires an actor");
+				await executeKanbanHover(actor, action);
+				break;
+			case "kanbanDrag":
+				if (!actor) throw new Error("kanbanDrag requires an actor");
+				await executeKanbanDrag(actor, action);
+				break;
+			case "sendChat":
+				if (!actor) throw new Error("sendChat requires an actor");
+				await executeSendChat(actor, action);
+				break;
+			case "wait":
+				await executeWait(action);
+				break;
+			case "parallel":
+				await executeParallel(action, execute);
+				break;
+			case "sequence":
+				await executeSequence(action, execute);
+				break;
+			case "repeat":
+				await executeRepeat(action, execute);
+				break;
+			default: throw new Error(`Unknown action type: ${action.type}`);
+		}
+	};
+	return execute;
+}
+
+//#endregion
+//#region packages/orchestrator/src/orchestrator.ts
+/**
+* Orchestrator — top-level class that loads a scene, manages actors, and runs the timeline.
+*/
+var Orchestrator = class {
+	constructor() {
+		this.scene = null;
+		this.actors = /* @__PURE__ */ new Map();
+		this.vars = /* @__PURE__ */ new Map();
+	}
+	/** Load a scene from a TypeScript file. */
+	async load(scriptPath) {
+		const mod = await import(pathToFileURL(resolve(scriptPath)).href);
+		const scene = mod.default ?? mod;
+		if (!scene.server?.url) throw new Error("Scene must have server.url");
+		if (!scene.actors?.length) throw new Error("Scene must have at least one actor");
+		if (!scene.timeline?.length) throw new Error("Scene must have at least one timeline entry");
+		this.scene = scene;
+		log(`Loaded scene: ${scene.actors.length} actors, ${scene.timeline.length} timeline entries`);
+	}
+	/** Prepare actor connections (does not connect yet — that's a timeline action). */
+	prepare() {
+		if (!this.scene) throw new Error("No scene loaded");
+		if (this.scene.vars) for (const [k, v] of Object.entries(this.scene.vars)) this.vars.set(k, v);
+		for (const actorDef of this.scene.actors) {
+			if (this.actors.has(actorDef.name)) throw new Error(`Duplicate actor name: ${actorDef.name}`);
+			const conn = new ActorConnection(actorDef, this.scene.server);
+			this.actors.set(actorDef.name, conn);
+		}
+		log(`Prepared ${this.actors.size} actors: ${[...this.actors.keys()].join(", ")}`);
+	}
+	/** Validate the scene without connecting. Logs the timeline structure. */
+	dryRun() {
+		if (!this.scene) throw new Error("No scene loaded");
+		const actorNames = new Set(this.scene.actors.map((a) => a.name));
+		const errors = [];
+		for (let i = 0; i < this.scene.timeline.length; i++) {
+			const entry = this.scene.timeline[i];
+			const prefix = `timeline[${i}]`;
+			if (entry.actor && !actorNames.has(entry.actor)) errors.push(`${prefix}: unknown actor "${entry.actor}"`);
+			if (![
+				"wait",
+				"parallel",
+				"sequence",
+				"repeat"
+			].includes(entry.action.type) && !entry.actor) errors.push(`${prefix}: ${entry.action.type} requires an actor`);
+		}
+		if (errors.length) {
+			log(`Dry run found ${errors.length} issue(s):`);
+			for (const e of errors) log(`  - ${e}`);
+		} else log("Dry run: no issues found");
+		const sorted = [...this.scene.timeline].sort((a, b) => (a.at ?? 0) - (b.at ?? 0));
+		log("Timeline:");
+		for (const entry of sorted) log(`  [${`${((entry.at ?? 0) / 1e3).toFixed(1)}s`}] ${entry.actor ?? "—"}: ${entry.action.type}`);
+		if (this.scene.duration) log(`Scene duration: ${(this.scene.duration / 1e3).toFixed(1)}s`);
+	}
+	/** Run the timeline. */
+	async run() {
+		if (!this.scene) throw new Error("No scene loaded");
+		if (this.scene.onStart) {
+			log("Running onStart hook...");
+			await this.scene.onStart();
+		}
+		const executor = createExecutor({
+			actors: this.actors,
+			serverConfig: this.scene.server,
+			vars: this.vars
+		});
+		const runner = new TimelineRunner();
+		log("Starting timeline...");
+		const startTime = Date.now();
+		if (this.scene.duration) {
+			const timelinePromise = runner.run(this.scene.timeline, executor);
+			const timeoutPromise = new Promise((resolve) => {
+				setTimeout(() => {
+					log(`Scene duration reached (${this.scene.duration}ms), stopping...`);
+					resolve();
+				}, this.scene.duration);
+			});
+			await Promise.race([timelinePromise, timeoutPromise]);
+		} else await runner.run(this.scene.timeline, executor);
+		log(`Timeline complete in ${((Date.now() - startTime) / 1e3).toFixed(1)}s`);
+		if (this.scene.onEnd) {
+			log("Running onEnd hook...");
+			await this.scene.onEnd();
+		}
+	}
+	/** Disconnect all actors gracefully. */
+	async cleanup() {
+		const disconnects = [...this.actors.values()].map((a) => a.disconnect().catch(() => {}));
+		await Promise.all(disconnects);
+		this.actors.clear();
+		this.vars.clear();
+		log("All actors disconnected");
+	}
+};
+
+//#endregion
+//#region packages/orchestrator/src/define.ts
+/** Define a complete scene. */
+function defineScene(scene) {
+	return scene;
+}
+/** Define an actor. */
+function actor(name, opts) {
+	return {
+		name,
+		...opts
+	};
+}
+/** Factory functions for all action types. */
+const actions = {
+	connect() {
+		return { type: "connect" };
+	},
+	disconnect() {
+		return { type: "disconnect" };
+	},
+	navigate(docId) {
+		return {
+			type: "navigate",
+			docId
+		};
+	},
+	type(docId, text, opts) {
+		return {
+			type: "type",
+			docId,
+			text,
+			...opts
+		};
+	},
+	typeDelete(docId, count, opts) {
+		return {
+			type: "typeDelete",
+			docId,
+			count,
+			...opts
+		};
+	},
+	select(docId, anchor, head) {
+		return {
+			type: "select",
+			docId,
+			anchor,
+			head
+		};
+	},
+	moveCursor(docId, from, to, duration, easing) {
+		return {
+			type: "moveCursor",
+			docId,
+			from,
+			to,
+			duration,
+			easing
+		};
+	},
+	setStatus(status) {
+		return {
+			type: "setStatus",
+			status
+		};
+	},
+	setAwareness(fields, docId) {
+		return {
+			type: "setAwareness",
+			docId,
+			fields
+		};
+	},
+	clearAwareness(fields, docId) {
+		return {
+			type: "clearAwareness",
+			docId,
+			fields
+		};
+	},
+	createDocument(parentId, label, opts) {
+		return {
+			type: "createDocument",
+			parentId,
+			label,
+			...opts
+		};
+	},
+	moveDocument(docId, newParentId, order) {
+		return {
+			type: "moveDocument",
+			docId,
+			newParentId,
+			order
+		};
+	},
+	renameDocument(docId, label) {
+		return {
+			type: "renameDocument",
+			docId,
+			label
+		};
+	},
+	writeContent(docId, markdown) {
+		return {
+			type: "writeContent",
+			docId,
+			markdown
+		};
+	},
+	deleteContent(docId, from, length) {
+		return {
+			type: "deleteContent",
+			docId,
+			from,
+			length
+		};
+	},
+	setMeta(docId, meta) {
+		return {
+			type: "setMeta",
+			docId,
+			meta
+		};
+	},
+	pointerMove(docId, from, to, duration, easing) {
+		return {
+			type: "pointerMove",
+			docId,
+			from,
+			to,
+			duration,
+			easing
+		};
+	},
+	scrollTo(docId, position) {
+		return {
+			type: "scrollTo",
+			docId,
+			position
+		};
+	},
+	kanbanHover(docId, cardId) {
+		return {
+			type: "kanbanHover",
+			docId,
+			cardId
+		};
+	},
+	kanbanDrag(docId, cardId, toColumnId, duration) {
+		return {
+			type: "kanbanDrag",
+			docId,
+			cardId,
+			toColumnId,
+			duration
+		};
+	},
+	sendChat(channel, message) {
+		return {
+			type: "sendChat",
+			channel,
+			message
+		};
+	},
+	wait(duration) {
+		return {
+			type: "wait",
+			duration
+		};
+	},
+	parallel(entries) {
+		return {
+			type: "parallel",
+			actions: entries
+		};
+	},
+	sequence(entries) {
+		return {
+			type: "sequence",
+			actions: entries
+		};
+	},
+	repeat(times, entries) {
+		return {
+			type: "repeat",
+			times,
+			actions: entries
+		};
+	}
+};
+
+//#endregion
+//#region packages/orchestrator/src/index.ts
+/**
+* Abracadabra Orchestrator — CouShell commercial director.
+*
+* Usage (after pnpm build:packages):
+*   node --experimental-transform-types \
+*     packages/orchestrator/dist/abracadabra-orchestrator.esm.js ./scripts/demo.ts
+*
+* Dry run:
+*   node --experimental-transform-types \
+*     packages/orchestrator/dist/abracadabra-orchestrator.esm.js --dry-run ./scripts/demo.ts
+*/
+async function main() {
+	const args = process.argv.slice(2);
+	const dryRun = args.includes("--dry-run");
+	const scriptPath = args.find((a) => !a.startsWith("--"));
+	if (!scriptPath) {
+		console.error("Usage: abracadabra-orchestrator [--dry-run] <script.ts>");
+		console.error("");
+		console.error("  The script file should export a Scene object (use defineScene()).");
+		console.error("");
+		console.error("Options:");
+		console.error("  --dry-run  Validate the scene without connecting to the server");
+		console.error("");
+		console.error("Example:");
+		console.error("  node --conditions=source --experimental-transform-types \\");
+		console.error("    packages/orchestrator/src/index.ts ./scripts/demo.ts");
+		process.exit(1);
+	}
+	const orchestrator = new Orchestrator();
+	try {
+		await orchestrator.load(scriptPath);
+		orchestrator.prepare();
+		if (dryRun) orchestrator.dryRun();
+		else await orchestrator.run();
+	} catch (err) {
+		console.error(`[orchestrator] Fatal: ${err.message}`);
+		process.exit(1);
+	} finally {
+		if (!dryRun) await orchestrator.cleanup();
+	}
+}
+const __dirname = dirname(fileURLToPath(import.meta.url));
+if (process.argv[1]) {
+	const resolved = resolve(process.argv[1]);
+	if (resolved.startsWith(__dirname) || resolved.includes("abracadabra-orchestrator")) main();
+}
+
+//#endregion
+export { Orchestrator, actions, actor, defineScene };
+//# sourceMappingURL=abracadabra-orchestrator.esm.js.map