@kirana-style/compiler-browser 0.0.0 → 0.3.5

package/compiler.js

@@ -0,0 +1,1093 @@
+import { c as WASI, d as createContext, f as __exportAll, i as instantiateNapiModule, l as asyncWork, n as memfs, s as createOnMessage, u as threadsafeFunction } from "./fs.js";
+// ../../dist-packages/stage/compiler-browser/engine/kirana.wasi-browser.js
+var kirana_wasi_browser_exports = /* @__PURE__ */ __exportAll({
+	Compiler: () => Compiler,
+	__fs: () => __fs,
+	__napiBindingTarget: () => __napiBindingTarget,
+	__volume: () => __volume,
+	default: () => kirana_wasi_browser_default,
+	runCli: () => runCli,
+	runLsp: () => runLsp,
+	scanComponent: () => scanComponent
+});
+const __napiBindingTarget = "wasm32-wasi";
+function __napiStampBindingTarget(exportsObject, target) {
+	if (Object.prototype.hasOwnProperty.call(exportsObject, "__napiBindingTarget")) {
+		if (exportsObject.__napiBindingTarget === target) return target;
+		const error = /* @__PURE__ */ new Error("`__napiBindingTarget` is reserved by the generated binding loader, but the loaded binding already exports it. Rename the export, e.g. #[napi(js_name = \"...\")].");
+		error.code = "ERR_NAPI_BINDING_TARGET_CONFLICT";
+		throw error;
+	}
+	if (!Object.isExtensible(exportsObject)) return target;
+	try {
+		Object.defineProperty(exportsObject, "__napiBindingTarget", {
+			configurable: true,
+			enumerable: true,
+			value: target,
+			writable: true
+		});
+	} catch {}
+	return target;
+}
+const { fs: __fs, vol: __volume } = memfs();
+const __wasi = new WASI({
+	version: "preview1",
+	fs: __fs,
+	preopens: { "/": "/" }
+});
+const __wasmUrl = new URL("./kirana.wasm32-wasi.wasm", import.meta.url).href;
+const __wasmResponse = await globalThis.fetch(__wasmUrl);
+if (!__wasmResponse.ok) throw new Error("Failed to fetch WASI module " + __wasmUrl + ": " + __wasmResponse.status + " " + (__wasmResponse.statusText || "Unknown Status"));
+const __wasmFile = await __wasmResponse.arrayBuffer();
+const __sharedMemory = new WebAssembly.Memory({
+	initial: 4e3,
+	maximum: 65536,
+	shared: true
+});
+const __asyncWorkPoolSize = 4;
+const __workerPoolSize = Math.max(2, globalThis.navigator?.hardwareConcurrency ?? 4);
+let __emnapiContext;
+const __wasiDisposeSymbol = Symbol.for("napi.rs.wasi.dispose");
+const __wasiWorkers = /* @__PURE__ */ new Set();
+let __wasiThreadManager;
+function __captureWasiThreadManager(context) {
+	if (context && context.PThread) __wasiThreadManager = context.PThread;
+	return {};
+}
+function __getWasiThreadManager() {
+	const manager = __wasiThreadManager !== void 0 ? __wasiThreadManager : __napiModule ? __napiModule.PThread : void 0;
+	if (manager && typeof manager.terminateWorker === "function") return manager;
+}
+let __napiInstance;
+let __emnapiContextDestroyed = false;
+let __emnapiContextDestroyPromise;
+let __emnapiWasmEnvCleanupPrepared = false;
+let __emnapiWasmEnvCleanupPreparing = false;
+let __finishParkedWasmEnvCleanup;
+let __emnapiWasmEnvCleanupYielding = false;
+let __emnapiWasmEnvSettlementLossReported = false;
+let __emnapiWasmEnvCleanupRan = false;
+let __emnapiWasmEnvCleanupDrained = false;
+let __emnapiWasmEnvCleanupDrainPromise;
+let __wasiDisposed = false;
+let __wasiAsyncWorkDrainPromise;
+let __wasiDisposePromise;
+let __completeWasiDisposal = function() {};
+function __isThenable(value) {
+	return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function __createCleanupError(errors, message) {
+	if (errors.length === 1) return errors[0];
+	const __AggregateError = globalThis.AggregateError;
+	if (typeof __AggregateError === "function") return new __AggregateError(errors, message);
+	const error = new Error(message);
+	error.errors = errors;
+	return error;
+}
+function __attachCleanupErrors(error, cleanupErrors) {
+	if (cleanupErrors.length === 0) return error;
+	const cleanupError = __createCleanupError(cleanupErrors, "WASI binding cleanup failed");
+	try {
+		if (error && (typeof error === "object" || typeof error === "function")) {
+			if (error.cause === void 0) {
+				error.cause = cleanupError;
+				if (error.cause === cleanupError) return error;
+			}
+			if (Array.isArray(error.cleanupErrors)) {
+				error.cleanupErrors.push(cleanupError);
+				return error;
+			} else {
+				const attachedCleanupErrors = [cleanupError];
+				error.cleanupErrors = attachedCleanupErrors;
+				if (error.cleanupErrors === attachedCleanupErrors) return error;
+			}
+		}
+	} catch {}
+	const aggregate = __createCleanupError([error, cleanupError], "WASI binding initialization and cleanup failed");
+	try {
+		aggregate.cause = error;
+	} catch {}
+	return aggregate;
+}
+function __wrapEmnapiContextDestroyForSettlement(context, prepareEnvCleanup, isPreparingEnvCleanup) {
+	let destroy;
+	try {
+		destroy = context.destroy;
+	} catch {
+		return context;
+	}
+	if (typeof destroy !== "function") return context;
+	try {
+		Object.defineProperty(context, "destroy", {
+			configurable: true,
+			enumerable: false,
+			writable: true,
+			value: function() {
+				if (isPreparingEnvCleanup?.()) return;
+				prepareEnvCleanup?.();
+				return Reflect.apply(destroy, this, arguments);
+			}
+		});
+	} catch {}
+	return context;
+}
+function __isPreparingWasmEnvCleanup() {
+	return __emnapiWasmEnvCleanupPreparing;
+}
+function __prepareWasmEnvCleanup() {
+	if (__emnapiWasmEnvCleanupPrepared) return;
+	const finishParked = __finishParkedWasmEnvCleanup;
+	if (finishParked !== void 0) {
+		finishParked();
+		__reportUnreachedWasmEnvSettlements();
+		return;
+	}
+	if (__emnapiWasmEnvCleanupPreparing) return;
+	const prepare = __napiInstance?.exports?.napi_prepare_wasm_env_cleanup;
+	if (typeof prepare === "function") {
+		__emnapiWasmEnvCleanupPreparing = true;
+		try {
+			prepare();
+		} finally {
+			__emnapiWasmEnvCleanupPreparing = false;
+		}
+		__emnapiWasmEnvCleanupRan = true;
+		__reportUnreachedWasmEnvSettlements();
+	}
+	__emnapiWasmEnvCleanupPrepared = true;
+}
+/**
+* Say so when the barrier leaves settlements queued and nothing is left that
+* could deliver them.
+*
+* Only the disposal chain yields the event-loop turns @emnapi/core needs to
+* dispatch its queue. Every other caller of the barrier destroys in the same
+* turn — a raw `Context.destroy()`, the 'exit' teardown — and
+* `Context.destroy()` runs the threadsafe function's cleanup hook, which drains
+* that queue with a null env and discards it. The promises those settlements
+* were for then hang forever, silently.
+*
+* Loud, once, and never throwing: this runs from inside `Context.destroy()`,
+* emnapi's own beforeExit destroy included, where throwing would take the whole
+* teardown down with it. Destroying anyway is still the right trade — the queue
+* is already unreachable by then.
+*/
+function __reportUnreachedWasmEnvSettlements() {
+	if (__emnapiWasmEnvCleanupYielding || __emnapiWasmEnvSettlementLossReported) return;
+	const pending = __napiInstance?.exports?.napi_wasm_env_cleanup_pending;
+	if (typeof pending !== "function") return;
+	let queued;
+	try {
+		queued = pending();
+	} catch {
+		return;
+	}
+	if (!queued) return;
+	__emnapiWasmEnvSettlementLossReported = true;
+	try {
+		const consoleHost = globalThis.console;
+		if (consoleHost && typeof consoleHost.error === "function") consoleHost.error("napi-rs: the wasm environment is being destroyed with " + queued + " queued promise settlement(s). Context.destroy() discards them, so those promises never settle. Dispose with binding[Symbol.for('napi.rs.wasi.dispose')]() instead: only it yields the event-loop turns the settlements need.");
+	} catch {}
+}
+const __scheduleMacrotask = (function() {
+	if (typeof setImmediate === "function") return function(callback) {
+		setImmediate(callback);
+	};
+	const __MessageChannel = globalThis.MessageChannel;
+	if (typeof __MessageChannel === "function") return function(callback) {
+		const channel = new __MessageChannel();
+		channel.port1.onmessage = function() {
+			channel.port1.onmessage = null;
+			try {
+				channel.port1.close();
+			} catch {}
+			try {
+				channel.port2.close();
+			} catch {}
+			callback();
+		};
+		channel.port2.postMessage(null);
+	};
+	return function(callback) {
+		setTimeout(callback, 0);
+	};
+})();
+function __scheduleTimer(callback, delay) {
+	const setTimer = globalThis.setTimeout;
+	if (typeof setTimer !== "function") {
+		__scheduleMacrotask(callback);
+		return;
+	}
+	try {
+		setTimer(callback, delay);
+	} catch {
+		__scheduleMacrotask(callback);
+	}
+}
+const __WASM_RUNTIME_WORK_POLL_INTERVAL_MS = 1;
+const __WASM_RUNTIME_WORK_POLL_TRUSTED_ARRIVALS = 2;
+const __WASM_RUNTIME_WORK_POLL_STALL_MS = 50;
+const __WASM_RUNTIME_WORK_POLL_BACKUP_MS = 200;
+/**
+* Pacing state for one runtime-work poll.
+*
+* Per poll, never per module: whether the host's timers arrive is not a
+* property of the module. A host can lose its timers between two disposals,
+* and in the deferred shape every instance shares this module — one healthy
+* instance must not disarm the fallback for the next one.
+*/
+function __createWasmRuntimePollPace() {
+	return {
+		arrivals: 0,
+		settleTurn: void 0,
+		turnTimerDueAt: 0
+	};
+}
+/**
+* The backup that ends a turn whose timer is never going to arrive.
+*
+* Once the poll paces on the timer alone it has nothing left to fall back on
+* if the host's timers stop mid-poll: the turn that armed the dead timer is
+* the turn that parks, and a parked poll schedules nothing that could notice.
+* So every turn arms one of these before it yields, and each one compares due
+* times instead of measuring how long the parked turn has been waiting.
+*
+* Invariant: a parked turn is ended by the newest backup that was armed while
+* the host's timers still worked, and a backup ends a turn only when that
+* turn's own timer was already due a whole window before the backup itself.
+* Neither half turns on how far apart the arms happen to fall — what bounds
+* the rescue is how far back that newest live backup is:
+*
+* - *Ends it.* Hosts run timers in due order, so a backup that runs while a
+*   turn due a whole window earlier is still parked proves that turn's timer
+*   was dropped rather than merely late. That same comparison is what leaves a
+*   healthy host alone: there the turn's timer has already run and cleared
+*   `settleTurn` before any backup due after it can look.
+* - *Two turns back, not one.* A turn that ended does not prove its own timer
+*   arrived: until `…_TRUSTED_ARRIVALS` is reached every turn arms both
+*   primitives and the macrotask wins, so such a turn can end with its own
+*   timer — and the backup armed one line before it — already dead. The
+*   arrival that then flips the poll onto the timer alone can itself be a
+*   timer armed before the host's timers died. So the turn that parks can sit
+*   two turns past the last live arm, and the newest live backup is due
+*   `…_BACKUP_MS` less *two* turn lengths after that turn's own timer.
+*   Arming on every turn is what holds it to two, rather than however far back
+*   a throttle last let one through.
+* - *Ceiling.* Coverage therefore holds while two consecutive poll turns fit
+*   inside `…_BACKUP_MS` less the slack and one interval: 149 ms, so 74 ms
+*   per turn (measured: a 74 ms turn is still rescued, a 75 ms one parks).
+*   Past that the turn stays parked and the disposal promise never settles.
+*   The bound is deliberate: reaching it takes a host that drops timers
+*   mid-poll *and* keeps every poll turn busy for more than 74 ms, and neither
+*   Node nor WebContainer — the hosts that run the threaded artifact — does
+*   the second.
+*
+* The poll then goes back to arming both primitives until two fresh arrivals
+* prove the timers again. A host that stops running the timers it has
+* *already* accepted leaves nothing to fire, and the disposal promise stays
+* pending rather than wedging the thread — the same outcome as a blocking
+* closure that never returns. Unreferenced wherever the host allows it: the
+* poll's own turn timers are what keep the loop alive, never these.
+*/
+function __armWasmRuntimePollStallBackup(pace) {
+	const setTimer = globalThis.setTimeout;
+	if (typeof setTimer !== "function") return;
+	const dueAt = Date.now() + __WASM_RUNTIME_WORK_POLL_BACKUP_MS;
+	let handle;
+	try {
+		handle = setTimer(() => {
+			const settleTurn = pace.settleTurn;
+			if (!settleTurn || pace.turnTimerDueAt > dueAt - __WASM_RUNTIME_WORK_POLL_STALL_MS) return;
+			pace.arrivals = 0;
+			pace.settleTurn = void 0;
+			settleTurn();
+		}, __WASM_RUNTIME_WORK_POLL_BACKUP_MS);
+	} catch {
+		return;
+	}
+	if (handle && typeof handle.unref === "function") try {
+		handle.unref();
+	} catch {}
+}
+/**
+* One turn of the runtime-work poll.
+*
+* `__scheduleTimer` falls back to the macrotask scheduler when `setTimeout` is
+* missing or throws, but not when it is present, returns a handle and never
+* fires — fake timers in a test suite that disposes from an `afterEach`, or a
+* host whose timers belong to an IO context that is already gone. That host
+* would park this poll forever, and the poll is unbounded, so nothing would
+* ever call `…_finish`.
+*
+* Arm both primitives until timers armed by this poll have arrived twice, and
+* let whichever lands first end the turn; the loser resolves nothing. A host
+* with working timers therefore pays the double arming for the first turn or
+* two — the macrotask wins the race, but the timers behind it still arrive and
+* are counted — and paces on the timer alone from then on, instead of spinning
+* the loop on a zero-delay queue. A host whose timers never arrive keeps both,
+* and the macrotask is what keeps the poll moving. A host whose timers stop
+* after proving themselves is caught by `__armWasmRuntimePollStallBackup`,
+* which ends the parked turn and puts this poll back on both.
+*/
+function __yieldWasmRuntimePollTurn(pace) {
+	__armWasmRuntimePollStallBackup(pace);
+	return new Promise((resolve) => {
+		let settled = false;
+		const settle = () => {
+			if (settled) return;
+			settled = true;
+			if (pace.settleTurn === settle) pace.settleTurn = void 0;
+			resolve();
+		};
+		__scheduleTimer(() => {
+			pace.arrivals++;
+			settle();
+		}, __WASM_RUNTIME_WORK_POLL_INTERVAL_MS);
+		const turnTimerDueAt = Date.now() + __WASM_RUNTIME_WORK_POLL_INTERVAL_MS;
+		if (pace.arrivals < __WASM_RUNTIME_WORK_POLL_TRUSTED_ARRIVALS) {
+			__scheduleMacrotask(settle);
+			return;
+		}
+		pace.settleTurn = settle;
+		pace.turnTimerDueAt = turnTimerDueAt;
+	});
+}
+/**
+* The barrier for callers that can yield: `__prepareWasmEnvCleanup` with real
+* event-loop turns in the middle.
+*
+* `napi_prepare_wasm_env_cleanup` waits — it returns only once the addon's
+* async runtime has quiesced, and on `wasm32-wasip1-threads` the thread it
+* waits on is this one, the only thread that can give a running blocking
+* closure the JavaScript turn *it* is waiting for. A single call there can wait
+* for work that can never finish. The addon's two-phase form splits that:
+* `…_begin` stops the runtime without joining and reports whether anything is
+* still live, `napi_wasm_runtime_work_pending` answers that question again
+* without blocking, and `…_finish` joins. The turns yielded in between are the
+* entire point.
+*
+* The poll has no deadline, for the same reason the async-work drain below has
+* none: giving up means calling `…_finish`, which joins on this thread, and the
+* work it would join is the work that is waiting for a turn from this thread —
+* so a bound does not end the wait, it only moves it somewhere the JavaScript
+* thread can no longer be reached. A blocking closure that never returns keeps
+* the disposal promise pending instead, exactly as a task whose `execute` never
+* returns already keeps an *undisposed* process alive. The host contract is in
+* `crates/async-runtime/README.md`: a blocking closure must never wait on a
+* JavaScript turn. The process-exit path still blocks in `…_finish`, because it
+* has no turns left to give (see `__prepareWasmEnvCleanup`).
+*
+* Feature-detected like every other export in this teardown, so an addon built
+* against a napi crate that predates the split keeps the single blocking call.
+* Returns nothing whenever the handshake finished without yielding, which keeps
+* an idle disposal synchronous.
+*/
+function __prepareWasmEnvCleanupWithTurns() {
+	if (__emnapiWasmEnvCleanupPrepared || __emnapiWasmEnvCleanupPreparing) return;
+	const exports = __napiInstance?.exports;
+	const begin = exports?.napi_prepare_wasm_env_cleanup_begin;
+	const finish = exports?.napi_prepare_wasm_env_cleanup_finish;
+	if (typeof begin !== "function" || typeof finish !== "function") {
+		__emnapiWasmEnvCleanupYielding = true;
+		try {
+			__prepareWasmEnvCleanup();
+		} finally {
+			__emnapiWasmEnvCleanupYielding = false;
+		}
+		return;
+	}
+	const workPending = exports?.napi_wasm_runtime_work_pending;
+	__emnapiWasmEnvCleanupPreparing = true;
+	let live;
+	try {
+		live = begin();
+	} catch (error) {
+		__emnapiWasmEnvCleanupPreparing = false;
+		throw error;
+	}
+	__emnapiWasmEnvCleanupRan = true;
+	const finishCleanup = () => {
+		if (__emnapiWasmEnvCleanupPrepared) return;
+		__finishParkedWasmEnvCleanup = void 0;
+		try {
+			finish();
+		} finally {
+			__emnapiWasmEnvCleanupPreparing = false;
+		}
+		__emnapiWasmEnvCleanupPrepared = true;
+	};
+	if (!live || typeof workPending !== "function") {
+		finishCleanup();
+		return;
+	}
+	__finishParkedWasmEnvCleanup = finishCleanup;
+	return (async () => {
+		const pace = __createWasmRuntimePollPace();
+		for (;;) {
+			await __yieldWasmRuntimePollTurn(pace);
+			try {
+				if (!workPending()) return;
+			} catch {
+				return;
+			}
+		}
+	})().then(finishCleanup, finishCleanup);
+}
+const __WASM_ENV_CLEANUP_DRAIN_TURNS = 128;
+const __WASM_ENV_CLEANUP_BLIND_DRAIN_TURNS = 4;
+/**
+* `napi_prepare_wasm_env_cleanup` only *queues* the promise settlements of the
+* tasks it cancelled: `napi_call_threadsafe_function` appends to the
+* threadsafe-function queue, and @emnapi/core dispatches that queue from a
+* macrotask — two coalescing turns later, even for a call made on this very
+* thread. `Context.destroy()` then runs the threadsafe function's cleanup hook,
+* which drains the queue with a null env and *discards* whatever is still in it.
+*
+* So destroying without yielding first strands exactly the promises the barrier
+* exists to settle. Yield real event-loop turns until the addon reports the
+* queue empty; microtask checkpoints cannot help, no number of them lets a
+* macrotask run.
+*
+* Returns nothing when there is nothing to wait for, which keeps disposal
+* synchronous in the common case.
+*
+* The "already drained" flag is set only once a wait has actually finished.
+* Scheduling a macrotask can fail — a host-provided or patched `setImmediate`
+* that throws is enough — and a disposal that rejects stays retryable, so
+* marking the drain complete up front would make the retry skip it and destroy
+* the context with the barrier's settlements still queued.
+*
+* A wait that runs out of turns with the counter still nonzero rejects with
+* `ERR_NAPI_WASI_CLEANUP_PENDING` for the same reason: at that point
+* "finished" is indistinguishable from the stranding above, and destroying
+* would discard the very settlement the wait was for. The rejection leaves the
+* flag unset and disposal retryable.
+*/
+function __drainWasmEnvCleanup() {
+	if (__emnapiWasmEnvCleanupDrained || !__emnapiWasmEnvCleanupRan) return;
+	if (__emnapiWasmEnvCleanupDrainPromise) return __emnapiWasmEnvCleanupDrainPromise;
+	const pending = __napiInstance?.exports?.napi_wasm_env_cleanup_pending;
+	const observable = typeof pending === "function";
+	if (observable) {
+		let queued;
+		try {
+			queued = pending();
+		} catch {
+			__emnapiWasmEnvCleanupDrained = true;
+			return;
+		}
+		if (!queued) {
+			__emnapiWasmEnvCleanupDrained = true;
+			return;
+		}
+	}
+	const limit = observable ? __WASM_ENV_CLEANUP_DRAIN_TURNS : __WASM_ENV_CLEANUP_BLIND_DRAIN_TURNS;
+	const drainPromise = (async () => {
+		let queued = 0;
+		for (let turn = 0; turn < limit; turn++) {
+			await new Promise((resolve) => {
+				__scheduleMacrotask(resolve);
+			});
+			if (!observable) continue;
+			try {
+				queued = pending();
+			} catch {
+				return;
+			}
+			if (!queued) return;
+		}
+		if (!observable) return;
+		const drainError = /* @__PURE__ */ new Error("the wasm environment still reports " + queued + " queued settlement(s) after " + limit + " event-loop turns; the context was not destroyed - retry dispose() to wait for the queue again");
+		drainError.code = "ERR_NAPI_WASI_CLEANUP_PENDING";
+		throw drainError;
+	})().then((value) => {
+		__emnapiWasmEnvCleanupDrained = true;
+		__emnapiWasmEnvCleanupDrainPromise = void 0;
+		return value;
+	}, (error) => {
+		__emnapiWasmEnvCleanupDrainPromise = void 0;
+		throw error;
+	});
+	__emnapiWasmEnvCleanupDrainPromise = drainPromise;
+	return drainPromise;
+}
+function __destroyEmnapiContext() {
+	if (__emnapiContextDestroyed || __emnapiContext === void 0) {
+		__emnapiContextDestroyed = true;
+		return;
+	}
+	if (__emnapiContextDestroyPromise) return __emnapiContextDestroyPromise;
+	__prepareWasmEnvCleanup();
+	if (__isPreparingWasmEnvCleanup()) return;
+	const result = __emnapiContext.destroy();
+	if (!__isThenable(result)) {
+		__emnapiContextDestroyed = true;
+		return;
+	}
+	const destroyPromise = Promise.resolve(result).then((value) => {
+		__emnapiContextDestroyed = true;
+		return value;
+	}, (error) => {
+		__emnapiContextDestroyPromise = void 0;
+		throw error;
+	});
+	__emnapiContextDestroyPromise = destroyPromise;
+	return destroyPromise;
+}
+/**
+* Holds the event loop open until `work` settles.
+*
+* Nothing else can: the pool workers are deliberately unreferenced so an idle
+* binding cannot keep a process alive, and referencing them again for the
+* termination does not hold either — emnapi unreferences a worker the moment it
+* reports `async-thread-ready`, which for a worker that was still starting
+* lands *after* the termination began. Without a handle of its own, an
+* `await dispose()` with nothing else pending exits the process with its
+* promise unsettled, and everything after the `await` is skipped.
+*
+* The timer is cleared as soon as the work settles, so this never outlives the
+* disposal that asked for it.
+*/
+function __keepEventLoopAliveUntil(work) {
+	const setTimer = globalThis.setInterval;
+	const clearTimer = globalThis.clearInterval;
+	if (typeof setTimer !== "function" || typeof clearTimer !== "function") return work;
+	let timer;
+	try {
+		timer = setTimer(function() {}, 50);
+	} catch {
+		return work;
+	}
+	const release = function() {
+		try {
+			clearTimer(timer);
+		} catch {}
+	};
+	return work.then((value) => {
+		release();
+		return value;
+	}, (error) => {
+		release();
+		throw error;
+	});
+}
+const __WASI_ASYNC_WORK_POLL_INTERVAL_MS = 1;
+/**
+* Settles this addon's outstanding `napi_async_work` before the teardown that
+* would strand it.
+*
+* `napi_prepare_wasm_env_cleanup` does not cover async work, and nothing about
+* it is observable from JavaScript: the threadless archive resolves
+* `napi_*_async_work` through the `@emnapi/core` plugins, but the threaded one
+* links the C `async_work.c` on the uv threadpool, so there the wasm neither
+* imports nor exports those symbols and the only brackets a loader could watch
+* (`_emnapi_ctx_*_waiting_request_counter`) are shared with threadsafe
+* functions. The addon is the one place both flavors go through, so it answers
+* for both, through the same kind of handshake the settlement drain uses:
+*
+*   - `napi_wasm_cancel_pending_async_work()` cancels what no thread has
+*     started. Those completion callbacks run with `napi_cancelled`, which
+*     napi-rs turns into a promise rejected with an `AbortError`.
+*   - `napi_wasm_async_work_pending()` counts what is still owed a completion
+*     callback. Work already executing refuses cancellation and stays counted
+*     until it finishes normally — which it can, because this runs before the
+*     barrier, before `Context.destroy()` and before anything is terminated.
+*
+* Both exports are optional: an addon built against a napi crate that predates
+* them drains nothing and keeps the previous behavior, exactly as the
+* `napi_wasm_env_cleanup_pending` handshake degrades.
+*
+* Returns nothing when there is nothing outstanding, which keeps disposal
+* synchronous in the common case. The promise it returns otherwise never
+* rejects.
+*
+* The wait has no deadline, and that is the point: giving up would destroy the
+* environment with a completion callback still owed, which is the stranding
+* this exists to prevent. A task whose `execute` never returns already keeps an
+* *undisposed* process alive in exactly the same way, so disposal inherits that
+* rather than inventing a bound it cannot honor.
+*
+* Safe to call from inside a completion callback, which is reachable: settling
+* a task runs addon code that can re-enter JavaScript — a setter on the value
+* being handed back, a threadsafe-function callback — and that JavaScript can
+* call `dispose()`. Two things make it terminate rather than wait on itself:
+*
+*   - The addon keeps a work registered until its completion callback
+*     *finishes*, so the count read here is at least one and this takes the
+*     polling path instead of declaring the environment drained and tearing it
+*     down from inside the frame that is still settling a promise.
+*   - The poll is a timer, so it cannot run until the callback has returned to
+*     the host — by which time that work has left the registry. The count the
+*     next poll reads is the one taken after the callback finished.
+*
+* `__disposeWasiBinding` hands every caller the same in-flight promise, so the
+* nested call joins this disposal rather than starting a second one.
+*/
+function __drainWasiAsyncWork() {
+	if (__wasiAsyncWorkDrainPromise !== void 0) return __wasiAsyncWorkDrainPromise;
+	const exports = __napiInstance?.exports;
+	const pending = exports?.napi_wasm_async_work_pending;
+	const cancelPending = exports?.napi_wasm_cancel_pending_async_work;
+	if (typeof pending !== "function" || typeof cancelPending !== "function") return;
+	const readPending = () => {
+		try {
+			return pending();
+		} catch (error) {
+			if (error instanceof globalThis.WebAssembly.RuntimeError) return 0;
+			throw error;
+		}
+	};
+	if (!readPending()) return;
+	try {
+		cancelPending();
+	} catch {}
+	if (!readPending()) return;
+	const drainPromise = __keepEventLoopAliveUntil((async () => {
+		while (readPending()) await new Promise((resolve) => {
+			__scheduleTimer(resolve, __WASI_ASYNC_WORK_POLL_INTERVAL_MS);
+		});
+	})()).then(() => {
+		__wasiAsyncWorkDrainPromise = void 0;
+	}, (error) => {
+		__wasiAsyncWorkDrainPromise = void 0;
+		throw error;
+	});
+	__wasiAsyncWorkDrainPromise = drainPromise;
+	return drainPromise;
+}
+/**
+* `@emnapi/wasi-threads` counts a worker exit as expected only when its own
+* thread manager performed the termination. A bare `worker.terminate()` reaches
+* the manager's `exit` listener instead, which reports
+* `worker (tid = N) sent an error! ... stopped with exit code 1` and rethrows
+* inside the emit — aborting the `once('exit')` that backs the terminate
+* promise, so disposal never settles and the process dies with an uncaught
+* exception. Mark the termination through the manager first.
+*
+* The manager comes from `__getWasiThreadManager`, not from `__napiModule`:
+* the initialization rollback runs on the one path where instantiation never
+* returned, so `__napiModule` is still undefined there while the workers it
+* spawned are already registered and loaded.
+*
+* Not `terminateAllThreads()`: that one recreates the pool it just shut down.
+*/
+function __terminateWasiWorkers() {
+	const cleanupErrors = [];
+	const pending = [];
+	const threadManager = __getWasiThreadManager();
+	for (const worker of __wasiWorkers) {
+		let result;
+		try {
+			if (threadManager) {
+				threadManager.terminateWorker(worker);
+				worker.onmessage = void 0;
+			}
+			result = worker.terminate();
+		} catch (error) {
+			cleanupErrors.push(error);
+			continue;
+		}
+		if (__isThenable(result)) pending.push(Promise.resolve(result).then(() => {
+			__wasiWorkers.delete(worker);
+		}, (error) => {
+			cleanupErrors.push(error);
+		}));
+		else __wasiWorkers.delete(worker);
+	}
+	const finish = () => {
+		if (cleanupErrors.length > 0) throw __createCleanupError(cleanupErrors, "Failed to terminate WASI workers");
+	};
+	return pending.length > 0 ? __keepEventLoopAliveUntil(Promise.all(pending)).then(finish) : finish();
+}
+function __finishWasiDisposal() {
+	const workerResult = __terminateWasiWorkers();
+	if (__isThenable(workerResult)) return Promise.resolve(workerResult).then(__completeWasiDisposal);
+}
+function __continueWasiDisposal() {
+	const destroyResult = __destroyEmnapiContext();
+	if (__isThenable(destroyResult)) return Promise.resolve(destroyResult).then(__finishWasiDisposal);
+	return __finishWasiDisposal();
+}
+function __drainWasmEnvForWasiDisposal() {
+	const drainResult = __drainWasmEnvCleanup();
+	if (__isThenable(drainResult)) return Promise.resolve(drainResult).then(__continueWasiDisposal);
+	return __continueWasiDisposal();
+}
+function __cleanUpWasmEnvForWasiDisposal() {
+	const prepareResult = __prepareWasmEnvCleanupWithTurns();
+	if (__isThenable(prepareResult)) return Promise.resolve(prepareResult).then(__drainWasmEnvForWasiDisposal);
+	return __drainWasmEnvForWasiDisposal();
+}
+function __startWasiDisposal() {
+	const asyncWorkResult = __drainWasiAsyncWork();
+	if (__isThenable(asyncWorkResult)) return Promise.resolve(asyncWorkResult).then(__cleanUpWasmEnvForWasiDisposal);
+	return __cleanUpWasmEnvForWasiDisposal();
+}
+/**
+* Disposes this generated WASI binding.
+*
+* Access this function with:
+* binding[Symbol.for('napi.rs.wasi.dispose')]()
+*/
+function __disposeWasiBinding() {
+	if (__wasiDisposePromise) return __wasiDisposePromise;
+	if (__wasiDisposed) return Promise.resolve();
+	let resolveDispose;
+	let rejectDispose;
+	const disposePromise = new Promise((resolve, reject) => {
+		resolveDispose = resolve;
+		rejectDispose = reject;
+	});
+	__wasiDisposePromise = disposePromise;
+	let result;
+	try {
+		result = __startWasiDisposal();
+	} catch (error) {
+		__wasiDisposePromise = void 0;
+		rejectDispose(error);
+		return disposePromise;
+	}
+	Promise.resolve(result).then((value) => {
+		__wasiDisposed = true;
+		resolveDispose(value);
+	}, (error) => {
+		__wasiDisposePromise = void 0;
+		rejectDispose(error);
+	});
+	return disposePromise;
+}
+function __publishWasiDispose(exports) {
+	Object.defineProperty(exports, __wasiDisposeSymbol, {
+		configurable: false,
+		enumerable: false,
+		value: __disposeWasiBinding,
+		writable: false
+	});
+}
+function __finishWasiInitializationRollback(cleanupErrors) {
+	let workerResult;
+	try {
+		workerResult = __terminateWasiWorkers();
+	} catch (cleanupError) {
+		cleanupErrors.push(cleanupError);
+		return cleanupErrors;
+	}
+	if (__isThenable(workerResult)) return Promise.resolve(workerResult).catch((cleanupError) => {
+		cleanupErrors.push(cleanupError);
+	}).then(() => cleanupErrors);
+	return cleanupErrors;
+}
+function __destroyContextForWasiRollback(cleanupErrors) {
+	let destroyResult;
+	try {
+		destroyResult = __destroyEmnapiContext();
+	} catch (cleanupError) {
+		cleanupErrors.push(cleanupError);
+		return __finishWasiInitializationRollback(cleanupErrors);
+	}
+	if (__isThenable(destroyResult)) return Promise.resolve(destroyResult).catch((cleanupError) => {
+		cleanupErrors.push(cleanupError);
+	}).then(() => __finishWasiInitializationRollback(cleanupErrors));
+	return __finishWasiInitializationRollback(cleanupErrors);
+}
+/**
+* Leaves a rollback that could not reach the queued settlements undestroyed, and
+* hands it to whatever this flavor has that can still reclaim it.
+*/
+function __retainFailedWasiRollback(cleanupErrors) {
+	return cleanupErrors;
+}
+/**
+* Initialization can fail *after* registration has already run, and registration
+* runs with a live environment: a module-init hook can start async work and then
+* return an error, and the promise it created may already have escaped into
+* JavaScript. The barrier cancels that work and *queues* the settlement, so this
+* path needs the same drain the ordinary disposal does — destroying without
+* yielding discards the queue with a null env and strands the promise.
+*
+* Stays synchronous when nothing is queued, which covers every failure before
+* `beforeInit`: there is no instance to run the barrier on, so nothing to drain.
+*
+* A barrier or drain that did *not* finish stops the rollback short of
+* destroying, which is what `dispose()` already does — a rejected drain there
+* never reaches `__continueWasiDisposal`. Destroying anyway is the worse of the
+* two trades, and not because of what it saves:
+*
+*   - It cannot deliver the settlements. `Context.destroy()` runs the
+*     threadsafe function's cleanup hook, which drains the queue with a null env
+*     and discards it, so a promise that already escaped into JavaScript hangs
+*     forever with nothing left that could ever settle it.
+*   - It saves less than it looks. `Context.destroy()` stops JavaScript calls
+*     and runs cleanup hooks; it does not free the wasm instance or its Memory,
+*     which this module's scope holds either way. What stopping short retains is
+*     the emnapi context's bookkeeping and its un-run cleanup hooks.
+*   - Retry is not theoretical. A rollback that records a cleanup error is
+*     already kept in the process-wide registry above, so re-`require()`ing this
+*     file replays it instead of re-instantiating — and the `6e15de6f` flag fix
+*     means the replay drains again rather than skipping it. Destroying first is
+*     what makes that retained record useless.
+*
+* The residual cost is honest: the CJS flavor hands the context to its
+* `process.on('exit')` teardown, so a process that never retries still reclaims
+* it on the way out. The ESM browser flavor has no equivalent — a module that
+* throws while evaluating is permanently errored, so re-importing rethrows
+* without re-running this file — and there the context stays until the realm
+* goes away. That is the deliberate choice: a hung promise is a silent liveness
+* bug with no upper bound, while the retained bookkeeping is bounded by the page.
+*/
+function __rollbackWasiInitialization() {
+	function __rollbackWasmEnvForWasiInitialization() {
+		const cleanupErrors = [];
+		let prepareResult;
+		try {
+			prepareResult = __prepareWasmEnvCleanupWithTurns();
+		} catch (cleanupError) {
+			cleanupErrors.push(cleanupError);
+			return __retainFailedWasiRollback(cleanupErrors);
+		}
+		if (__isThenable(prepareResult)) return Promise.resolve(prepareResult).then(() => __drainWasmEnvForWasiRollback(cleanupErrors), (cleanupError) => {
+			cleanupErrors.push(cleanupError);
+			return __retainFailedWasiRollback(cleanupErrors);
+		});
+		return __drainWasmEnvForWasiRollback(cleanupErrors);
+	}
+	function __drainWasmEnvForWasiRollback(cleanupErrors) {
+		let drainResult;
+		try {
+			drainResult = __drainWasmEnvCleanup();
+		} catch (cleanupError) {
+			cleanupErrors.push(cleanupError);
+			return __retainFailedWasiRollback(cleanupErrors);
+		}
+		if (__isThenable(drainResult)) return Promise.resolve(drainResult).then(() => __destroyContextForWasiRollback(cleanupErrors), (cleanupError) => {
+			cleanupErrors.push(cleanupError);
+			return __retainFailedWasiRollback(cleanupErrors);
+		});
+		return __destroyContextForWasiRollback(cleanupErrors);
+	}
+	const __retainAfterAsyncWorkDrainFailure = (cleanupError) => __retainFailedWasiRollback([cleanupError]);
+	let asyncWorkResult;
+	try {
+		asyncWorkResult = __drainWasiAsyncWork();
+	} catch (cleanupError) {
+		return __retainAfterAsyncWorkDrainFailure(cleanupError);
+	}
+	if (__isThenable(asyncWorkResult)) return Promise.resolve(asyncWorkResult).then(__rollbackWasmEnvForWasiInitialization, __retainAfterAsyncWorkDrainFailure);
+	return __rollbackWasmEnvForWasiInitialization();
+}
+let __wasiAddonCrashFlag;
+function __captureWasiAddonCrashFlag(instance) {
+	try {
+		const getAddress = instance.exports.napi_wasm_thread_crash_flag_address;
+		if (typeof getAddress !== "function") return;
+		const address = getAddress() >>> 0;
+		const buffer = __sharedMemory.buffer;
+		if (address === 0 || address % 4 !== 0 || address + 4 > buffer.byteLength) return;
+		__wasiAddonCrashFlag = new Int32Array(buffer, address, 1);
+	} catch {}
+}
+function __shareWasiAddonCrashFlag(worker) {
+	if (__wasiAddonCrashFlag === void 0) return;
+	try {
+		worker.postMessage({ __napiRsAddonCrashFlag: __wasiAddonCrashFlag });
+	} catch {}
+}
+let __wasiModule;
+let __napiModule;
+try {
+	__emnapiContext = __wrapEmnapiContextDestroyForSettlement(createContext({ autoDestroy: false }), __prepareWasmEnvCleanup, __isPreparingWasmEnvCleanup);
+	__emnapiContext.suppressDestroy();
+	({instance: __napiInstance, module: __wasiModule, napiModule: __napiModule} = await instantiateNapiModule(__wasmFile, {
+		context: __emnapiContext,
+		asyncWorkPoolSize: __asyncWorkPoolSize,
+		reuseWorker: { size: __asyncWorkPoolSize + __workerPoolSize },
+		plugins: [
+			__captureWasiThreadManager,
+			asyncWork,
+			threadsafeFunction
+		],
+		wasi: __wasi,
+		onCreateWorker() {
+			const worker = new Worker(new URL("./wasi-worker-browser.mjs", import.meta.url), { type: "module" });
+			__wasiWorkers.add(worker);
+			__shareWasiAddonCrashFlag(worker);
+			worker.addEventListener("message", createOnMessage(__fs));
+			return worker;
+		},
+		overwriteImports(importObject) {
+			importObject.env = {
+				...importObject.env,
+				...importObject.napi,
+				...importObject.emnapi,
+				memory: __sharedMemory
+			};
+			return importObject;
+		},
+		beforeInit({ instance }) {
+			__napiInstance = instance;
+			__captureWasiAddonCrashFlag(instance);
+			for (const worker of __wasiWorkers) __shareWasiAddonCrashFlag(worker);
+			for (const name of Object.keys(instance.exports)) if (name.startsWith("__napi_register__")) instance.exports[name]();
+		}
+	}));
+	__publishWasiDispose(__napiModule.exports);
+	__napiStampBindingTarget(__napiModule.exports, __napiBindingTarget);
+} catch (error) {
+	throw __attachCleanupErrors(error, await __rollbackWasiInitialization());
+}
+var kirana_wasi_browser_default = __napiModule.exports;
+const Compiler = __napiModule.exports.Compiler;
+const runCli = __napiModule.exports.runCli;
+const runLsp = __napiModule.exports.runLsp;
+const scanComponent = __napiModule.exports.scanComponent;
+// ../compiler/src/engine-json.ts
+/**
+* `root` joined with a relative module, for POSIX paths: `.` and `..` segments are resolved and
+* the result is absolute when `root` is. The browser's in-memory projects have no other kind.
+*/
+function posixResolve(root, module) {
+	const segments = [];
+	for (const segment of `${root}/${module}`.split("/")) {
+		if (segment === "" || segment === ".") continue;
+		if (segment === "..") segments.pop();
+		else segments.push(segment);
+	}
+	return `${root.startsWith("/") ? "/" : ""}${segments.join("/")}`;
+}
+/**
+* The engine's JSON: file configuration, overridden key by key by inline options. `jsx` is the
+* mode detected from the project when the configuration names none.
+*/
+function engineJson(root, config, inline, options = {}) {
+	const { presets = [], utilities, ui: _registry, ...merged } = {
+		...config,
+		...inline
+	};
+	const jsx = merged.jsx ?? options.jsx;
+	const grammar = mergeGrammars([...presets.map((preset) => preset.utilities), utilities], root, options.resolveModule);
+	return JSON.stringify({
+		...merged,
+		...jsx ? { jsx } : {},
+		...grammar ? { utilities: grammar } : {},
+		root
+	});
+}
+/**
+* The presets' utility grammars and the project's, merged in order: a later scale, root or variant
+* replaces an earlier one of the same name (KRN-TOK-008). A relative scale module is resolved from
+* the project root, since the engine reads it from whichever module uses the utility.
+*/
+function mergeGrammars(grammars, root, resolveModule = posixResolve) {
+	const present = grammars.filter((grammar) => grammar !== void 0);
+	if (present.length === 0) return void 0;
+	const scales = {};
+	const utilities = {};
+	const variants = {};
+	for (const grammar of present) {
+		for (const [name, sources] of Object.entries(grammar.scales ?? {})) scales[name] = sources.map((source) => ({
+			module: /^\.\.?\//.test(source.module) ? resolveModule(root, source.module) : source.module,
+			export: source.export
+		}));
+		Object.assign(utilities, grammar.utilities);
+		Object.assign(variants, grammar.variants);
+	}
+	return {
+		scales,
+		utilities,
+		variants
+	};
+}
+// src/project.ts
+/**
+* A Kirana project held in memory, for the engine in a browser (KRN-CMP-012, D-113): the files are
+* written to the WebAssembly engine's file system, so a module's imports, the tokens it reads and
+* the configuration's scale modules resolve as they would on disk, and the `Compiler` session
+* compiles them.
+*
+* Nothing here loads the engine: `openProject` takes it, so the same code runs on the native engine
+* and a directory in the tests, and on the WebAssembly engine and its in-memory volume in a page.
+*/
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+/** The position of a UTF-8 byte offset in `source`. */
+function positionOf(source, offset) {
+	const lines = decoder.decode(encoder.encode(source).subarray(0, offset)).split("\n");
+	return {
+		line: lines.length,
+		column: lines.at(-1).length + 1
+	};
+}
+/** A path relative to `root`, absolute as the engine needs it. */
+function absolute(root, file) {
+	return `${root}/${file.replace(/^\.?\//, "")}`;
+}
+/** An engine path back to one relative to `root`; a path outside it is kept as it is. */
+function relative(root, file) {
+	return file.startsWith(`${root}/`) ? file.slice(root.length + 1) : file;
+}
+/** Opens a project on `engine`: the configuration becomes the engine's JSON, the files are written. */
+function openProject(engine, { config = {}, root = "/app", files = {} } = {}) {
+	const configJson = engineJson(root, config, {});
+	const volume = engine.__volume;
+	volume.mkdirSync(root, { recursive: true });
+	const session = new engine.Compiler(configJson);
+	const sources = /* @__PURE__ */ new Map();
+	const diagnosticsOf = (json) => JSON.parse(json).map((diagnostic) => {
+		const source = sources.get(diagnostic.file);
+		return source === void 0 ? diagnostic : {
+			...diagnostic,
+			start: positionOf(source, diagnostic.span.start),
+			end: positionOf(source, diagnostic.span.end)
+		};
+	});
+	const project = {
+		root,
+		configJson,
+		write(file, code) {
+			const path = absolute(root, file);
+			volume.mkdirSync(path.slice(0, path.lastIndexOf("/")), { recursive: true });
+			volume.writeFileSync(path, code);
+			sources.set(relative(root, path), code);
+			return session.invalidate(path).map((id) => relative(root, id));
+		},
+		remove(file) {
+			const path = absolute(root, file);
+			volume.rmSync(path, { force: true });
+			sources.delete(relative(root, path));
+			session.remove(path);
+		},
+		transform(file) {
+			const path = absolute(root, file);
+			const code = sources.get(relative(root, path));
+			if (code === void 0) throw new Error(`${file} is not a file of this project`);
+			const result = session.transform(path, code);
+			return {
+				code: result.code,
+				map: result.map,
+				diagnostics: diagnosticsOf(result.diagnostics),
+				cssChanged: result.cssChanged,
+				dependencies: result.dependencies.map((id) => relative(root, id))
+			};
+		},
+		stylesheet: (minify = false) => session.stylesheet(minify),
+		diagnostics: () => diagnosticsOf(session.diagnostics()),
+		files: () => [...sources.keys()]
+	};
+	for (const [file, code] of Object.entries(files)) project.write(file, code);
+	return project;
+}
+// src/index.js
+/**
+* The Kirana engine in a browser (D-113). Importing this module fetches the WebAssembly engine
+* beside it and starts its threads, so the page must be cross-origin isolated (COOP `same-origin`,
+* COEP `require-corp`): the engine's memory is a `SharedArrayBuffer`.
+*
+* Hand-written JavaScript: the engine it imports is the loader napi-rs writes for browsers, with an
+* in-memory file system (`napi.wasm.browser.fs`), and exists only once the WebAssembly build has
+* run. `scripts/pack.ts` bundles it, its worker and its runtime into this package.
+*/
+/** Opens a project in the engine's in-memory file system. */
+function createProject(options) {
+	return openProject(kirana_wasi_browser_exports, options);
+}
+export { engineJson as configJson, createProject, positionOf };