hascii 0.1.0

package/dist/run-mrITeQUl.mjs

@@ -0,0 +1,1750 @@
+import { LineCounter, isMap, isPair, isScalar, isSeq, parse, parseDocument } from "yaml";
+import { z } from "zod";
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+//#region src/compiler/ansi.ts
+const ANSI = Object.freeze({
+	RESET: "\x1B[0m",
+	BOLD: "\x1B[1m",
+	DIM: "\x1B[2m",
+	RED: "\x1B[31m",
+	GREEN: "\x1B[32m",
+	YELLOW: "\x1B[33m",
+	BLUE: "\x1B[34m",
+	MAGENTA: "\x1B[35m",
+	CYAN: "\x1B[36m",
+	BRIGHT_RED: "\x1B[91m",
+	BRIGHT_BLUE: "\x1B[94m"
+});
+const COLORS = Object.freeze({
+	error: `${ANSI.BOLD}${ANSI.BRIGHT_RED}`,
+	category: `${ANSI.BOLD}${ANSI.CYAN}`,
+	location: `${ANSI.BRIGHT_BLUE}`,
+	lineNumber: `${ANSI.BRIGHT_BLUE}`,
+	gutter: `${ANSI.BRIGHT_BLUE}`,
+	arrow: `${ANSI.BRIGHT_RED}`,
+	hint: `${ANSI.YELLOW}`,
+	help: `${ANSI.GREEN}`,
+	expected: `${ANSI.GREEN}`,
+	received: `${ANSI.RED}`,
+	note: `${ANSI.CYAN}`,
+	emphasis: `${ANSI.BOLD}${ANSI.MAGENTA}`
+});
+const BOX = Object.freeze({
+	TOP: "┌",
+	VERT: "│",
+	BOTTOM: "└",
+	HORIZ: "─",
+	CROSS: "┼"
+});
+function supportsColor() {
+	if (process.env.NO_COLOR !== void 0) return false;
+	if (process.env.FORCE_COLOR !== void 0) return true;
+	if (typeof process.stdout.isTTY === "boolean") return process.stdout.isTTY;
+	return false;
+}
+function stripAnsi(text) {
+	return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function line(char, length) {
+	return char.repeat(length);
+}
+
+//#endregion
+//#region src/compiler/error-codes.ts
+const E001 = Object.freeze({
+	code: "E001",
+	title: "invalid YAML syntax",
+	hint: "check indentation and colon placement"
+});
+const E101 = Object.freeze({
+	code: "E101",
+	title: "invalid type",
+	hint: "wrong type for this value"
+});
+const E102 = Object.freeze({
+	code: "E102",
+	title: "missing required field",
+	hint: "this field is required"
+});
+const E103 = Object.freeze({
+	code: "E103",
+	title: "unexpected field",
+	hint: "unknown field, maybe a typo?"
+});
+const E104 = Object.freeze({
+	code: "E104",
+	title: "invalid array length",
+	hint: "wrong number of arguments"
+});
+const E201 = Object.freeze({
+	code: "E201",
+	title: "invalid statement",
+	hint: "unknown statement"
+});
+const E301 = Object.freeze({
+	code: "E301",
+	title: "invalid rect arguments",
+	hint: "usage: rect: [x, y, width, height]"
+});
+const E302 = Object.freeze({
+	code: "E302",
+	title: "invalid strokeStyle",
+	hint: "usage: strokeStyle: light / heavy / double / round"
+});
+const E303 = Object.freeze({
+	code: "E303",
+	title: "invalid print arguments",
+	hint: "usage: print: [text, x, y]"
+});
+const E304 = Object.freeze({
+	code: "E304",
+	title: "invalid cls usage",
+	hint: "usage: cls:"
+});
+const E305 = Object.freeze({
+	code: "E305",
+	title: "invalid color",
+	hint: "color must be 0-15"
+});
+const E401 = Object.freeze({
+	code: "E401",
+	title: "invalid expression",
+	hint: "unknown expression"
+});
+const ERROR_CODES = Object.freeze({
+	E001,
+	E101,
+	E102,
+	E103,
+	E104,
+	E201,
+	E301,
+	E302,
+	E303,
+	E304,
+	E305,
+	E401
+});
+function mapZodCodeToErrorCode(zodCode, path$1) {
+	if (zodCode === "invalid_type") return E101;
+	if (zodCode === "invalid_union") {
+		const lastKey = path$1[path$1.length - 1];
+		if (lastKey === "rect") return E301;
+		if (lastKey === "strokeStyle") return E302;
+		if (lastKey === "print") return E303;
+		if (lastKey === "cls") return E304;
+		return E201;
+	}
+	if (zodCode === "too_small" || zodCode === "too_big") {
+		const lastKey = path$1[path$1.length - 1];
+		if (lastKey === "fill" || lastKey === "stroke") return E305;
+		return E104;
+	}
+	if (zodCode === "unrecognized_keys") return E103;
+	return E101;
+}
+
+//#endregion
+//#region src/core/safe-key.ts
+const DANGEROUS_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype",
+	"__defineGetter__",
+	"__defineSetter__",
+	"__lookupGetter__",
+	"__lookupSetter__"
+]);
+function isSafeKey(key) {
+	return !DANGEROUS_KEYS.has(key);
+}
+function isSafePath(path$1) {
+	return path$1.split(".").every(isSafeKey);
+}
+
+//#endregion
+//#region src/compiler/evaluate.ts
+const MAX_DEPTH = 100;
+const VARIABLE_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
+function isVariableName(str) {
+	return VARIABLE_PATTERN.test(str);
+}
+function getVariable(state, path$1) {
+	if (!isSafePath(path$1)) return 0;
+	const parts = path$1.split(".");
+	let current = state;
+	for (const part of parts) {
+		if (typeof current !== "object" || current === null || Array.isArray(current)) return 0;
+		current = current[part] ?? 0;
+	}
+	return current;
+}
+function evaluate(expr, state, depth = 0) {
+	if (depth > MAX_DEPTH) return 0;
+	if (typeof expr === "number") return expr;
+	if (typeof expr === "string") {
+		if (isVariableName(expr)) return getVariable(state, expr);
+		return expr;
+	}
+	if (Array.isArray(expr)) {
+		const d = depth + 1;
+		return Object.freeze(expr.map((item) => evaluate(item, state, d)));
+	}
+	if (typeof expr === "object" && expr !== null) {
+		const d = depth + 1;
+		if ("add" in expr) return evaluate(expr.add[0], state, d) + evaluate(expr.add[1], state, d);
+		if ("sub" in expr) return evaluate(expr.sub[0], state, d) - evaluate(expr.sub[1], state, d);
+		if ("mul" in expr) return evaluate(expr.mul[0], state, d) * evaluate(expr.mul[1], state, d);
+		if ("div" in expr) {
+			const left = evaluate(expr.div[0], state, d);
+			const right = evaluate(expr.div[1], state, d);
+			return right !== 0 ? left / right : 0;
+		}
+		if ("mod" in expr) {
+			const left = evaluate(expr.mod[0], state, d);
+			const right = evaluate(expr.mod[1], state, d);
+			return right !== 0 ? left % right : 0;
+		}
+		if ("abs" in expr) return Math.abs(evaluate(expr.abs, state, d));
+		if ("neg" in expr) return -evaluate(expr.neg, state, d);
+		if ("floor" in expr) return Math.floor(evaluate(expr.floor, state, d));
+		if ("ceil" in expr) return Math.ceil(evaluate(expr.ceil, state, d));
+		if ("round" in expr) return Math.round(evaluate(expr.round, state, d));
+		if ("sqrt" in expr) return Math.sqrt(evaluate(expr.sqrt, state, d));
+		if ("sin" in expr) return Math.sin(evaluate(expr.sin, state, d));
+		if ("cos" in expr) return Math.cos(evaluate(expr.cos, state, d));
+		if ("pow" in expr) return evaluate(expr.pow[0], state, d) ** evaluate(expr.pow[1], state, d);
+		if ("min" in expr) {
+			const left = evaluate(expr.min[0], state, d);
+			const right = evaluate(expr.min[1], state, d);
+			return Math.min(left, right);
+		}
+		if ("max" in expr) {
+			const left = evaluate(expr.max[0], state, d);
+			const right = evaluate(expr.max[1], state, d);
+			return Math.max(left, right);
+		}
+		if ("rnd" in expr) {
+			const min = evaluate(expr.rnd[0], state, d);
+			const max = evaluate(expr.rnd[1], state, d);
+			return Math.floor(Math.random() * (max - min + 1)) + min;
+		}
+		if ("eq" in expr) return evaluate(expr.eq[0], state, d) === evaluate(expr.eq[1], state, d) ? 1 : 0;
+		if ("lt" in expr) return evaluate(expr.lt[0], state, d) < evaluate(expr.lt[1], state, d) ? 1 : 0;
+		if ("lte" in expr) return evaluate(expr.lte[0], state, d) <= evaluate(expr.lte[1], state, d) ? 1 : 0;
+		if ("gt" in expr) return evaluate(expr.gt[0], state, d) > evaluate(expr.gt[1], state, d) ? 1 : 0;
+		if ("gte" in expr) return evaluate(expr.gte[0], state, d) >= evaluate(expr.gte[1], state, d) ? 1 : 0;
+		if ("and" in expr) {
+			const args = expr.and;
+			for (const arg of args) if (!evaluate(arg, state, d)) return 0;
+			return 1;
+		}
+		if ("or" in expr) {
+			const args = expr.or;
+			for (const arg of args) if (evaluate(arg, state, d)) return 1;
+			return 0;
+		}
+		if ("not" in expr) return evaluate(expr.not, state, d) ? 0 : 1;
+		if ("at" in expr) {
+			const arr = evaluate(expr.at[0], state, d);
+			const idx = evaluate(expr.at[1], state, d);
+			if (Array.isArray(arr) && Number.isInteger(idx) && idx >= 0) return arr[idx] ?? 0;
+			return 0;
+		}
+		if ("len" in expr) {
+			const arr = evaluate(expr.len, state, d);
+			if (Array.isArray(arr)) return arr.length;
+			return 0;
+		}
+	}
+	return 0;
+}
+
+//#endregion
+//#region src/compiler/diagnostic.ts
+function categorize(zodCode, path$1) {
+	if (zodCode === "invalid_type") return "TYPE_MISMATCH";
+	if (zodCode === "invalid_union") {
+		const lastKey = path$1[path$1.length - 1];
+		if (lastKey === "rect" || lastKey === "circ" || lastKey === "print" || lastKey === "cls") return "INVALID_ARGS";
+		return "INVALID_STATEMENT";
+	}
+	if (zodCode === "too_small" || zodCode === "too_big") {
+		if (path$1[path$1.length - 1] === "cls") return "INVALID_COLOR";
+		return "INVALID_ARGS";
+	}
+	if (zodCode === "unrecognized_keys") return "UNKNOWN_FIELD";
+	return "TYPE_MISMATCH";
+}
+function categoryTitle(category) {
+	return {
+		TYPE_MISMATCH: "TYPE MISMATCH",
+		MISSING_FIELD: "MISSING FIELD",
+		UNKNOWN_FIELD: "UNKNOWN FIELD",
+		INVALID_SYNTAX: "INVALID SYNTAX",
+		INVALID_STATEMENT: "INVALID STATEMENT",
+		INVALID_ARGS: "INVALID ARGUMENTS",
+		INVALID_COLOR: "INVALID COLOR"
+	}[category];
+}
+function extractDiagnostic(issue, _sourceLine) {
+	const path$1 = issue.path.filter((p) => typeof p === "string" || typeof p === "number");
+	const errorCode = mapZodCodeToErrorCode(issue.code, path$1);
+	const category = categorize(issue.code, path$1);
+	let expected;
+	let received;
+	const issueAny = issue;
+	if (issue.code === "invalid_type") {
+		expected = issueAny.expected;
+		received = issueAny.received;
+	}
+	return Object.freeze({
+		category,
+		code: errorCode.code,
+		title: categoryTitle(category),
+		hint: errorCode.hint,
+		path: Object.freeze(path$1),
+		expected,
+		received
+	});
+}
+
+//#endregion
+//#region src/compiler/source-map/create.ts
+function createSourceMap(source) {
+	const lineCounter = new LineCounter();
+	const doc = parseDocument(source, { lineCounter });
+	const entries = [];
+	const lines = Object.freeze(source.split("\n"));
+	function traverse(node, currentPath) {
+		if (isMap(node)) {
+			const map = node;
+			for (const item of map.items) if (isPair(item)) {
+				const pair = item;
+				const key = isScalar(pair.key) ? pair.key.value : null;
+				if (key !== null && typeof key === "string") {
+					const keyPath = Object.freeze([...currentPath, key]);
+					const value = pair.value;
+					if (value?.range) {
+						const range = value.range;
+						const pos = lineCounter.linePos(range[0]);
+						entries.push(Object.freeze({
+							path: keyPath,
+							location: Object.freeze({
+								line: pos.line,
+								column: pos.col,
+								offset: range[0],
+								length: range[1] - range[0]
+							})
+						}));
+					}
+					traverse(pair.value, keyPath);
+				}
+			}
+		}
+		if (isSeq(node)) {
+			const seq = node;
+			for (let i = 0; i < seq.items.length; i++) {
+				const item = seq.items[i];
+				const indexPath = Object.freeze([...currentPath, i]);
+				if (item?.range) {
+					const range = item.range;
+					const pos = lineCounter.linePos(range[0]);
+					entries.push(Object.freeze({
+						path: indexPath,
+						location: Object.freeze({
+							line: pos.line,
+							column: pos.col,
+							offset: range[0],
+							length: range[1] - range[0]
+						})
+					}));
+				}
+				traverse(item, indexPath);
+			}
+		}
+	}
+	traverse(doc.contents, Object.freeze([]));
+	return Object.freeze({
+		entries: Object.freeze(entries),
+		source,
+		lines
+	});
+}
+
+//#endregion
+//#region src/compiler/source-map/query.ts
+function pathEquals(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+function findLocation(sourceMap, path$1) {
+	for (const entry of sourceMap.entries) if (pathEquals(entry.path, path$1)) return entry.location;
+	for (let len = path$1.length - 1; len > 0; len--) {
+		const partialPath = path$1.slice(0, len);
+		for (const entry of sourceMap.entries) if (pathEquals(entry.path, partialPath)) return entry.location;
+	}
+	return null;
+}
+function getSourceLine(sourceMap, lineNumber) {
+	if (lineNumber < 1 || lineNumber > sourceMap.lines.length) return "";
+	return sourceMap.lines[lineNumber - 1] ?? "";
+}
+
+//#endregion
+//#region src/core/errors.ts
+var HasciiError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "HasciiError";
+	}
+};
+var HasciiParseError = class extends HasciiError {
+	source;
+	constructor(message, source = "") {
+		super(message);
+		this.name = "HasciiParseError";
+		this.source = source;
+		Object.freeze(this);
+	}
+};
+var HasciiValidationError = class extends HasciiError {
+	issues;
+	source;
+	constructor(message, issues = [], source = "") {
+		super(message);
+		this.name = "HasciiValidationError";
+		this.issues = Object.freeze([...issues]);
+		this.source = source;
+		Object.freeze(this);
+	}
+};
+var HasciiRuntimeError = class extends HasciiError {
+	constructor(message) {
+		super(message);
+		this.name = "HasciiRuntimeError";
+		Object.freeze(this);
+	}
+};
+
+//#endregion
+//#region src/compiler/formatter.ts
+const HEADER_WIDTH = 60;
+function formatHeader(title) {
+	const padding = HEADER_WIDTH - title.length - 6;
+	const left = Math.floor(padding / 2);
+	const right = padding - left;
+	return `${COLORS.category}${line(BOX.HORIZ, left)} ${title} ${line(BOX.HORIZ, right)}${ANSI.RESET}`;
+}
+function formatValidationDiagnostic(issue, sourceMap) {
+	const location = findLocation(sourceMap, issue.path);
+	const diag = extractDiagnostic(issue, location ? getSourceLine(sourceMap, location.line) : void 0);
+	const lines = [];
+	lines.push(formatHeader(diag.title));
+	lines.push("");
+	if (diag.category === "TYPE_MISMATCH" && diag.expected && diag.received) lines.push(`I was expecting a ${COLORS.expected}${diag.expected}${ANSI.RESET} but found a ${COLORS.received}${diag.received}${ANSI.RESET}:`);
+	else if (diag.category === "INVALID_STATEMENT") lines.push("I don't recognize this statement:");
+	else if (diag.category === "INVALID_ARGS") lines.push("The arguments for this command are not right:");
+	else if (diag.category === "INVALID_COLOR") lines.push("This color is not in the palette:");
+	else lines.push("I found a problem here:");
+	lines.push("");
+	if (location) {
+		const gutter = " ".repeat(String(location.line).length);
+		lines.push(`  ${COLORS.gutter}${BOX.TOP}${BOX.HORIZ}${ANSI.RESET} ${COLORS.location}${location.line}:${location.column}${ANSI.RESET}`);
+		lines.push(`  ${COLORS.gutter}${BOX.VERT}${ANSI.RESET}`);
+		const sourceLine = getSourceLine(sourceMap, location.line);
+		lines.push(`${COLORS.lineNumber}${location.line}${ANSI.RESET} ${COLORS.gutter}${BOX.VERT}${ANSI.RESET} ${sourceLine}`);
+		const underlineLength = Math.max(1, Math.min(location.length, 20));
+		const padding = " ".repeat(Math.max(0, location.column - 1));
+		const underline = "^".repeat(underlineLength);
+		lines.push(`${gutter} ${COLORS.gutter}${BOX.VERT}${ANSI.RESET} ${padding}${COLORS.arrow}${underline}${ANSI.RESET}`);
+		lines.push(`  ${COLORS.gutter}${BOX.VERT}${ANSI.RESET}`);
+	}
+	lines.push(`  ${COLORS.gutter}${BOX.BOTTOM}${BOX.HORIZ}${ANSI.RESET} ${COLORS.hint}ℹ${ANSI.RESET} ${diag.hint}`);
+	return lines.join("\n");
+}
+function formatParseDiagnostic(message, sourceMap) {
+	const lines = [];
+	const lineMatch = message.match(/at line (\d+)/i);
+	const colMatch = message.match(/column (\d+)/i);
+	const lineNum = lineMatch ? parseInt(lineMatch[1], 10) : 1;
+	const column = colMatch ? parseInt(colMatch[1], 10) : 1;
+	const gutter = " ".repeat(String(lineNum).length);
+	lines.push(formatHeader("INVALID SYNTAX"));
+	lines.push("");
+	lines.push("I couldn't parse this YAML:");
+	lines.push("");
+	lines.push(`  ${COLORS.gutter}${BOX.TOP}${BOX.HORIZ}${ANSI.RESET} ${COLORS.location}${lineNum}:${column}${ANSI.RESET}`);
+	lines.push(`  ${COLORS.gutter}${BOX.VERT}${ANSI.RESET}`);
+	const sourceLine = getSourceLine(sourceMap, lineNum);
+	lines.push(`${COLORS.lineNumber}${lineNum}${ANSI.RESET} ${COLORS.gutter}${BOX.VERT}${ANSI.RESET} ${sourceLine}`);
+	const padding = " ".repeat(Math.max(0, column - 1));
+	lines.push(`${gutter} ${COLORS.gutter}${BOX.VERT}${ANSI.RESET} ${padding}${COLORS.arrow}^${ANSI.RESET}`);
+	lines.push(`  ${COLORS.gutter}${BOX.VERT}${ANSI.RESET}`);
+	lines.push(`  ${COLORS.gutter}${BOX.BOTTOM}${BOX.HORIZ}${ANSI.RESET} ${COLORS.hint}ℹ${ANSI.RESET} Check YAML indentation and bracket matching`);
+	return lines.join("\n");
+}
+function formatError(error) {
+	const sourceMap = createSourceMap(error.source);
+	if (error instanceof HasciiValidationError) return error.issues.map((issue) => formatValidationDiagnostic(issue, sourceMap)).join("\n\n");
+	return formatParseDiagnostic(error.message, sourceMap);
+}
+
+//#endregion
+//#region src/core/models.ts
+const colorSchema = z.number().int().min(0).max(15);
+const strokeStyleSchema = z.enum([
+	"light",
+	"heavy",
+	"double",
+	"round"
+]);
+const valueSchema = z.lazy(() => z.union([
+	z.number(),
+	z.string(),
+	z.boolean(),
+	z.array(valueSchema),
+	z.record(z.string(), valueSchema)
+]));
+const expressionSchema = z.lazy(() => z.union([
+	z.number(),
+	z.string(),
+	z.object({ add: z.tuple([expressionSchema, expressionSchema]) }),
+	z.object({ sub: z.tuple([expressionSchema, expressionSchema]) }),
+	z.object({ mul: z.tuple([expressionSchema, expressionSchema]) }),
+	z.object({ div: z.tuple([expressionSchema, expressionSchema]) }),
+	z.object({ mod: z.tuple([expressionSchema, expressionSchema]) }),
+	z.object({ pow: z.tuple([expressionSchema, expressionSchema]) }),
+	z.object({ abs: expressionSchema }),
+	z.object({ neg: expressionSchema }),
+	z.object({ floor: expressionSchema }),
+	z.object({ ceil: expressionSchema }),
+	z.object({ round: expressionSchema }),
+	z.object({ sqrt: expressionSchema }),
+	z.object({ sin: expressionSchema }),
+	z.object({ cos: expressionSchema }),
+	z.object({ min: z.tuple([expressionSchema, expressionSchema]) }),
+	z.object({ max: z.tuple([expressionSchema, expressionSchema]) }),
+	z.object({ rnd: z.tuple([expressionSchema, expressionSchema]) }),
+	z.object({ eq: z.tuple([expressionSchema, expressionSchema]) }),
+	z.object({ lt: z.tuple([expressionSchema, expressionSchema]) }),
+	z.object({ lte: z.tuple([expressionSchema, expressionSchema]) }),
+	z.object({ gt: z.tuple([expressionSchema, expressionSchema]) }),
+	z.object({ gte: z.tuple([expressionSchema, expressionSchema]) }),
+	z.object({ and: z.array(expressionSchema).min(2) }),
+	z.object({ or: z.array(expressionSchema).min(2) }),
+	z.object({ not: expressionSchema }),
+	z.object({ at: z.tuple([expressionSchema, expressionSchema]) }),
+	z.object({ len: expressionSchema })
+]));
+const setValueSchema = z.lazy(() => z.union([expressionSchema, z.array(setValueSchema)]));
+const setStatementSchema = z.object({ set: z.record(z.string(), setValueSchema) }).strict();
+const ifStatementSchema = z.object({
+	if: expressionSchema,
+	then: z.array(z.lazy(() => statementSchema)).optional(),
+	else: z.array(z.lazy(() => statementSchema)).optional(),
+	set: z.record(z.string(), setValueSchema).optional()
+});
+const eachStatementSchema = z.object({
+	each: z.string(),
+	as: z.string(),
+	index: z.string().optional(),
+	do: z.array(z.lazy(() => statementSchema))
+});
+const pushStatementSchema = z.object({ push: z.object({
+	to: z.string(),
+	item: expressionSchema
+}) });
+const filterStatementSchema = z.object({ filter: z.object({
+	list: z.string(),
+	as: z.string(),
+	cond: expressionSchema
+}) });
+const fillStatementSchema = z.object({ fill: expressionSchema });
+const strokeStatementSchema = z.object({ stroke: expressionSchema });
+const noFillStatementSchema = z.object({ noFill: z.union([z.literal(true), z.null()]) }).strict();
+const noStrokeStatementSchema = z.object({ noStroke: z.union([z.literal(true), z.null()]) }).strict();
+const strokeStyleStatementSchema = z.object({ strokeStyle: strokeStyleSchema });
+const clsStatementSchema = z.object({ cls: z.union([z.literal(true), z.null()]) }).strict();
+const rectStatementSchema = z.object({ rect: z.tuple([
+	expressionSchema,
+	expressionSchema,
+	expressionSchema,
+	expressionSchema
+]) });
+const printStatementSchema = z.object({ print: z.tuple([
+	expressionSchema,
+	expressionSchema,
+	expressionSchema
+]) });
+const waveTypeSchema = z.enum([
+	"tri",
+	"saw",
+	"sqr",
+	"pls",
+	"org",
+	"noi",
+	"pha",
+	"sin"
+]);
+const effectTypeSchema = z.enum([
+	"pitchUp",
+	"vibrato",
+	"pitchDown",
+	"fadeIn",
+	"fadeOut"
+]);
+const sfxStatementSchema = z.object({ sfx: z.object({
+	wave: waveTypeSchema,
+	freq: expressionSchema,
+	length: expressionSchema,
+	volume: expressionSchema,
+	effect: effectTypeSchema.optional()
+}) });
+const statementSchema = z.lazy(() => z.union([
+	setStatementSchema,
+	ifStatementSchema,
+	eachStatementSchema,
+	pushStatementSchema,
+	filterStatementSchema,
+	fillStatementSchema,
+	strokeStatementSchema,
+	noFillStatementSchema,
+	noStrokeStatementSchema,
+	strokeStyleStatementSchema,
+	clsStatementSchema,
+	rectStatementSchema,
+	printStatementSchema,
+	sfxStatementSchema
+]));
+const channelNoteSchema = z.object({
+	pitch: z.number().int().min(-1).max(11),
+	octave: z.number().int().min(2).max(5).optional(),
+	volume: z.number().int().min(0).max(7).optional(),
+	effect: z.number().int().min(0).max(5).optional()
+});
+const patternSchema = z.object({ steps: z.array(z.array(channelNoteSchema)) });
+const trackerSchema = z.object({
+	bpm: z.number().int().min(60).max(480).optional(),
+	items: z.array(patternSchema).optional()
+});
+const musicNoteSchema = z.object({
+	time: z.number().min(0),
+	pitch: z.number().int().min(0).max(11),
+	octave: z.number().int().min(2).max(5).optional(),
+	duration: z.number().min(.0625).optional(),
+	volume: z.number().int().min(0).max(7).optional()
+});
+const musicTrackSchema = z.object({
+	channel: z.number().int().min(0).max(3).optional(),
+	wave: waveTypeSchema.optional(),
+	notes: z.array(musicNoteSchema)
+});
+const songSchema = z.object({
+	name: z.string().max(16).optional(),
+	bpm: z.number().int().min(60).max(480).optional(),
+	tracks: z.array(musicTrackSchema)
+});
+const musicSchema = z.array(songSchema).max(8);
+const descriptionSchema = z.string().max(80).regex(/^[a-zA-Z0-9 .,!?'\-:]*$/);
+const baseMetaSchema = z.object({
+	title: z.string().min(2).max(8),
+	frame: colorSchema,
+	bg: colorSchema,
+	art: z.array(z.string()).length(5),
+	description: descriptionSchema.optional()
+});
+const gameCartridgeSchema = z.object({
+	meta: baseMetaSchema.extend({ type: z.literal("game") }).optional(),
+	init: z.record(z.string(), valueSchema).optional().default({}),
+	update: z.array(statementSchema).optional().default([]),
+	draw: z.array(statementSchema).optional().default([])
+});
+const trackerCartridgeSchema = z.object({
+	meta: baseMetaSchema.extend({ type: z.literal("tracker") }),
+	tracker: trackerSchema
+});
+const musicCartridgeSchema = z.object({
+	meta: baseMetaSchema.extend({ type: z.literal("music") }),
+	music: musicSchema
+});
+const legacyCartridgeSchema = z.object({
+	meta: baseMetaSchema.optional(),
+	init: z.record(z.string(), valueSchema).optional().default({}),
+	update: z.array(statementSchema).optional().default([]),
+	draw: z.array(statementSchema).optional().default([])
+});
+const hasciiProgramSchema = z.union([
+	trackerCartridgeSchema,
+	musicCartridgeSchema,
+	gameCartridgeSchema,
+	legacyCartridgeSchema
+]);
+
+//#endregion
+//#region src/compiler/parser.ts
+function compile(source) {
+	let doc;
+	try {
+		doc = parse(source);
+	} catch (e) {
+		return new HasciiParseError(e instanceof Error ? e.message : String(e), source);
+	}
+	const result = hasciiProgramSchema.safeParse(doc);
+	if (!result.success) return new HasciiValidationError(result.error.message, result.error.issues, source);
+	return Object.freeze(result.data);
+}
+
+//#endregion
+//#region src/runtime/button-state.ts
+const EMPTY_BUTTON_STATE = Object.freeze({
+	left: 0,
+	right: 0,
+	up: 0,
+	down: 0,
+	a: 0,
+	b: 0
+});
+const EMPTY_KEY_TIMESTAMPS = Object.freeze({
+	left: 0,
+	right: 0,
+	up: 0,
+	down: 0,
+	a: 0,
+	b: 0
+});
+function createButtonState() {
+	return EMPTY_BUTTON_STATE;
+}
+function createKeyTimestamps() {
+	return EMPTY_KEY_TIMESTAMPS;
+}
+function updateKeyTimestamps(timestamps, btn, now) {
+	return Object.freeze({
+		left: btn.left ? now : timestamps.left,
+		right: btn.right ? now : timestamps.right,
+		up: btn.up ? now : timestamps.up,
+		down: btn.down ? now : timestamps.down,
+		a: btn.a ? now : timestamps.a,
+		b: btn.b ? now : timestamps.b
+	});
+}
+function getActiveButtons(timestamps, now, holdMs) {
+	return Object.freeze({
+		left: now - timestamps.left < holdMs ? 1 : 0,
+		right: now - timestamps.right < holdMs ? 1 : 0,
+		up: now - timestamps.up < holdMs ? 1 : 0,
+		down: now - timestamps.down < holdMs ? 1 : 0,
+		a: now - timestamps.a < holdMs ? 1 : 0,
+		b: now - timestamps.b < holdMs ? 1 : 0
+	});
+}
+function getPressedButtons(prev, curr) {
+	return Object.freeze({
+		left: prev.left === 0 && curr.left === 1 ? 1 : 0,
+		right: prev.right === 0 && curr.right === 1 ? 1 : 0,
+		up: prev.up === 0 && curr.up === 1 ? 1 : 0,
+		down: prev.down === 0 && curr.down === 1 ? 1 : 0,
+		a: prev.a === 0 && curr.a === 1 ? 1 : 0,
+		b: prev.b === 0 && curr.b === 1 ? 1 : 0
+	});
+}
+const VALID_KEYS = Object.freeze(new Set(["z", "x"]));
+const ARROW_UP = "\x1B[A";
+const ARROW_DOWN = "\x1B[B";
+const ARROW_RIGHT = "\x1B[C";
+const ARROW_LEFT = "\x1B[D";
+function isValidKey(key) {
+	return VALID_KEYS.has(key.toLowerCase());
+}
+function processKeyInput(key) {
+	const seq = key.toString();
+	const lower = seq.toLowerCase();
+	if (seq === ARROW_UP) return Object.freeze({
+		...EMPTY_BUTTON_STATE,
+		up: 1
+	});
+	if (seq === ARROW_DOWN) return Object.freeze({
+		...EMPTY_BUTTON_STATE,
+		down: 1
+	});
+	if (seq === ARROW_LEFT) return Object.freeze({
+		...EMPTY_BUTTON_STATE,
+		left: 1
+	});
+	if (seq === ARROW_RIGHT) return Object.freeze({
+		...EMPTY_BUTTON_STATE,
+		right: 1
+	});
+	if (!VALID_KEYS.has(lower)) return EMPTY_BUTTON_STATE;
+	return Object.freeze({
+		left: 0,
+		right: 0,
+		up: 0,
+		down: 0,
+		a: lower === "z" ? 1 : 0,
+		b: lower === "x" ? 1 : 0
+	});
+}
+
+//#endregion
+//#region src/core/constants.ts
+const CANVAS_WIDTH = 80;
+const CANVAS_HEIGHT = 22;
+const VIEW_WIDTH = 80;
+const VIEW_HEIGHT = 22;
+const ENABLE_SPRITE_EDITOR = false;
+const ENABLE_MAP_EDITOR = false;
+const DEFAULT_VOLUME = 4;
+const DEFAULT_OCTAVE = 4;
+
+//#endregion
+//#region src/runtime/set-variable.ts
+function setVariable(state, path$1, value) {
+	if (!isSafePath(path$1)) return state;
+	const parts = path$1.split(".");
+	if (parts.length === 1) {
+		if (!isSafeKey(path$1)) return state;
+		return {
+			...state,
+			[path$1]: value
+		};
+	}
+	const newState = { ...state };
+	let current = newState;
+	for (let i = 0; i < parts.length - 1; i++) {
+		const part = parts[i];
+		if (!part || !isSafeKey(part)) return state;
+		if (typeof current[part] !== "object" || Array.isArray(current[part])) current[part] = {};
+		current[part] = { ...current[part] };
+		current = current[part];
+	}
+	const lastPart = parts[parts.length - 1];
+	if (!lastPart || !isSafeKey(lastPart)) return state;
+	current[lastPart] = value;
+	return newState;
+}
+
+//#endregion
+//#region src/runtime/interpreter/execute.ts
+const DEFAULT_DRAW_STATE = Object.freeze({
+	fill: 7,
+	stroke: 7,
+	strokeStyle: "light"
+});
+function createDrawState() {
+	return DEFAULT_DRAW_STATE;
+}
+function executeStatements(statements, state, drawState = DEFAULT_DRAW_STATE) {
+	return statements.reduce((acc, stmt) => {
+		const result = executeStatement(stmt, acc.state, acc.drawState);
+		return Object.freeze({
+			state: result.state,
+			commands: Object.freeze([...acc.commands, ...result.commands]),
+			drawState: result.drawState
+		});
+	}, Object.freeze({
+		state,
+		commands: Object.freeze([]),
+		drawState
+	}));
+}
+function executeStatement(stmt, state, drawState) {
+	const emptyResult = Object.freeze({
+		state,
+		commands: Object.freeze([]),
+		drawState
+	});
+	if ("set" in stmt && !("if" in stmt)) {
+		const newState = Object.keys(stmt.set).reduce((s, key) => {
+			return setVariable(s, key, evaluate(stmt.set[key], s));
+		}, state);
+		return Object.freeze({
+			...emptyResult,
+			state: newState
+		});
+	}
+	if ("if" in stmt) {
+		if (evaluate(stmt.if, state)) {
+			let currentState = state;
+			if (stmt.set) currentState = Object.keys(stmt.set).reduce((s, key) => {
+				return setVariable(s, key, evaluate(stmt.set?.[key], s));
+			}, state);
+			if (stmt.then) return executeStatements(stmt.then, currentState, drawState);
+			return Object.freeze({
+				...emptyResult,
+				state: currentState
+			});
+		}
+		if (stmt.else) return executeStatements(stmt.else, state, drawState);
+		return emptyResult;
+	}
+	if ("each" in stmt) {
+		const arr = state[stmt.each];
+		if (!Array.isArray(arr)) return emptyResult;
+		return arr.slice(0, 1e3).reduce((acc, item, i) => {
+			if (item === void 0) return acc;
+			const loopState = Object.freeze({
+				...acc.state,
+				[stmt.as]: item,
+				...stmt.index ? { [stmt.index]: i } : {}
+			});
+			const result = executeStatements(stmt.do, loopState, acc.drawState);
+			const currentArr = acc.state[stmt.each];
+			const updatedItem = result.state[stmt.as];
+			const newState = Array.isArray(currentArr) && updatedItem !== void 0 ? Object.freeze({
+				...result.state,
+				[stmt.each]: Object.freeze(currentArr.map((v, idx) => idx === i ? updatedItem : v))
+			}) : result.state;
+			return Object.freeze({
+				state: newState,
+				commands: Object.freeze([...acc.commands, ...result.commands]),
+				drawState: result.drawState
+			});
+		}, Object.freeze({
+			state,
+			commands: Object.freeze([]),
+			drawState
+		}));
+	}
+	if ("push" in stmt) {
+		const arr = state[stmt.push.to];
+		if (!Array.isArray(arr)) return emptyResult;
+		const item = evaluate(stmt.push.item, state);
+		const newArr = Object.freeze([...arr, item]);
+		return Object.freeze({
+			...emptyResult,
+			state: Object.freeze({
+				...state,
+				[stmt.push.to]: newArr
+			})
+		});
+	}
+	if ("filter" in stmt) {
+		const arr = state[stmt.filter.list];
+		if (!Array.isArray(arr)) return emptyResult;
+		const filtered = arr.filter((item, idx) => {
+			const loopState = Object.freeze({
+				...state,
+				[stmt.filter.as]: item,
+				i: idx
+			});
+			const result = evaluate(stmt.filter.cond, loopState);
+			return Boolean(result);
+		});
+		return Object.freeze({
+			...emptyResult,
+			state: Object.freeze({
+				...state,
+				[stmt.filter.list]: Object.freeze(filtered)
+			})
+		});
+	}
+	if ("fill" in stmt) {
+		const fillValue = evaluate(stmt.fill, state);
+		const fill = typeof fillValue === "number" ? Math.floor(fillValue) % 16 : 0;
+		return Object.freeze({
+			...emptyResult,
+			drawState: Object.freeze({
+				...drawState,
+				fill
+			})
+		});
+	}
+	if ("stroke" in stmt) {
+		const strokeValue = evaluate(stmt.stroke, state);
+		const stroke = typeof strokeValue === "number" ? Math.floor(strokeValue) % 16 : 7;
+		return Object.freeze({
+			...emptyResult,
+			drawState: Object.freeze({
+				...drawState,
+				stroke
+			})
+		});
+	}
+	if ("noFill" in stmt) return Object.freeze({
+		...emptyResult,
+		drawState: Object.freeze({
+			...drawState,
+			fill: null
+		})
+	});
+	if ("noStroke" in stmt) return Object.freeze({
+		...emptyResult,
+		drawState: Object.freeze({
+			...drawState,
+			stroke: null
+		})
+	});
+	if ("strokeStyle" in stmt) return Object.freeze({
+		...emptyResult,
+		drawState: Object.freeze({
+			...drawState,
+			strokeStyle: stmt.strokeStyle
+		})
+	});
+	if ("cls" in stmt) {
+		const bg = drawState.fill ?? 0;
+		return Object.freeze({
+			...emptyResult,
+			commands: Object.freeze([{
+				type: "cls",
+				bg
+			}])
+		});
+	}
+	if ("rect" in stmt) {
+		const x = evaluate(stmt.rect[0], state);
+		const y = evaluate(stmt.rect[1], state);
+		const w = evaluate(stmt.rect[2], state);
+		const h = evaluate(stmt.rect[3], state);
+		return Object.freeze({
+			...emptyResult,
+			commands: Object.freeze([{
+				type: "rect",
+				x,
+				y,
+				w,
+				h,
+				fill: drawState.fill,
+				stroke: drawState.stroke,
+				strokeStyle: drawState.strokeStyle
+			}])
+		});
+	}
+	if ("print" in stmt) {
+		const text = String(evaluate(stmt.print[0], state));
+		const x = evaluate(stmt.print[1], state);
+		const y = evaluate(stmt.print[2], state);
+		return Object.freeze({
+			...emptyResult,
+			commands: Object.freeze([{
+				type: "print",
+				text,
+				x,
+				y,
+				fg: drawState.stroke ?? 7,
+				bg: drawState.fill
+			}])
+		});
+	}
+	if ("sfx" in stmt) {
+		const freq = evaluate(stmt.sfx.freq, state);
+		const length = evaluate(stmt.sfx.length, state);
+		const volume = evaluate(stmt.sfx.volume, state);
+		return Object.freeze({
+			...emptyResult,
+			commands: Object.freeze([{
+				type: "sfx",
+				wave: stmt.sfx.wave,
+				freq,
+				length,
+				volume,
+				effect: stmt.sfx.effect ?? null
+			}])
+		});
+	}
+	return emptyResult;
+}
+
+//#endregion
+//#region src/runtime/game.ts
+/**
+* Game engine - Pure functions for game state management
+*/
+/**
+* Create a new game instance from a program
+*/
+function createGame(program) {
+	return Object.freeze({
+		program,
+		gameState: Object.freeze({ ...program.init }),
+		btn: createButtonState(),
+		prevBtn: createButtonState()
+	});
+}
+/**
+* Tick the game: update state and generate draw commands
+* This is a pure function - no side effects
+*/
+function tick(game, btn) {
+	const btnPressed = getPressedButtons(game.btn, btn);
+	const stateWithBtn = Object.freeze({
+		...game.gameState,
+		width: CANVAS_WIDTH,
+		height: CANVAS_HEIGHT,
+		btn,
+		btnPressed
+	});
+	const updateResult = executeStatements(game.program.update, stateWithBtn);
+	const { btn: _b, btnPressed: _bp, width: _w, height: _h, ...newGameState } = updateResult.state;
+	const drawState = Object.freeze({
+		...newGameState,
+		width: CANVAS_WIDTH,
+		height: CANVAS_HEIGHT,
+		btn,
+		btnPressed
+	});
+	const drawResult = executeStatements(game.program.draw, drawState);
+	const allCommands = Object.freeze([...updateResult.commands, ...drawResult.commands]);
+	return Object.freeze({
+		game: Object.freeze({
+			program: game.program,
+			gameState: Object.freeze(newGameState),
+			btn,
+			prevBtn: game.btn
+		}),
+		commands: allCommands
+	});
+}
+
+//#endregion
+//#region src/runtime/raw-mode.ts
+function enableRawMode() {
+	if (process.stdin.isTTY) process.stdin.setRawMode(true);
+	process.stdin.resume();
+}
+function disableRawMode() {
+	if (process.stdin.isTTY) process.stdin.setRawMode(false);
+}
+
+//#endregion
+//#region src/runtime/render/palette.ts
+const HASCII_PALETTE = Object.freeze([
+	"\x1B[48;2;0;0;0m",
+	"\x1B[48;2;128;0;0m",
+	"\x1B[48;2;0;128;0m",
+	"\x1B[48;2;128;128;0m",
+	"\x1B[48;2;0;0;128m",
+	"\x1B[48;2;128;0;128m",
+	"\x1B[48;2;0;128;128m",
+	"\x1B[48;2;192;192;192m",
+	"\x1B[48;2;128;128;128m",
+	"\x1B[48;2;255;0;0m",
+	"\x1B[48;2;0;255;0m",
+	"\x1B[48;2;255;255;0m",
+	"\x1B[48;2;0;0;255m",
+	"\x1B[48;2;255;0;255m",
+	"\x1B[48;2;0;255;255m",
+	"\x1B[48;2;255;255;255m"
+]);
+const FG_PALETTE = Object.freeze([
+	"\x1B[38;2;0;0;0m",
+	"\x1B[38;2;128;0;0m",
+	"\x1B[38;2;0;128;0m",
+	"\x1B[38;2;128;128;0m",
+	"\x1B[38;2;0;0;128m",
+	"\x1B[38;2;128;0;128m",
+	"\x1B[38;2;0;128;128m",
+	"\x1B[38;2;192;192;192m",
+	"\x1B[38;2;128;128;128m",
+	"\x1B[38;2;255;0;0m",
+	"\x1B[38;2;0;255;0m",
+	"\x1B[38;2;255;255;0m",
+	"\x1B[38;2;0;0;255m",
+	"\x1B[38;2;255;0;255m",
+	"\x1B[38;2;0;255;255m",
+	"\x1B[38;2;255;255;255m"
+]);
+const RESET = "\x1B[0m";
+const MARGIN_COLOR = "\x1B[48;2;30;30;30m";
+
+//#endregion
+//#region src/runtime/render/buffer.ts
+Object.freeze({
+	char: " ",
+	fg: 7,
+	bg: 0
+});
+function createBuffer(width, height, bg) {
+	const cell = Object.freeze({
+		char: " ",
+		fg: 7,
+		bg
+	});
+	return Object.freeze(Array.from({ length: height }, () => Object.freeze(Array.from({ length: width }, () => cell))));
+}
+function setCell(buffer, x, y, cell) {
+	if (y < 0 || y >= buffer.length) return buffer;
+	const row = buffer[y];
+	if (!row || x < 0 || x >= row.length) return buffer;
+	return Object.freeze(buffer.map((r, ry) => ry === y ? Object.freeze(r.map((c, rx) => rx === x ? cell : c)) : r));
+}
+const BOX_CHARS = {
+	light: Object.freeze({
+		h: "─",
+		v: "│",
+		tl: "┌",
+		tr: "┐",
+		bl: "└",
+		br: "┘"
+	}),
+	heavy: Object.freeze({
+		h: "━",
+		v: "┃",
+		tl: "┏",
+		tr: "┓",
+		bl: "┗",
+		br: "┛"
+	}),
+	double: Object.freeze({
+		h: "═",
+		v: "║",
+		tl: "╔",
+		tr: "╗",
+		bl: "╚",
+		br: "╝"
+	}),
+	round: Object.freeze({
+		h: "─",
+		v: "│",
+		tl: "╭",
+		tr: "╮",
+		bl: "╰",
+		br: "╯"
+	})
+};
+function applyCommand(buffer, cmd, width, height) {
+	if (cmd.type === "cls") return createBuffer(width, height, cmd.bg);
+	if (cmd.type === "rect") {
+		let result = buffer;
+		const x = Math.floor(cmd.x);
+		const y = Math.floor(cmd.y);
+		const w = Math.floor(cmd.w);
+		const h = Math.floor(cmd.h);
+		if (cmd.fill !== null) for (let dy = 0; dy < h; dy++) for (let dx = 0; dx < w; dx++) {
+			const px = x + dx;
+			const py = y + dy;
+			const existingRow = result[py];
+			const existingCell = existingRow ? existingRow[px] : null;
+			const cell = Object.freeze({
+				char: existingCell?.char ?? " ",
+				fg: existingCell?.fg ?? 7,
+				bg: cmd.fill
+			});
+			result = setCell(result, px, py, cell);
+		}
+		if (cmd.stroke !== null && w >= 2 && h >= 2) {
+			const chars = BOX_CHARS[cmd.strokeStyle];
+			const fg = cmd.stroke;
+			for (let dx = 1; dx < w - 1; dx++) {
+				const existingRow = result[y];
+				const existingCell = existingRow ? existingRow[x + dx] : null;
+				result = setCell(result, x + dx, y, Object.freeze({
+					char: chars.h,
+					fg,
+					bg: existingCell?.bg ?? null
+				}));
+			}
+			for (let dx = 1; dx < w - 1; dx++) {
+				const existingRow = result[y + h - 1];
+				const existingCell = existingRow ? existingRow[x + dx] : null;
+				result = setCell(result, x + dx, y + h - 1, Object.freeze({
+					char: chars.h,
+					fg,
+					bg: existingCell?.bg ?? null
+				}));
+			}
+			for (let dy = 1; dy < h - 1; dy++) {
+				const existingRow = result[y + dy];
+				const existingCell = existingRow ? existingRow[x] : null;
+				result = setCell(result, x, y + dy, Object.freeze({
+					char: chars.v,
+					fg,
+					bg: existingCell?.bg ?? null
+				}));
+			}
+			for (let dy = 1; dy < h - 1; dy++) {
+				const existingRow = result[y + dy];
+				const existingCell = existingRow ? existingRow[x + w - 1] : null;
+				result = setCell(result, x + w - 1, y + dy, Object.freeze({
+					char: chars.v,
+					fg,
+					bg: existingCell?.bg ?? null
+				}));
+			}
+			const tlRow = result[y];
+			const tlCell = tlRow ? tlRow[x] : null;
+			result = setCell(result, x, y, Object.freeze({
+				char: chars.tl,
+				fg,
+				bg: tlCell?.bg ?? null
+			}));
+			const trRow = result[y];
+			const trCell = trRow ? trRow[x + w - 1] : null;
+			result = setCell(result, x + w - 1, y, Object.freeze({
+				char: chars.tr,
+				fg,
+				bg: trCell?.bg ?? null
+			}));
+			const blRow = result[y + h - 1];
+			const blCell = blRow ? blRow[x] : null;
+			result = setCell(result, x, y + h - 1, Object.freeze({
+				char: chars.bl,
+				fg,
+				bg: blCell?.bg ?? null
+			}));
+			const brRow = result[y + h - 1];
+			const brCell = brRow ? brRow[x + w - 1] : null;
+			result = setCell(result, x + w - 1, y + h - 1, Object.freeze({
+				char: chars.br,
+				fg,
+				bg: brCell?.bg ?? null
+			}));
+		}
+		return result;
+	}
+	if (cmd.type === "print") {
+		let result = buffer;
+		const x = Math.floor(cmd.x);
+		const y = Math.floor(cmd.y);
+		const chars = Array.from(cmd.text);
+		for (let i = 0; i < chars.length; i++) {
+			const char = chars[i];
+			if (char === void 0) continue;
+			result = setCell(result, x + i, y, Object.freeze({
+				char,
+				fg: cmd.fg,
+				bg: cmd.bg
+			}));
+		}
+		return result;
+	}
+	return buffer;
+}
+function bufferToString(buffer, canvasWidth, canvasHeight, viewWidth, viewHeight, hints) {
+	const offsetX = Math.floor((viewWidth - canvasWidth) / 2);
+	const offsetY = Math.floor((viewHeight - canvasHeight) / 2);
+	const hintRowTop = offsetY - 1;
+	const hintRowBottom = offsetY + canvasHeight;
+	const lines = [];
+	for (let vy = 0; vy < viewHeight; vy++) {
+		const cy = vy - offsetY;
+		if (hints?.top && vy === hintRowTop) {
+			const padding = " ".repeat(offsetX);
+			lines.push(padding + hints.top);
+			continue;
+		}
+		if (hints?.bottom && vy === hintRowBottom) {
+			const textLen = hints.bottom.replace(/\x1b\[[0-9;]*m/g, "").length;
+			const rightPadding = Math.max(0, canvasWidth - textLen);
+			const padding = " ".repeat(offsetX + rightPadding);
+			lines.push(padding + hints.bottom);
+			continue;
+		}
+		let line$1 = "";
+		for (let vx = 0; vx < viewWidth; vx++) {
+			const cx = vx - offsetX;
+			if (cx >= 0 && cx < canvasWidth && cy >= 0 && cy < canvasHeight) {
+				const row = buffer[cy];
+				const cell = row ? row[cx] : null;
+				if (cell) {
+					const fgCode = FG_PALETTE[cell.fg % FG_PALETTE.length];
+					const bgCode = cell.bg !== null ? HASCII_PALETTE[cell.bg % HASCII_PALETTE.length] : "";
+					line$1 += `${bgCode}${fgCode}${cell.char}${RESET}`;
+				} else line$1 += `${HASCII_PALETTE[0]} ${RESET}`;
+			} else line$1 += `${MARGIN_COLOR} ${RESET}`;
+		}
+		lines.push(line$1);
+	}
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/runtime/render/index.ts
+function buildHintTop(termCols, termRows, canvasWidth, canvasHeight, actualHeight, offsetX) {
+	if (termCols < canvasWidth || termRows < canvasHeight + 2) return `${" ".repeat(Math.max(0, offsetX))} \x1b[43m\x1b[30m Too small! \x1b[0m`;
+	const esc = "\x1B[44m ESC \x1B[104m Exit \x1B[0m";
+	const zKey = "\x1B[44m Z \x1B[104m OK \x1B[0m";
+	const xKey = "\x1B[44m X \x1B[104m Cancel \x1B[0m";
+	const leftPad = " ".repeat(offsetX);
+	const middleSpace = actualHeight - 1 - 11 - 21;
+	return `${leftPad} ${esc}${" ".repeat(Math.max(0, middleSpace))}${zKey} ${xKey}  `;
+}
+function buildHintBottom(termCols, termRows, canvasWidth, canvasHeight, offsetX) {
+	const leftPad = " ".repeat(Math.max(0, offsetX));
+	if (termCols < canvasWidth || termRows < canvasHeight + 2) return `${leftPad} \x1b[43m\x1b[30m Need ${canvasWidth}x${canvasHeight + 2} but ${termCols}x${termRows} \x1b[0m`;
+	return `${leftPad} \x1b[100m Hascii - Fantasy Console \x1b[0m`;
+}
+const MIN_WIDTH = 40;
+const MIN_HEIGHT = 20;
+function render(commands, canvasWidth, canvasHeight) {
+	const termCols = process.stdout.columns || 80;
+	const termRows = process.stdout.rows || 24;
+	if (termCols < MIN_WIDTH || termRows < MIN_HEIGHT) process.exit(0);
+	const actualWidth = Math.min(canvasWidth, termCols);
+	const actualHeight = Math.min(canvasHeight, termRows - 2);
+	const availableHeight = termRows - 2;
+	const offsetY = Math.max(0, Math.floor((availableHeight - actualHeight) / 2));
+	const output = bufferToString(commands.reduce((buf, cmd) => applyCommand(buf, cmd, actualWidth, actualHeight), createBuffer(actualWidth, actualHeight, 0)), actualWidth, actualHeight, termCols, actualHeight);
+	const offsetX = Math.floor((termCols - actualWidth) / 2);
+	const hintTop = buildHintTop(termCols, termRows, canvasWidth, canvasHeight, actualWidth, offsetX);
+	const hintBottom = buildHintBottom(termCols, termRows, canvasWidth, canvasHeight, offsetX);
+	const emptyLine = " ".repeat(termCols);
+	const lines = [];
+	for (let i = 0; i < offsetY && lines.length < termRows; i++) lines.push(emptyLine);
+	if (lines.length < termRows) lines.push(hintTop.padEnd(termCols));
+	const canvasLines = output.split("\n");
+	for (const line$1 of canvasLines) {
+		if (lines.length >= termRows) break;
+		lines.push(line$1);
+	}
+	if (lines.length < termRows) lines.push(hintBottom.padEnd(termCols));
+	while (lines.length < termRows) lines.push(emptyLine);
+	process.stdout.write("\x1B[H");
+	process.stdout.write(lines.join("\n"));
+	process.stdout.write("\x1B[H");
+}
+
+//#endregion
+//#region src/runtime/render/canvas.ts
+/**
+* Canvas renderer - Pure function to render draw commands to ANSI string
+*/
+/**
+* Render draw commands to an ANSI string.
+* Pure function - no side effects.
+*
+* @param commands - Draw commands from game tick
+* @param region - Where to render the canvas (screen coordinates)
+* @returns ANSI escape sequence string
+*/
+function renderCanvas(commands, region) {
+	const canvasWidth = Math.min(CANVAS_WIDTH, region.width);
+	const canvasHeight = Math.min(CANVAS_HEIGHT, region.height);
+	const lines = bufferToString(commands.reduce((buf, cmd) => applyCommand(buf, cmd, canvasWidth, canvasHeight), createBuffer(canvasWidth, canvasHeight, 0)), canvasWidth, canvasHeight, region.width, canvasHeight).split("\n");
+	let output = "";
+	for (let y = 0; y < lines.length && y < region.height; y++) output += `\x1b[${region.y + y + 1};${region.x + 1}H${lines[y]}`;
+	return output;
+}
+
+//#endregion
+//#region src/audio/wave.ts
+/**
+* Wave generation for Hascii audio
+*/
+const SAMPLE_RATE = 44100;
+function noteToFreq(note, octave) {
+	return 440 * 2 ** (((octave + 1) * 12 + note - 69) / 12);
+}
+function generateWave(wave, freq, dur, vol, fx) {
+	const n = Math.floor(SAMPLE_RATE * dur);
+	const out = new Int16Array(n);
+	if (freq === 0 || vol === 0) return out;
+	const amp = 32767 * (vol / 7) * .8;
+	for (let i = 0; i < n; i++) {
+		const t = i / SAMPLE_RATE;
+		const p = i / n;
+		let f = freq;
+		if (fx === 1) f *= 1 + p * .5;
+		if (fx === 2) f *= 1 + Math.sin(t * 30) * .02;
+		if (fx === 3) f *= 1 - p * .5;
+		const ph = t * f % 1;
+		let v = 0;
+		switch (wave) {
+			case 0:
+				v = 4 * Math.abs(ph - .5) - 1;
+				break;
+			case 1:
+				v = 2 * ph - 1;
+				break;
+			case 2:
+				v = ph < .5 ? 1 : -1;
+				break;
+			case 3:
+				v = ph < .25 ? 1 : -1;
+				break;
+			case 4:
+				v = Math.sin(2 * Math.PI * ph) * .6 + Math.sin(4 * Math.PI * ph) * .3;
+				break;
+			case 5:
+				v = Math.random() * 2 - 1;
+				break;
+			case 6:
+				v = Math.sin(2 * Math.PI * ph + Math.sin(t * 8) * 2);
+				break;
+			case 7:
+				v = Math.sin(2 * Math.PI * ph);
+				break;
+		}
+		let env = Math.min(1, (n - i) / (SAMPLE_RATE * .02));
+		if (fx === 4) env = p;
+		if (fx === 5) env = 1 - p;
+		out[i] = Math.floor(v * amp * env);
+	}
+	return out;
+}
+function createWav(samples) {
+	const buf = Buffer.alloc(44 + samples.length * 2);
+	buf.write("RIFF", 0);
+	buf.writeUInt32LE(36 + samples.length * 2, 4);
+	buf.write("WAVE", 8);
+	buf.write("fmt ", 12);
+	buf.writeUInt32LE(16, 16);
+	buf.writeUInt16LE(1, 20);
+	buf.writeUInt16LE(1, 22);
+	buf.writeUInt32LE(SAMPLE_RATE, 24);
+	buf.writeUInt32LE(SAMPLE_RATE * 2, 28);
+	buf.writeUInt16LE(2, 32);
+	buf.writeUInt16LE(16, 34);
+	buf.write("data", 36);
+	buf.writeUInt32LE(samples.length * 2, 40);
+	for (let i = 0; i < samples.length; i++) buf.writeInt16LE(samples[i] ?? 0, 44 + i * 2);
+	return buf;
+}
+
+//#endregion
+//#region src/audio/player.ts
+/**
+* Audio player for Hascii
+* Uses afplay on macOS, aplay on Linux
+*/
+let currentProcess = null;
+let tempFile = null;
+let stoppedManually = false;
+function getPlayCommand() {
+	const platform$1 = os.platform();
+	if (platform$1 === "darwin") return ["afplay"];
+	if (platform$1 === "linux") return ["aplay", "-q"];
+	return ["afplay"];
+}
+function cleanup() {
+	if (tempFile && fs.existsSync(tempFile)) {
+		try {
+			fs.unlinkSync(tempFile);
+		} catch {}
+		tempFile = null;
+	}
+}
+function stopAudio() {
+	stoppedManually = true;
+	if (currentProcess) {
+		currentProcess.kill();
+		currentProcess = null;
+	}
+	cleanup();
+}
+const WAVE_MAP = {
+	tri: 0,
+	saw: 1,
+	sqr: 2,
+	pls: 3,
+	org: 4,
+	noi: 5,
+	pha: 6,
+	sin: 7
+};
+const EFFECT_MAP = {
+	pitchUp: 1,
+	vibrato: 2,
+	pitchDown: 3,
+	fadeIn: 4,
+	fadeOut: 5
+};
+const SFX_MASTER = .1;
+const MUSIC_MASTER = .05;
+function playSfx(waveName, freq, length, volume, effect = null) {
+	stopAudio();
+	const wav = createWav(generateWave(WAVE_MAP[waveName] ?? 0, freq, length, Math.round(volume * SFX_MASTER / 100 * 7), effect ? EFFECT_MAP[effect] ?? 0 : 0));
+	tempFile = path.join(os.tmpdir(), `hascii_${Date.now()}.wav`);
+	fs.writeFileSync(tempFile, wav);
+	const [cmd, ...args] = getPlayCommand();
+	if (!cmd) return;
+	currentProcess = spawn(cmd, [...args, tempFile]);
+	currentProcess.on("close", () => {
+		currentProcess = null;
+		cleanup();
+	});
+}
+function isPlaying() {
+	return currentProcess !== null;
+}
+/**
+* Convert step-based pattern to timeline-based Song for playback
+* This ensures EDIT and PLAY use the same audio generation
+*/
+function patternToSong(pattern, channelWaves, bpm, startStep = 0) {
+	const tracks = [];
+	const channels = pattern.length;
+	const totalSteps = pattern[0]?.length ?? 32;
+	for (let ch = 0; ch < channels; ch++) {
+		const notes = [];
+		const wave = channelWaves[ch] ?? 0;
+		for (let step = startStep; step < totalSteps; step++) {
+			const n = pattern[ch]?.[step];
+			if (n && n.pitch >= 0) notes.push({
+				time: (step - startStep) * .5,
+				pitch: n.pitch,
+				octave: n.octave,
+				duration: .5,
+				volume: n.volume
+			});
+		}
+		tracks.push({
+			channel: ch,
+			wave,
+			notes
+		});
+	}
+	return {
+		name: "Pattern",
+		bpm,
+		tracks
+	};
+}
+function playMusic(song, onComplete) {
+	stopAudio();
+	stoppedManually = false;
+	const beatDuration = 60 / song.bpm;
+	let maxTime = 0;
+	for (const track of song.tracks) for (const note of track.notes) {
+		const endTime = note.time + note.duration;
+		if (endTime > maxTime) maxTime = endTime;
+	}
+	const totalDuration = maxTime * beatDuration;
+	const totalSamples = Math.ceil(totalDuration * SAMPLE_RATE);
+	const buf = new Int16Array(totalSamples);
+	for (const track of song.tracks) {
+		const wave = track.wave;
+		for (const note of track.notes) {
+			const startSample = Math.floor(note.time * beatDuration * SAMPLE_RATE);
+			const noteDuration = note.duration * beatDuration;
+			const samples = generateWave(wave, noteToFreq(note.pitch, note.octave), noteDuration, note.volume, 0);
+			for (let i = 0; i < samples.length && startSample + i < totalSamples; i++) {
+				const idx = startSample + i;
+				buf[idx] = Math.max(-32768, Math.min(32767, (buf[idx] ?? 0) + (samples[i] ?? 0)));
+			}
+		}
+	}
+	for (let i = 0; i < buf.length; i++) buf[i] = Math.floor((buf[i] ?? 0) * MUSIC_MASTER);
+	const wav = createWav(buf);
+	tempFile = path.join(os.tmpdir(), `hascii_${Date.now()}.wav`);
+	fs.writeFileSync(tempFile, wav);
+	const [cmd, ...args] = getPlayCommand();
+	if (!cmd) return;
+	currentProcess = spawn(cmd, [...args, tempFile]);
+	currentProcess.on("close", () => {
+		currentProcess = null;
+		cleanup();
+		if (!stoppedManually) onComplete?.();
+		stoppedManually = false;
+	});
+}
+
+//#endregion
+//#region src/runtime/state.ts
+const CURSOR_HOME$1 = "\x1B[H";
+function createInitialState(program) {
+	return Object.freeze({
+		gameState: Object.freeze({ ...program.init }),
+		btn: createButtonState(),
+		prevBtn: createButtonState()
+	});
+}
+function processSfxCommands(commands) {
+	for (const cmd of commands) if (cmd.type === "sfx") playSfx(cmd.wave, cmd.freq, cmd.length, cmd.volume, cmd.effect);
+}
+function updateGameState(program, state, btn) {
+	const btnPressed = getPressedButtons(state.btn, btn);
+	const stateWithBtn = Object.freeze({
+		...state.gameState,
+		width: CANVAS_WIDTH,
+		height: CANVAS_HEIGHT,
+		btn,
+		btnPressed
+	});
+	const updateResult = executeStatements(program.update, stateWithBtn);
+	processSfxCommands(updateResult.commands);
+	const { btn: _b, btnPressed: _bp, width: _w, height: _h, ...newGameState } = updateResult.state;
+	return Object.freeze({
+		gameState: Object.freeze(newGameState),
+		btn,
+		prevBtn: state.btn
+	});
+}
+function renderFrame(program, state) {
+	const btnPressed = getPressedButtons(state.prevBtn, state.btn);
+	const drawState = Object.freeze({
+		...state.gameState,
+		width: CANVAS_WIDTH,
+		height: CANVAS_HEIGHT,
+		btn: state.btn,
+		btnPressed
+	});
+	const drawResult = executeStatements(program.draw, drawState);
+	process.stdout.write(CURSOR_HOME$1);
+	render(drawResult.commands, CANVAS_WIDTH, CANVAS_HEIGHT);
+}
+
+//#endregion
+//#region src/runtime/run.ts
+const HIDE_CURSOR = "\x1B[?25l";
+const SHOW_CURSOR = "\x1B[?25h";
+const CURSOR_HOME = "\x1B[H";
+function clearScreen() {
+	const height = process.stdout.rows ?? 24;
+	let out = "";
+	for (let y = 0; y < height; y++) out += `\x1b[${y + 1};1H\x1b[2K`;
+	return out;
+}
+const FPS = 30;
+const ESC_KEY = "\x1B";
+function run(program) {
+	runWithCallback(program, {});
+}
+function runWithCallback(program, options) {
+	let state = createInitialState(program);
+	let intervalId = null;
+	let currentBtn = createButtonState();
+	let lastInputTime = 0;
+	enableRawMode();
+	console.clear();
+	process.stdout.write(HIDE_CURSOR + clearScreen() + CURSOR_HOME);
+	const cleanup$1 = () => {
+		if (intervalId !== null) {
+			clearInterval(intervalId);
+			intervalId = null;
+		}
+		stopAudio();
+		disableRawMode();
+		process.stdout.write(SHOW_CURSOR + clearScreen() + CURSOR_HOME);
+		process.stdin.removeAllListeners("data");
+	};
+	process.on("exit", cleanup$1);
+	process.on("SIGINT", () => {
+		cleanup$1();
+		process.exit(0);
+	});
+	process.on("SIGTERM", () => {
+		cleanup$1();
+		process.exit(0);
+	});
+	process.stdout.on("resize", () => {
+		process.stdout.write(clearScreen() + CURSOR_HOME);
+	});
+	process.stdin.on("data", (key) => {
+		const seq = key.toString();
+		if (seq === "" || seq === "q" || seq === ESC_KEY) {
+			cleanup$1();
+			if (seq === ESC_KEY && options.onEscape) options.onEscape();
+			else process.exit(0);
+			return;
+		}
+		currentBtn = processKeyInput(key);
+		lastInputTime = Date.now();
+	});
+	const loop = () => {
+		const btn = Date.now() - lastInputTime < 100 ? currentBtn : createButtonState();
+		state = updateGameState(program, state, btn);
+		renderFrame(program, state);
+	};
+	intervalId = setInterval(loop, 1e3 / FPS);
+}
+
+//#endregion
+export { line as $, getActiveButtons as A, HasciiRuntimeError as B, DEFAULT_VOLUME as C, VIEW_WIDTH as D, VIEW_HEIGHT as E, compile as F, evaluate as G, findLocation as H, hasciiProgramSchema as I, ERROR_CODES as J, isSafeKey as K, formatError as L, isValidKey as M, processKeyInput as N, createButtonState as O, updateKeyTimestamps as P, COLORS as Q, HasciiError as R, DEFAULT_OCTAVE as S, ENABLE_SPRITE_EDITOR as T, getSourceLine as U, HasciiValidationError as V, createSourceMap as W, ANSI as X, mapZodCodeToErrorCode as Y, BOX as Z, createDrawState as _, updateGameState as a, CANVAS_HEIGHT as b, playMusic as c, renderCanvas as d, stripAnsi as et, render as f, tick as g, createGame as h, renderFrame as i, getPressedButtons as j, createKeyTimestamps as k, playSfx as l, enableRawMode as m, runWithCallback as n, isPlaying as o, disableRawMode as p, isSafePath as q, createInitialState as r, patternToSong as s, run as t, supportsColor as tt, stopAudio as u, executeStatements as v, ENABLE_MAP_EDITOR as w, CANVAS_WIDTH as x, setVariable as y, HasciiParseError as z };