@p4code/cli 0.7.2 → 0.7.4

package/dist/runtime-DC_ewLnZ.mjs

@@ -0,0 +1,984 @@
+#!/usr/bin/env node
+
+import { T as DesignDocument, j as DesignNode } from "./src-DjTfFS-z.mjs";
+import * as Schema from "effect/Schema";
+//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+function isBytes(a) {
+	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+/** Asserts something is Uint8Array. */
+function abytes(b, ...lengths) {
+	if (!isBytes(b)) throw new Error("Uint8Array expected");
+	if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+/** Asserts a hash instance has not been destroyed / finished */
+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 properly-sized byte array */
+function aoutput(out, instance) {
+	abytes(out);
+	const min = instance.outputLen;
+	if (out.length < min) throw new Error("digestInto() expects output buffer of length at least " + min);
+}
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+function clean(...arrays) {
+	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
+}
+/** Create DataView of an array for easy byte-level manipulation. */
+function createView(arr) {
+	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** The rotate right (circular right shift) operation for uint32 */
+function rotr(word, shift) {
+	return word << 32 - shift | word >>> shift;
+}
+const hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+/**
+* Convert byte array to hex string. Uses built-in function, when available.
+* @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+*/
+function bytesToHex(bytes) {
+	abytes(bytes);
+	if (hasHexBuiltin) return bytes.toHex();
+	let hex = "";
+	for (let i = 0; i < bytes.length; i++) hex += hexes[bytes[i]];
+	return hex;
+}
+/**
+* Converts string to bytes using UTF8 encoding.
+* @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+*/
+function utf8ToBytes(str) {
+	if (typeof str !== "string") throw new Error("string expected");
+	return new Uint8Array(new TextEncoder().encode(str));
+}
+/**
+* Normalizes (non-hex) string or Uint8Array to Uint8Array.
+* Warning: when Uint8Array is passed, it would NOT get copied.
+* Keep in mind for future mutable operations.
+*/
+function toBytes(data) {
+	if (typeof data === "string") data = utf8ToBytes(data);
+	abytes(data);
+	return data;
+}
+/** For runtime check if class implements interface */
+var Hash = class {};
+/** Wraps hash function, creating an interface on top of it */
+function createHasher(hashCons) {
+	const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+	const tmp = hashCons();
+	hashC.outputLen = tmp.outputLen;
+	hashC.blockLen = tmp.blockLen;
+	hashC.create = () => hashCons();
+	return hashC;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_md.js
+/**
+* Internal Merkle-Damgard hash utils.
+* @module
+*/
+/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */
+function setBigUint64(view, byteOffset, value, isLE) {
+	if (typeof view.setBigUint64 === "function") return view.setBigUint64(byteOffset, value, isLE);
+	const _32n = BigInt(32);
+	const _u32_max = BigInt(4294967295);
+	const wh = Number(value >> _32n & _u32_max);
+	const wl = Number(value & _u32_max);
+	const h = isLE ? 4 : 0;
+	const l = isLE ? 0 : 4;
+	view.setUint32(byteOffset + h, wh, isLE);
+	view.setUint32(byteOffset + l, wl, isLE);
+}
+/** Choice: a ? b : c */
+function Chi(a, b, c) {
+	return a & b ^ ~a & c;
+}
+/** Majority function, true if any two inputs is true. */
+function Maj(a, b, c) {
+	return a & b ^ a & c ^ b & c;
+}
+/**
+* Merkle-Damgard hash construction base class.
+* Could be used to create MD5, RIPEMD, SHA1, SHA2.
+*/
+var HashMD = class extends Hash {
+	constructor(blockLen, outputLen, padOffset, isLE) {
+		super();
+		this.finished = false;
+		this.length = 0;
+		this.pos = 0;
+		this.destroyed = false;
+		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);
+		data = toBytes(data);
+		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;
+		setBigUint64(view, 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 should 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 || (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 SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
+* Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
+*/
+/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */
+const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+	1779033703,
+	3144134277,
+	1013904242,
+	2773480762,
+	1359893119,
+	2600822924,
+	528734635,
+	1541459225
+]);
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/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 [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
+* [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+* @module
+*/
+/**
+* Round constants:
+* First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)
+*/
+const SHA256_K = /* @__PURE__ */ Uint32Array.from([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+/** Reusable temporary buffer. "W" comes straight from spec. */
+const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA256 = class extends HashMD {
+	constructor(outputLen = 32) {
+		super(64, outputLen, 8, false);
+		this.A = SHA256_IV[0] | 0;
+		this.B = SHA256_IV[1] | 0;
+		this.C = SHA256_IV[2] | 0;
+		this.D = SHA256_IV[3] | 0;
+		this.E = SHA256_IV[4] | 0;
+		this.F = SHA256_IV[5] | 0;
+		this.G = SHA256_IV[6] | 0;
+		this.H = SHA256_IV[7] | 0;
+	}
+	get() {
+		const { A, B, C, D, E, F, G, H } = this;
+		return [
+			A,
+			B,
+			C,
+			D,
+			E,
+			F,
+			G,
+			H
+		];
+	}
+	set(A, B, C, D, E, F, G, H) {
+		this.A = A | 0;
+		this.B = B | 0;
+		this.C = C | 0;
+		this.D = D | 0;
+		this.E = E | 0;
+		this.F = F | 0;
+		this.G = G | 0;
+		this.H = H | 0;
+	}
+	process(view, offset) {
+		for (let i = 0; i < 16; i++, offset += 4) SHA256_W[i] = view.getUint32(offset, false);
+		for (let i = 16; i < 64; i++) {
+			const W15 = SHA256_W[i - 15];
+			const W2 = SHA256_W[i - 2];
+			const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+			const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+			SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+		}
+		let { A, B, C, D, E, F, G, H } = this;
+		for (let i = 0; i < 64; i++) {
+			const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+			const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+			const T2 = (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Maj(A, B, C) | 0;
+			H = G;
+			G = F;
+			F = E;
+			E = D + T1 | 0;
+			D = C;
+			C = B;
+			B = A;
+			A = T1 + T2 | 0;
+		}
+		A = A + this.A | 0;
+		B = B + this.B | 0;
+		C = C + this.C | 0;
+		D = D + this.D | 0;
+		E = E + this.E | 0;
+		F = F + this.F | 0;
+		G = G + this.G | 0;
+		H = H + this.H | 0;
+		this.set(A, B, C, D, E, F, G, H);
+	}
+	roundClean() {
+		clean(SHA256_W);
+	}
+	destroy() {
+		this.set(0, 0, 0, 0, 0, 0, 0, 0);
+		clean(this.buffer);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha256.js
+/**
+* SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.
+*
+* To break sha256 using birthday attack, attackers need to try 2^128 hashes.
+* BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+*
+* Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+* @module
+* @deprecated
+*/
+/** @deprecated Use import from `noble/hashes/sha2` module */
+const sha256 = /* @__PURE__ */ createHasher(() => new SHA256());
+//#endregion
+//#region ../../packages/design/src/runtime.ts
+const decodeDocument = Schema.decodeUnknownSync(DesignDocument);
+const decodeNode = Schema.decodeUnknownSync(DesignNode);
+const diagnostic = (code, message, nodeId, severity = "error") => ({
+	code,
+	message,
+	severity,
+	...nodeId ? { nodeId } : {}
+});
+function canonicalSerialize(value) {
+	const visit = (v) => {
+		if (v === null || typeof v === "string" || typeof v === "boolean") return JSON.stringify(v);
+		if (typeof v === "number" && Number.isFinite(v)) return JSON.stringify(v);
+		if (Array.isArray(v)) return `[${v.map(visit).join(",")}]`;
+		if (typeof v === "object" && v !== null && Object.getPrototypeOf(v) === Object.prototype) {
+			const obj = v;
+			return `{${Object.keys(obj).sort().map((k) => `${JSON.stringify(k)}:${visit(obj[k])}`).join(",")}}`;
+		}
+		throw new Error("Design JSON must contain only finite JSON values");
+	};
+	return `${visit(value)}\n`;
+}
+function fileHash(bytes) {
+	return bytesToHex(sha256(typeof bytes === "string" ? new TextEncoder().encode(bytes) : bytes));
+}
+var DesignDependencyError = class extends Error {
+	diagnostics;
+	constructor(diagnostics) {
+		super("Design dependency digests are missing or invalid");
+		this.name = "DesignDependencyError";
+		this.diagnostics = diagnostics;
+	}
+};
+/** Digest of a library's own content. The server supplies its transitive dependency edges separately. */
+function documentContentDigest(doc) {
+	const { annotations: _annotations, reviews: _reviews, acceptances: _acceptances, ...content } = doc;
+	return fileHash(canonicalSerialize(content));
+}
+function contentHash(doc, dependencies = {}) {
+	const libraries = {};
+	const assets = {};
+	const issues = [];
+	const pending = Object.values(doc.imports).map((i) => i.libraryId);
+	const visited = /* @__PURE__ */ new Set();
+	const requiredAssets = new Set(Object.keys(doc.assets));
+	for (const node of Object.values(doc.nodes)) for (const fill of node.fills ?? []) if (fill.kind === "image") requiredAssets.add(fill.assetId);
+	for (const instance of Object.values(doc.instances)) for (const patch of Object.values(instance.overrides)) for (const fill of patch.fills ?? []) if (fill.kind === "image") requiredAssets.add(fill.assetId);
+	const valid = (digest) => digest !== void 0 && /^[0-9a-f]{64}$/.test(digest);
+	while (pending.length) {
+		const id = pending.pop();
+		if (visited.has(id)) continue;
+		visited.add(id);
+		const library = dependencies.libraries?.[id];
+		if (!library || !valid(library.digest)) {
+			issues.push(diagnostic("missing-dependency-digest", `Library digest is missing or invalid: ${id}`));
+			continue;
+		}
+		libraries[id] = library.digest;
+		pending.push(...library.libraries);
+		for (const asset of library.assets) requiredAssets.add(asset);
+	}
+	for (const id of requiredAssets) {
+		const digest = dependencies.assets?.[id];
+		if (!valid(digest)) issues.push(diagnostic("missing-dependency-digest", `Asset digest is missing or invalid: ${id}`));
+		else assets[id] = digest;
+	}
+	if (issues.length) throw new DesignDependencyError(issues);
+	return fileHash(canonicalSerialize({
+		document: documentContentDigest(doc),
+		libraries,
+		assets
+	}));
+}
+function parseDesign(source) {
+	try {
+		const raw = JSON.parse(source);
+		if (typeof raw !== "object" || raw === null || !("version" in raw) || typeof raw.version !== "string" || !/^\d+\.\d+$/.test(raw.version)) throw new Error("Missing or invalid format version");
+		if (raw.version.split(".")[0] !== "1") return {
+			status: "read-only",
+			raw,
+			source,
+			fileHash: fileHash(source),
+			diagnostics: [diagnostic("unknown-major", `Unsupported design version ${raw.version}`)]
+		};
+		return {
+			status: "editable",
+			document: decodeDocument(raw, { onExcessProperty: "error" }),
+			fileHash: fileHash(source),
+			diagnostics: []
+		};
+	} catch {
+		return {
+			status: "invalid",
+			source,
+			diagnostics: [diagnostic("invalid-schema", "Invalid .p4design JSON or schema")]
+		};
+	}
+}
+function patchNode(node, patch) {
+	return decodeNode({
+		...node,
+		...patch
+	}, { onExcessProperty: "error" });
+}
+function buildIndexes(doc) {
+	const parents = /* @__PURE__ */ new Map();
+	const order = /* @__PURE__ */ new Map();
+	const diagnostics = [];
+	const attach = (id, parent, index) => {
+		if (!doc.nodes[id]) diagnostics.push(diagnostic("missing-node", "Referenced node is missing", parent ?? id));
+		if (parents.has(id)) diagnostics.push(diagnostic("multiple-parents", "Node occurs in more than one ordered child list", id));
+		else {
+			parents.set(id, parent);
+			order.set(id, index);
+		}
+	};
+	doc.roots.forEach((id, i) => attach(id, null, i));
+	for (const [id, node] of Object.entries(doc.nodes)) if ("children" in node) node.children.forEach((child, i) => attach(child, id, i));
+	for (const [id, instance] of Object.entries(doc.instances)) for (const ids of Object.values(instance.slots)) ids.forEach((child, i) => attach(child, id, i));
+	const visiting = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const walk = (id, depth) => {
+		if (visiting.has(id)) {
+			diagnostics.push(diagnostic("tree-cycle", "Child lists contain a cycle", id));
+			return;
+		}
+		if (depth > 256) {
+			diagnostics.push(diagnostic("depth-limit", "Scene exceeds 256 levels", id));
+			return;
+		}
+		if (visited.has(id)) return;
+		visiting.add(id);
+		const node = doc.nodes[id];
+		if (node && "children" in node) for (const child of node.children) walk(child, depth + 1);
+		visiting.delete(id);
+		visited.add(id);
+	};
+	for (const id of Object.keys(doc.nodes)) walk(id, 0);
+	return {
+		parents,
+		order,
+		diagnostics
+	};
+}
+function resolveToken(doc, id, theme = {}, chain = /* @__PURE__ */ new Set()) {
+	if (chain.has(id)) throw new Error("token-cycle");
+	if (chain.size >= 256) throw new Error("token-depth-limit");
+	const token = doc.tokens[id];
+	if (!token) throw new Error("missing-token");
+	const next = new Set(chain).add(id);
+	const matching = token.variants.filter((v) => Object.entries(v.theme).every(([axis, value]) => theme[axis] === value));
+	matching.sort((a, b) => Object.keys(b.theme).length - Object.keys(a.theme).length);
+	if (matching[0] && matching.some((variant) => Object.keys(variant.theme).length === Object.keys(matching[0].theme).length && canonicalSerialize(variant.value) !== canonicalSerialize(matching[0].value))) throw new Error("ambiguous-token");
+	const value = matching[0]?.value ?? token.value;
+	const resolved = typeof value === "object" ? resolveToken(doc, value.tokenId, theme, next) : value;
+	if (token.kind === "number" ? typeof resolved !== "number" : typeof resolved !== "string") throw new Error("token-type");
+	if (token.kind === "color" && (typeof resolved !== "string" || !/^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/.test(resolved))) throw new Error("token-type");
+	return resolved;
+}
+function resolveValue(doc, value, theme = {}) {
+	return typeof value === "object" ? resolveToken(doc, value.tokenId, theme) : value;
+}
+function expandComponents(doc, context = {}) {
+	const diagnostics = [];
+	const expand = (source, id, key, ownerId, chain, inherited, depth) => {
+		const original = source.nodes[id];
+		if (!original) {
+			diagnostics.push(diagnostic("missing-node", "Expansion target is missing", ownerId));
+			return;
+		}
+		if (depth > 256 || chain.has(`${source.documentId}/node/${id}`)) {
+			diagnostics.push(diagnostic("component-cycle", "Expansion contains a cycle or exceeds 256 levels", ownerId));
+			return;
+		}
+		let node = original;
+		try {
+			if (inherited[id]) node = patchNode(node, inherited[id]);
+		} catch {
+			diagnostics.push(diagnostic("invalid-override", "Override does not match its source node", ownerId));
+		}
+		const next = new Set(chain).add(`${source.documentId}/node/${id}`);
+		if (node.type === "ref") {
+			const imported = node.importId ? source.imports[node.importId] : void 0;
+			const library = imported ? context.manifest?.libraries[imported.libraryId] : void 0;
+			const target = node.importId ? library?.exports.includes(node.componentId) && imported ? context.documents?.[imported.libraryId] : void 0 : source;
+			const component = target?.components[node.componentId];
+			if (!target || !component) {
+				diagnostics.push(diagnostic("missing-import", "Component or exported library symbol is unavailable", ownerId));
+				return {
+					key,
+					sourceId: id,
+					ownerId,
+					document: source,
+					node,
+					children: []
+				};
+			}
+			const instance = source.instances[id];
+			const overrides = {
+				...inherited,
+				...instance?.overrides
+			};
+			const scopedTarget = target === source ? target : {
+				...target,
+				tokens: {
+					...target.tokens,
+					...source.tokens
+				},
+				themeAxes: {
+					...target.themeAxes,
+					...source.themeAxes
+				}
+			};
+			const root = expand(scopedTarget, component.rootId, `${key}/${component.rootId}`, ownerId, next, overrides, depth + 1);
+			if (!root) return;
+			const substitute = (item) => {
+				const slot = Object.entries(component.slots).find(([, s]) => s.nodeId === item.sourceId);
+				const replacement = slot ? instance?.slots[slot[0]] : void 0;
+				if (replacement) return {
+					...item,
+					children: replacement.flatMap((child) => {
+						const expanded = expand(source, child, `${item.key}/slot/${child}`, ownerId, next, {}, depth + 1);
+						return expanded ? [expanded] : [];
+					})
+				};
+				return {
+					...item,
+					children: item.children.map(substitute)
+				};
+			};
+			const { type: _type, componentId: _componentId, importId: _importId, ...presentation } = node;
+			return {
+				...substitute(root),
+				key,
+				ownerId,
+				node: {
+					...root.node,
+					...presentation
+				}
+			};
+		}
+		const children = "children" in node ? node.children.flatMap((child) => {
+			const expanded = expand(source, child, `${key}/${child}`, ownerId === id ? child : ownerId, next, inherited, depth + 1);
+			return expanded ? [expanded] : [];
+		}) : [];
+		return {
+			key,
+			sourceId: id,
+			ownerId,
+			document: source,
+			node,
+			children
+		};
+	};
+	return {
+		roots: doc.roots.flatMap((id) => {
+			const root = expand(doc, id, id, id, /* @__PURE__ */ new Set(), {}, 0);
+			return root ? [root] : [];
+		}),
+		diagnostics
+	};
+}
+/** Select authored nodes and their rendered descendants, excluding other component instances. */
+function selectLayoutItems(items, nodeIds) {
+	const ids = new Set(nodeIds);
+	const keys = new Set(items.filter((item) => ids.has(item.ownerId)).map((item) => item.key));
+	return items.filter((item) => {
+		let key = item.key;
+		while (key) {
+			if (keys.has(key)) return true;
+			const separator = key.lastIndexOf("/");
+			if (separator < 0) break;
+			key = key.slice(0, separator);
+		}
+		return false;
+	});
+}
+function computeLayout(doc, theme = {}, context = {}) {
+	const expanded = expandComponents(doc, context);
+	const diagnostics = [...expanded.diagnostics];
+	const items = [];
+	const numeric = (item, value) => {
+		try {
+			const n = resolveValue(item.document, value, theme);
+			if (typeof n !== "number" || !Number.isFinite(n)) throw new Error("token-type");
+			return n;
+		} catch {
+			diagnostics.push(diagnostic("invalid-layout-token", "Layout value requires a finite number", item.ownerId));
+			return 0;
+		}
+	};
+	const intrinsic = /* @__PURE__ */ new Map();
+	const measure = (item) => {
+		const cached = intrinsic.get(item.key);
+		if (cached) return cached;
+		const node = item.node;
+		const children = item.children.map(measure);
+		const layout = "layout" in node ? node.layout : void 0;
+		const padding = layout ? Object.fromEntries(Object.entries(layout.padding).map(([k, v]) => [k, numeric(item, v)])) : {
+			top: 0,
+			right: 0,
+			bottom: 0,
+			left: 0
+		};
+		const gap = layout ? numeric(item, layout.gap) : 0;
+		const direction = layout?.direction ?? "none";
+		let naturalWidth = direction === "horizontal" ? children.reduce((s, c) => s + c.width, 0) + Math.max(0, children.length - 1) * gap : Math.max(0, ...children.map((c) => c.width));
+		let naturalHeight = direction === "vertical" ? children.reduce((s, c) => s + c.height, 0) + Math.max(0, children.length - 1) * gap : Math.max(0, ...children.map((c) => c.height));
+		if (direction === "none") {
+			naturalWidth = Math.max(0, ...item.children.map((c, i) => numeric(c, c.node.x) + children[i].width));
+			naturalHeight = Math.max(0, ...item.children.map((c, i) => numeric(c, c.node.y) + children[i].height));
+		}
+		if (node.type === "text") {
+			const size = numeric(item, node.fontSize);
+			const lh = node.lineHeight ? numeric(item, node.lineHeight) : 1.2;
+			const lines = node.text.split("\n");
+			naturalWidth = Math.max(0, ...lines.map((l) => l.length)) * size * .6;
+			naturalHeight = lines.length * size * lh;
+		}
+		naturalWidth += padding.left + padding.right;
+		naturalHeight += padding.top + padding.bottom;
+		const size = {
+			width: node.width.mode === "fixed" ? numeric(item, node.width.value) : node.width.mode === "hug" ? naturalWidth : 0,
+			height: node.height.mode === "fixed" ? numeric(item, node.height.value) : node.height.mode === "hug" ? naturalHeight : 0
+		};
+		for (const axis of ["width", "height"]) {
+			if (size[axis] < 0) {
+				diagnostics.push(diagnostic("negative-size", "Dimensions cannot be negative", item.ownerId));
+				size[axis] = 0;
+			}
+			if (node[axis].mode === "hug" && item.children.some((c) => c.node[axis].mode === "fill")) diagnostics.push(diagnostic("layout-cycle", "A hug dimension cannot contain fill on the same axis", item.ownerId));
+		}
+		intrinsic.set(item.key, size);
+		return size;
+	};
+	const place = (item, x, y, width, height, clips, parentVisible = true) => {
+		const bounds = {
+			x,
+			y,
+			width,
+			height
+		};
+		const visible = parentVisible && item.node.visible !== false;
+		items.push({
+			...item,
+			node: {
+				...item.node,
+				visible
+			},
+			bounds,
+			clips
+		});
+		const layout = "layout" in item.node ? item.node.layout : void 0;
+		const padding = layout ? Object.fromEntries(Object.entries(layout.padding).map(([k, v]) => [k, numeric(item, v)])) : {
+			top: 0,
+			right: 0,
+			bottom: 0,
+			left: 0
+		};
+		const gap = layout ? numeric(item, layout.gap) : 0;
+		const direction = layout?.direction ?? "none";
+		const available = {
+			width: Math.max(0, width - padding.left - padding.right),
+			height: Math.max(0, height - padding.top - padding.bottom)
+		};
+		const main = direction === "horizontal" ? "width" : "height";
+		const fillCount = item.children.filter((c) => c.node[main].mode === "fill").length;
+		const used = item.children.reduce((sum, c) => sum + (c.node[main].mode === "fill" ? 0 : measure(c)[main]), 0) + Math.max(0, item.children.length - 1) * gap;
+		const share = fillCount ? Math.max(0, available[main] - used) / fillCount : 0;
+		let offset = 0;
+		const nextClips = item.node.type === "frame" && item.node.clip ? [...clips, bounds] : clips;
+		for (const child of item.children) {
+			const natural = measure(child);
+			const size = {
+				width: child.node.width.mode === "fill" ? direction === "horizontal" ? share : available.width : natural.width,
+				height: child.node.height.mode === "fill" ? direction === "vertical" ? share : available.height : natural.height
+			};
+			const cx = x + padding.left + (direction === "horizontal" ? offset : direction === "none" ? numeric(child, child.node.x) : 0);
+			const cy = y + padding.top + (direction === "vertical" ? offset : direction === "none" ? numeric(child, child.node.y) : 0);
+			place(child, cx, cy, size.width, size.height, nextClips, visible);
+			offset += size[main] + gap;
+		}
+	};
+	for (const root of expanded.roots) {
+		const size = measure(root);
+		if (root.node.width.mode === "fill" || root.node.height.mode === "fill") diagnostics.push(diagnostic("root-fill", "Root dimensions need fixed or hug sizing", root.ownerId));
+		place(root, numeric(root, root.node.x), numeric(root, root.node.y), size.width, size.height, []);
+	}
+	return {
+		items,
+		diagnostics
+	};
+}
+function isConfinedRelativePath(path) {
+	return path.length > 0 && !path.startsWith("/") && !path.includes("\\") && !/[%?#:]/.test(path) && !Array.from(path).some((c) => c.charCodeAt(0) < 32) && path.split("/").every((p) => p !== ".." && p !== "." && p !== "");
+}
+function reviewState(doc, dependencies = {}) {
+	const blockers = Object.entries(doc.annotations).filter(([, a]) => a.blocking && a.status === "open").map(([id]) => id);
+	let revision;
+	try {
+		revision = contentHash(doc, dependencies);
+	} catch (error) {
+		if (!(error instanceof DesignDependencyError)) throw error;
+		return {
+			revision: null,
+			blockers,
+			canAccept: false,
+			approved: false,
+			diagnostics: error.diagnostics
+		};
+	}
+	const reviews = Object.values(doc.reviews).filter((r) => r.revision === revision).sort((a, b) => (a.sequence ?? 0) - (b.sequence ?? 0) || a.createdAt.localeCompare(b.createdAt));
+	return {
+		revision,
+		blockers,
+		canAccept: blockers.length === 0,
+		approved: blockers.length === 0 && reviews.at(-1)?.decision === "approve",
+		diagnostics: []
+	};
+}
+function validateDesign(doc, context = {}, theme = {}) {
+	const issues = [...buildIndexes(doc).diagnostics];
+	const validateValues = (node, source, id) => {
+		const check = (value, kind, label, nonNegative = false) => {
+			try {
+				const resolved = resolveValue(source, value, theme);
+				if (kind === "number" ? typeof resolved !== "number" || !Number.isFinite(resolved) || nonNegative && resolved < 0 : typeof resolved !== "string" || kind === "color" && !/^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/.test(resolved)) throw new Error();
+			} catch {
+				issues.push(diagnostic("invalid-property", `${label} requires a valid ${kind} value`, id));
+			}
+		};
+		if (node.stroke) check(node.stroke, "color", "Stroke");
+		if (node.strokeWidth !== void 0) check(node.strokeWidth, "number", "Stroke width", true);
+		if ("radius" in node && node.radius !== void 0) check(node.radius, "number", "Radius", true);
+		if (node.type === "text") {
+			check(node.fontSize, "number", "Font size", true);
+			check(node.fontFamily, "string", "Font family");
+			if (node.lineHeight !== void 0) check(node.lineHeight, "number", "Line height", true);
+		}
+		if ("layout" in node) {
+			check(node.layout.gap, "number", "Layout gap", true);
+			for (const value of Object.values(node.layout.padding)) check(value, "number", "Padding", true);
+		}
+		for (const fill of node.fills ?? []) {
+			if (fill.kind === "solid") check(fill.color, "color", "Fill");
+			if (fill.kind === "gradient") for (const stop of fill.stops) check(stop.color, "color", "Gradient stop");
+		}
+		for (const effect of node.effects ?? []) if (effect.kind === "shadow") {
+			check(effect.x, "number", "Shadow x");
+			check(effect.y, "number", "Shadow y");
+			check(effect.blur, "number", "Shadow blur", true);
+			check(effect.color, "color", "Shadow color");
+		} else check(effect.radius, "number", "Blur radius", true);
+	};
+	for (const [axis, value] of Object.entries(theme)) if (!doc.themeAxes[axis]?.includes(value)) issues.push(diagnostic("unknown-theme", "Theme preview value is not declared"));
+	let themes = [{}];
+	for (const [axis, values] of Object.entries(doc.themeAxes).sort(([a], [b]) => a.localeCompare(b))) {
+		const next = themes.flatMap((preview) => [preview, ...values.map((value) => ({
+			...preview,
+			[axis]: value
+		}))]);
+		if (next.length > 256) {
+			issues.push(diagnostic("theme-limit", "Theme validation exceeds 256 combinations"));
+			break;
+		}
+		themes = next;
+	}
+	for (const token of Object.values(doc.tokens)) for (const variant of token.variants) {
+		themes.push(variant.theme);
+		for (const [axis, value] of Object.entries(variant.theme)) if (!doc.themeAxes[axis]?.includes(value)) issues.push(diagnostic("unknown-theme", "Token variant uses an undeclared theme"));
+	}
+	for (const id of Object.keys(doc.tokens)) for (const preview of themes) try {
+		resolveToken(doc, id, preview);
+	} catch (e) {
+		issues.push(diagnostic(e instanceof Error ? e.message : "invalid-token", "Token could not be resolved"));
+	}
+	const covered = /* @__PURE__ */ new Set();
+	const cover = (id) => {
+		if (covered.has(id)) return;
+		covered.add(id);
+		const n = doc.nodes[id];
+		if (n && "children" in n) n.children.forEach(cover);
+	};
+	doc.roots.forEach(cover);
+	for (const c of Object.values(doc.components)) {
+		if (!doc.nodes[c.rootId]) issues.push(diagnostic("missing-component-root", "Component root is missing", c.rootId));
+		cover(c.rootId);
+		const subtree = /* @__PURE__ */ new Set();
+		const collect = (id) => {
+			if (subtree.has(id)) return;
+			subtree.add(id);
+			const n = doc.nodes[id];
+			if (n && "children" in n) n.children.forEach(collect);
+		};
+		collect(c.rootId);
+		for (const slot of Object.values(c.slots)) if (!subtree.has(slot.nodeId) || !doc.nodes[slot.nodeId] || !("children" in doc.nodes[slot.nodeId])) issues.push(diagnostic("invalid-slot", "Slot must target a container inside its component", c.rootId));
+	}
+	for (const [id, instance] of Object.entries(doc.instances)) {
+		if (doc.nodes[id]?.type !== "ref") issues.push(diagnostic("invalid-instance", "Instance metadata must target a ref node", id));
+		for (const ids of Object.values(instance.slots)) ids.forEach(cover);
+	}
+	for (const [id, node] of Object.entries(doc.nodes)) {
+		validateValues(node, doc, id);
+		if (!covered.has(id)) issues.push(diagnostic("orphan-node", "Node is outside the scene and component definitions", id));
+		if (node.type === "ref" && !doc.instances[id]) issues.push(diagnostic("missing-instance", "Ref node requires instance metadata", id));
+		if (node.type === "ref") {
+			const imported = node.importId ? doc.imports[node.importId] : void 0;
+			const lib = imported ? context.manifest?.libraries[imported.libraryId] : void 0;
+			const source = node.importId ? context.documents?.[imported?.libraryId ?? ""] : doc;
+			const comp = source?.components[node.componentId];
+			if (!comp || node.importId && (!lib || !lib.exports.includes(node.componentId))) issues.push(diagnostic("missing-import", "Component symbol is not available through the manifest", id));
+			if (comp && source) {
+				const seen = /* @__PURE__ */ new Set();
+				const collect = (n) => {
+					if (seen.has(n)) return;
+					seen.add(n);
+					const v = source.nodes[n];
+					if (v && "children" in v) v.children.forEach(collect);
+				};
+				collect(comp.rootId);
+				for (const [target, patch] of Object.entries(doc.instances[id]?.overrides ?? {})) if (!seen.has(target)) issues.push(diagnostic("invalid-override-target", "Override must target a stable source node in this component", id));
+				else try {
+					patchNode(source.nodes[target], patch);
+				} catch {
+					issues.push(diagnostic("invalid-override", "Override fields do not match the source type", id));
+				}
+				for (const [slotId, children] of Object.entries(doc.instances[id]?.slots ?? {})) {
+					const slot = comp.slots[slotId];
+					if (!slot) issues.push(diagnostic("invalid-slot", "Instance names an undeclared slot", id));
+					else for (const child of children) {
+						const n = doc.nodes[child];
+						if (slot.accepts.length && (!n || n.type !== "ref" || !slot.accepts.includes(n.componentId))) issues.push(diagnostic("slot-type", "Slot content does not match its accepted symbols", id));
+					}
+				}
+			}
+		}
+		for (const fill of node.fills ?? []) {
+			if (fill.kind === "image" && !doc.assets[fill.assetId]) issues.push(diagnostic("missing-asset", "Image asset is missing; render a placeholder", id, "warning"));
+			if (fill.kind === "gradient" && (fill.stops.length < 2 || fill.stops.some((s, i) => i > 0 && s.offset < fill.stops[i - 1].offset))) issues.push(diagnostic("gradient-stops", "Gradient needs ordered stops", id));
+		}
+		for (const value of [
+			node.x,
+			node.y,
+			node.width.mode === "fixed" ? node.width.value : 0,
+			node.height.mode === "fixed" ? node.height.value : 0
+		]) if (typeof value === "object") try {
+			if (typeof resolveToken(doc, value.tokenId, theme) !== "number") throw new Error();
+		} catch {
+			issues.push(diagnostic("token-type", "Geometry token must be numeric", id));
+		}
+	}
+	for (const asset of Object.values(doc.assets)) {
+		if (!isConfinedRelativePath(asset.path)) issues.push(diagnostic("unsafe-asset-path", "Asset path must be project-confined and relative"));
+		if (context.documentPath) {
+			const name = context.documentPath.split("/").at(-1).replace(/\.p4design$/, "");
+			if (!asset.path.startsWith(`${name}.assets/`)) issues.push(diagnostic("asset-folder", "Assets must live beside the document in its assets folder"));
+		}
+		if (context.availableAssets && !context.availableAssets.has(asset.path)) issues.push(diagnostic("missing-asset", "Asset file is unavailable; render a placeholder", void 0, "warning"));
+	}
+	for (const lib of Object.values(context.manifest?.libraries ?? {})) if (!isConfinedRelativePath(lib.path) || !lib.path.endsWith(".p4design")) issues.push(diagnostic("unsafe-library-path", "Library document path must be project-confined"));
+	for (const imported of Object.values(doc.imports)) if (!context.manifest?.libraries[imported.libraryId] || !context.documents?.[imported.libraryId]) issues.push(diagnostic("missing-import", "Declared library is unavailable"));
+	const layout = computeLayout(doc, theme, context);
+	issues.push(...layout.diagnostics);
+	for (const item of layout.items) validateValues(item.node, item.document, item.ownerId);
+	return issues.filter((issue, index) => issues.findIndex((v) => v.code === issue.code && v.nodeId === issue.nodeId && v.message === issue.message) === index);
+}
+function semanticDiff(before, after) {
+	const changes = [];
+	const walk = (a, b, path) => {
+		if (a === void 0) {
+			changes.push({
+				path,
+				kind: "added",
+				after: b
+			});
+			return;
+		}
+		if (b === void 0) {
+			changes.push({
+				path,
+				kind: "removed",
+				before: a
+			});
+			return;
+		}
+		if (canonicalSerialize(a) === canonicalSerialize(b)) return;
+		if (a && b && typeof a === "object" && typeof b === "object" && !Array.isArray(a) && !Array.isArray(b)) {
+			const aa = a, bb = b;
+			for (const k of [.../* @__PURE__ */ new Set([...Object.keys(aa), ...Object.keys(bb)])].sort()) walk(aa[k], bb[k], `${path}/${k.replaceAll("~", "~0").replaceAll("/", "~1")}`);
+		} else changes.push({
+			path,
+			kind: "changed",
+			before: a,
+			after: b
+		});
+	};
+	walk(before, after, "");
+	return changes;
+}
+//#endregion
+export { documentContentDigest as a, parseDesign as c, reviewState as d, selectLayoutItems as f, diagnostic as i, patchNode as l, validateDesign as m, canonicalSerialize as n, fileHash as o, semanticDiff as p, computeLayout as r, isConfinedRelativePath as s, buildIndexes as t, resolveValue as u };
+
+//# sourceMappingURL=runtime-DC_ewLnZ.mjs.map