@rohal12/twee-ts 1.15.4 → 1.16.1

package/dist/index.js

@@ -1,6 +1,7 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, watch as watch$1, writeFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, watch as watch$1, writeFileSync } from "node:fs";
+import * as nodePath from "node:path";
+import { basename, dirname, extname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
 import { randomUUID } from "node:crypto";
-import { basename, dirname, extname, join, parse, relative, resolve } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 //#region src/ifid.ts
@@ -109,6 +110,61 @@ function commentSanitize(s) {
 function htmlCommentSanitize(s) {
 	return s.replace(/-->/g, "-- >");
 }
+/**
+* Escape JavaScript for the content of an HTML `<script>` element, so that the HTML parser reads all of it as
+* the element's text and ends the element at the end tag written after it.
+*
+* - Every `<\/script` (in any letter case) becomes `<\/script`. HTML ends a script element at the first
+*   `<\/script` followed by whitespace, `/` or `>`, wherever it is in the JavaScript, even inside a string.
+* - Every `<!--` becomes `<\!--`, but only if the text would otherwise end in the HTML tokenizer's "script
+*   data double escaped" state: after a `<!--` and then a `<script` start tag with no `-->` between them, the
+*   end tag after the text would not end the element.
+*
+* Inserting a backslash after `<` keeps the value of every string, template, and regular expression literal
+* and every comment where these sequences can be written (`\/` and `\!` are identity escapes; a backslash
+* already before the `<` escapes the `<`, as it did before); `<\/script` is also how minifiers such as Terser
+* write inline scripts. It only changes code that uses them outside literals (`a <\/script/ b`, an HTML-like `<!--`
+* comment that is escaped because of a later `<script`), the raw text of a tagged template, and a `<!--` in a
+* regular expression with the `u` or `v` flag. The result is unchanged by escaping it again.
+*/
+function scriptContentEscape(s) {
+	const escaped = s.replace(/<(?=\/script)/gi, "<\\");
+	return endsDoubleEscaped(escaped) ? escaped.replace(/<(?=!--)/g, "<\\") : escaped;
+}
+/**
+* Whether the HTML tokenizer, reading `s` as script element content with no `<\/script` in it, ends in the
+* "script data double escaped" state, where an end tag after `s` would not end the element.
+* See https://html.spec.whatwg.org/multipage/parsing.html#script-data-escaped-state.
+*/
+function endsDoubleEscaped(s) {
+	const scriptStartTag = /<script[\t\n\f\r />]/gi;
+	let pos = 0;
+	for (;;) {
+		const open = s.indexOf("<!--", pos);
+		if (open === -1) return false;
+		const escapedFrom = open + 2;
+		const close = s.indexOf("-->", escapedFrom);
+		scriptStartTag.lastIndex = escapedFrom;
+		const start = scriptStartTag.exec(s);
+		if (start === null || close !== -1 && close < start.index) {
+			if (close === -1) return false;
+			pos = close + 3;
+			continue;
+		}
+		const end = s.indexOf("-->", start.index + start[0].length);
+		if (end === -1) return true;
+		pos = end + 3;
+	}
+}
+/**
+* Escape CSS for the content of an HTML `<style>` element: every `</style` (in any letter case) becomes
+* `<\/style`, since HTML ends a style element at the first `</style` followed by whitespace, `/` or `>`.
+* `\/` stands for `/` in CSS strings and URLs, and comments don't matter; `</style` anywhere else isn't valid
+* CSS anyway.
+*/
+function styleContentEscape(s) {
+	return s.replace(/<(?=\/style)/gi, "<\\");
+}
 /** Apply ROT13 encoding to a string (only affects [A-Za-z]). */
 function rot13(s) {
 	if (s.length === 0) return s;
@@ -631,11 +687,25 @@ function fontFormatHint(ext) {
 * Ported from filesystem.go.
 */
 /**
+* Whether `filename` matches one of the `exclude` globs. The globs are matched
+* against the file's path relative to the working directory, the path
+* getFilenames reports; an absolute `filename` is made relative first. A leading
+* `./` in a glob is dropped. Matching is Node's `path.matchesGlob`.
+*/
+function isExcluded(filename, exclude) {
+	if (exclude.length === 0) return false;
+	const { matchesGlob } = nodePath;
+	if (typeof matchesGlob !== "function") throw new Error(`The exclude option needs Node.js 22.5 or newer (found ${process.version}).`);
+	const rel = relative(process.cwd(), resolve(filename)) || filename;
+	return exclude.some((pattern) => matchesGlob(rel, pattern.replace(/^\.\//, "")));
+}
+/**
 * Recursively walk directories, collecting regular file paths.
-* Filters out the output file to prevent circular compilation.
+* Filters out the output file to prevent circular compilation, and the files
+* that match an `exclude` glob (see isExcluded).
 * Like Tweego, a path that cannot be read is reported as a warning and skipped.
 */
-function getFilenames(pathnames, outFilename) {
+function getFilenames(pathnames, outFilename, exclude = []) {
 	const filenames = [];
 	const diagnostics = [];
 	const absOutFile = outFilename ? resolve(outFilename) : "";
@@ -657,6 +727,7 @@ function getFilenames(pathnames, outFilename) {
 			const abs = resolve(pathname);
 			if (abs === absOutFile) return;
 			const rel = relative(process.cwd(), abs);
+			if (isExcluded(rel || abs, exclude)) return;
 			filenames.push(rel || abs);
 		} else if (stat.isDirectory()) {
 			let entries;
@@ -675,11 +746,38 @@ function getFilenames(pathnames, outFilename) {
 		diagnostics
 	};
 }
+/** Whether the absolute path `file` is the absolute path `dir` or inside it. */
+function isInsideDir(file, dir) {
+	return file === dir || file.startsWith(dir.endsWith(sep) ? dir : dir + sep);
+}
+/**
+* The watched paths split into folders (as given) and files (absolute). A path
+* that cannot be read counts as a folder, which fs.watch then fails to watch.
+*/
+function splitWatchRoots(pathnames) {
+	const dirs = [];
+	const files = /* @__PURE__ */ new Set();
+	for (const pathname of pathnames) {
+		let isFile = false;
+		try {
+			isFile = statSync(pathname).isFile();
+		} catch {}
+		if (isFile) files.add(resolve(pathname));
+		else dirs.push(pathname);
+	}
+	return {
+		dirs,
+		files
+	};
+}
 /**
 * Watch paths for changes, calling the build callback on known file type changes.
+* A folder is watched recursively; a file is watched on its own and counts
+* whatever its type (a head file, say). A change to a file `ignore` returns true
+* for (given the path relative to the working directory) schedules no build.
 * Uses debouncing to avoid rapid rebuilds.
 */
-function watchFilesystem(pathnames, outFilename, callback) {
+function watchFilesystem(pathnames, outFilename, callback, ignore = () => false) {
 	const absOutFile = resolve(outFilename);
 	const watchers = [];
 	let buildTimer = null;
@@ -695,15 +793,30 @@ function watchFilesystem(pathnames, outFilename, callback) {
 			callback(files);
 		}, BUILD_DEBOUNCE);
 	}
-	for (const pathname of pathnames) try {
-		const watcher = watch$1(pathname, { recursive: true }, (_event, filename) => {
-			if (!filename) return;
-			const abs = resolve(pathname, filename);
-			if (abs === absOutFile) return;
-			if (isKnownFileType(filename)) scheduleBuild(relative(process.cwd(), abs) || abs);
-		});
-		watchers.push(watcher);
-	} catch {}
+	function fileChanged(abs, named) {
+		if (abs === absOutFile) return;
+		if (!named && !isKnownFileType(abs)) return;
+		const rel = relative(process.cwd(), abs);
+		if (!ignore(rel || abs)) scheduleBuild(rel || abs);
+	}
+	function watchPath(pathname, recursive, listener) {
+		try {
+			watchers.push(watch$1(pathname, { recursive }, (_event, filename) => {
+				if (filename) listener(filename);
+			}));
+		} catch {}
+	}
+	const { dirs, files } = splitWatchRoots(pathnames);
+	const absDirs = dirs.map((dir) => resolve(dir));
+	for (const dir of dirs) watchPath(dir, true, (filename) => {
+		const abs = resolve(dir, filename);
+		fileChanged(abs, files.has(abs));
+	});
+	const fileDirs = new Set([...files].filter((file) => !absDirs.some((dir) => isInsideDir(file, dir))).map((file) => dirname(file)));
+	for (const dir of fileDirs) watchPath(dir, false, (filename) => {
+		const abs = resolve(dir, filename);
+		if (files.has(abs)) fileChanged(abs, true);
+	});
 	callback();
 	return { close() {
 		if (buildTimer) clearTimeout(buildTimer);
@@ -711,16 +824,25 @@ function watchFilesystem(pathnames, outFilename, callback) {
 	} };
 }
 //#endregion
+//#region src/source-text.ts
+/**
+* Source text normalization shared by every input path (files, in-memory sources, `parseTwee`).
+*/
+/**
+* Strip a leading UTF-8 byte order mark and convert CRLF and bare CR line endings to LF.
+* Idempotent, so text that is already normalized passes through unchanged.
+*/
+function normalizeSourceText(text) {
+	return (text.charCodeAt(0) === 65279 ? text.slice(1) : text).replace(/\r\n?/g, "\n");
+}
+//#endregion
 //#region src/util.ts
 /**
 * Shared file I/O utilities.
 */
 /** Read a file as UTF-8 with BOM stripping and line ending normalization. */
 function readUTF8(filename) {
-	let content = readFileSync(filename, "utf-8");
-	if (content.charCodeAt(0) === 65279) content = content.slice(1);
-	content = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-	return content;
+	return normalizeSourceText(readFileSync(filename, "utf-8"));
 }
 /** Read a file as base64. */
 function readBase64(filename) {
@@ -750,16 +872,28 @@ function relaxedJSONParse(json) {
 	fixed = fixed.replace(/,\s*([}\]])/g, "$1");
 	return JSON.parse(fixed);
 }
+/** A `"setup": function` property, which Harlowe appends to its otherwise-JSON format object. */
+const SETUP_FUNCTION_PROPERTY = /,\s*"setup"\s*:\s*function\b/g;
+/** Drop a trailing `"setup": function(){…}` property from a format object, if it has one. */
+function stripSetupFunction(chunk) {
+	let lastIndex = -1;
+	for (const match of chunk.matchAll(SETUP_FUNCTION_PROPERTY)) lastIndex = match.index;
+	return lastIndex === -1 ? void 0 : chunk.slice(0, lastIndex) + "}";
+}
 /**
 * Parse the Twine 2 format.js JSON chunk.
-* Handles Harlowe's malformed JSON by stripping the "setup" function property.
+* Handles Harlowe's malformed JSON by stripping the "setup" function property. The workaround
+* keys on the property itself, so the same bytes parse whether they come from a `harlowe-3`
+* directory or a direct download.
 * Per spec, the name key is Optional.
+*
+* @param _formatId No longer used; kept so existing callers keep compiling.
 */
-function parseFormatJSON(source, formatId) {
+function parseFormatJSON(source, _formatId) {
 	const first = source.indexOf("{");
 	const last = source.lastIndexOf("}");
 	if (first === -1 || last === -1) return null;
-	let chunk = source.slice(first, last + 1);
+	const chunk = source.slice(first, last + 1);
 	const parse = (json) => {
 		const raw = relaxedJSONParse(json);
 		if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
@@ -782,16 +916,13 @@ function parseFormatJSON(source, formatId) {
 	try {
 		return parse(chunk);
 	} catch {
-		if (formatId.toLowerCase().startsWith("harlowe")) {
-			const setupIdx = chunk.lastIndexOf(",\"setup\": function");
-			if (setupIdx !== -1) {
-				chunk = chunk.slice(0, setupIdx) + "}";
-				try {
-					return parse(chunk);
-				} catch {}
-			}
+		const stripped = stripSetupFunction(chunk);
+		if (stripped === void 0) return null;
+		try {
+			return parse(stripped);
+		} catch {
+			return null;
 		}
-		return null;
 	}
 }
 /**
@@ -941,6 +1072,54 @@ function semverCompare(a, b) {
 	if (aPatch !== bPatch) return aPatch - bPatch;
 	return 0;
 }
+/** Build a directory-style format ID from a name and version, e.g. ('SugarCube', '2.37.3') → 'sugarcube-2'. */
+function makeFormatId(name, version) {
+	const major = parseSemver(version)?.[0] ?? 0;
+	return `${name.toLowerCase().replace(/\s+/g, "-")}-${major}`;
+}
+/** Describe a format request for diagnostics. */
+function describeFormatRequest(request) {
+	switch (request.kind) {
+		case "id": return `"${request.id}"`;
+		case "name": return request.version ? `"${request.name}" at version "${request.version}"` : `"${request.name}"`;
+		default: throw new Error(`unhandled format request: ${JSON.stringify(request)}`);
+	}
+}
+/**
+* Pick the candidate that best answers a format request.
+*
+* - An ID request ('sugarcube-2') matches a candidate whose name and major version build that ID,
+*   and takes the greatest such version.
+* - A name request matches the name case-insensitively. An exact version wins outright; otherwise
+*   the greatest version with the same major that is not older than the one asked for (or, with
+*   `allowOlder`, the greatest same-major version). An unparseable requested version takes the
+*   greatest version of any major.
+*/
+function selectFormatCandidate(request, candidates, describe, options = {}) {
+	const allowOlder = options.allowOlder ?? false;
+	const wanted = request.kind === "name" ? parseSemver(request.version) : null;
+	let best;
+	for (const candidate of candidates) {
+		const { name, version } = describe(candidate);
+		const have = parseSemver(version);
+		if (!have) continue;
+		if (request.kind === "id") {
+			if (makeFormatId(name, version) !== request.id.toLowerCase()) continue;
+		} else {
+			if (name.toLowerCase() !== request.name.toLowerCase()) continue;
+			if (wanted) {
+				if (semverCompare(have, wanted) === 0) return candidate;
+				if (have[0] !== wanted[0]) continue;
+				if (!allowOlder && semverCompare(have, wanted) < 0) continue;
+			}
+		}
+		if (!best || semverCompare(have, best.version) > 0) best = {
+			candidate,
+			version: have
+		};
+	}
+	return best?.candidate;
+}
 /** Get format ID from Twine 2 name and version, using SemVer major matching. */
 function getFormatIdByNameAndVersion(formats, name, version) {
 	const wanted = parseSemver(version);
@@ -970,169 +1149,584 @@ function readFormatSource(format) {
 	return source;
 }
 //#endregion
-//#region src/types.ts
-const ItemType = {
-	Error: 0,
-	EOF: 1,
-	Header: 2,
-	Name: 3,
-	Tags: 4,
-	Metadata: 5,
-	Content: 6
-};
-//#endregion
-//#region src/lexer.ts
-const EOF = -1;
-const HEADER_DELIM = "::";
-const NEWLINE_HEADER_DELIM = "\n::";
-var LexerContext = class {
-	input;
-	line = 1;
-	start = 0;
-	pos = 0;
-	items = [];
-	constructor(input) {
-		this.input = input;
-	}
-	next() {
-		if (this.pos >= this.input.length) return EOF;
-		const ch = this.input.charCodeAt(this.pos);
-		this.pos++;
-		if (ch === 10) this.line++;
-		return ch;
-	}
-	peek() {
-		if (this.pos >= this.input.length) return EOF;
-		return this.input.charCodeAt(this.pos);
-	}
-	backup() {
-		if (this.pos > this.start) {
-			this.pos--;
-			if (this.input.charCodeAt(this.pos) === 10) this.line--;
-		} else throw new Error("backup would leave pos < start");
-	}
-	emit(type) {
-		const val = this.input.slice(this.start, this.pos);
-		this.items.push({
-			type,
-			line: this.line,
-			pos: this.start,
-			val
-		});
-		if (type === ItemType.Content) {
-			for (let i = this.start; i < this.pos; i++) if (this.input.charCodeAt(i) === 10) this.line++;
-		}
-		this.start = this.pos;
-	}
-	ignore() {
-		for (let i = this.start; i < this.pos; i++) if (this.input.charCodeAt(i) === 10) this.line++;
-		this.start = this.pos;
-	}
-	acceptRun(valid) {
-		let ch;
-		for (ch = this.next(); ch !== EOF && valid.includes(String.fromCharCode(ch)); ch = this.next());
-		if (ch !== EOF) this.backup();
-	}
-	errorf(message) {
-		this.items.push({
-			type: ItemType.Error,
-			line: this.line,
-			pos: this.start,
-			val: message
-		});
-		return null;
-	}
-	/** Drain all pending items and return them. */
-	drainItems() {
-		const result = this.items;
-		this.items = [];
-		return result;
-	}
-};
-function acceptQuoted(ctx, quote) {
-	for (;;) {
-		const ch = ctx.next();
-		switch (ch) {
-			case 92: {
-				const r = ctx.next();
-				if (r !== 10 && r !== EOF) break;
-			}
-			case 10:
-			case EOF: return "unterminated quoted string";
-			default: if (ch === quote) return null;
-		}
-	}
+//#region src/remote-formats.ts
+/**
+* Remote story format fetching, caching, and checksum verification.
+* Uses the Story Formats Archive (SFA) as the default source.
+*/
+const DEFAULT_SFA_INDICES = ["https://videlais.github.io/story-formats-archive/official/index.json", "https://videlais.github.io/story-formats-archive/unofficial/index.json"];
+/** Get the cache directory for downloaded story formats. */
+function getCacheDir() {
+	const base = process.env["XDG_CACHE_HOME"] || join(homedir(), ".cache");
+	return join(base, "twee-ts", "storyformats");
 }
-function lexProlog(ctx) {
-	if (ctx.input.startsWith(HEADER_DELIM, ctx.pos)) return lexHeaderDelim;
-	const i = ctx.input.indexOf(NEWLINE_HEADER_DELIM, ctx.pos);
-	if (i > -1) {
-		ctx.pos = i + 1;
-		ctx.ignore();
-		return lexHeaderDelim;
+/**
+* Whether a string can serve as one directory name inside the cache: not empty, not `.` or `..`,
+* and free of path separators. Format names and versions come from downloaded metadata, so they
+* are untrusted path input.
+*/
+function isSafeSegment(segment) {
+	return segment !== "" && segment !== "." && segment !== ".." && !/[/\\\0]/.test(segment);
+}
+/** Whether absolute path `target` lies strictly inside absolute path `root`. */
+function isInside(root, target) {
+	const rel = relative(root, target);
+	return rel !== "" && !isAbsolute(rel) && rel.split(sep)[0] !== "..";
+}
+/** The cache directory for one format version. Throws when the name or version could leave the cache. */
+function cachedFormatDir(name, version) {
+	if (!isSafeSegment(name)) throw new Error(`Refusing to cache a story format with an unsafe name: ${JSON.stringify(name)}`);
+	if (!isSafeSegment(version) || !parseSemver(version)) throw new Error(`Refusing to cache story format "${name}" with an unsafe version: ${JSON.stringify(version)}`);
+	const root = resolve(getCacheDir());
+	const dir = resolve(root, name, version);
+	if (!isInside(root, dir)) throw new Error(`Refusing to cache a story format outside the cache directory ${root}: ${dir}`);
+	return dir;
+}
+/** Create `dir` as a plain directory, or check that it already is one (a symlink could lead out of the cache). */
+function ensurePlainDirectory(dir) {
+	const stat = lstatSync(dir, { throwIfNoEntry: false });
+	if (stat === void 0) {
+		mkdirSync(dir);
+		return;
 	}
-	ctx.emit(ItemType.EOF);
-	return null;
+	if (stat.isSymbolicLink() || !stat.isDirectory()) throw new Error(`Refusing to write a story format outside the cache directory: ${dir} is not a plain directory`);
+}
+/** Write a downloaded format.js to `<cache>/<name>/<version>/format.js` and return its path. */
+function writeCachedFormat(name, version, text) {
+	const dir = cachedFormatDir(name, version);
+	const root = resolve(getCacheDir());
+	mkdirSync(root, { recursive: true });
+	ensurePlainDirectory(join(root, name));
+	ensurePlainDirectory(dir);
+	const formatPath = join(dir, "format.js");
+	if (lstatSync(formatPath, { throwIfNoEntry: false })?.isSymbolicLink()) throw new Error(`Refusing to write a story format outside the cache directory: ${formatPath} is a symlink`);
+	writeFileSync(formatPath, text, "utf-8");
+	return formatPath;
 }
-function lexContent(ctx) {
-	if (ctx.input.startsWith(HEADER_DELIM, ctx.pos)) return lexHeaderDelim;
-	const i = ctx.input.indexOf(NEWLINE_HEADER_DELIM, ctx.pos);
-	if (i > -1) {
-		ctx.pos = i + 1;
-		ctx.emit(ItemType.Content);
-		return lexHeaderDelim;
-	}
-	ctx.pos = ctx.input.length;
-	if (ctx.pos > ctx.start) ctx.emit(ItemType.Content);
-	ctx.emit(ItemType.EOF);
-	return null;
+/** In-memory index cache, keyed by URL. Cleared each compile. */
+const indexCache = /* @__PURE__ */ new Map();
+/** Clear the in-memory index cache. */
+function clearIndexCache() {
+	indexCache.clear();
 }
-function lexHeaderDelim(ctx) {
-	ctx.pos += 2;
-	ctx.emit(ItemType.Header);
-	return lexName;
+/** Validate that a JSON value is a valid SFAIndexEntry. */
+function isValidEntry(val) {
+	if (typeof val !== "object" || val === null || Array.isArray(val)) return false;
+	const obj = val;
+	return typeof obj.name === "string" && typeof obj.version === "string" && typeof obj.checksums === "object" && obj.checksums !== null && !Array.isArray(obj.checksums);
 }
-function lexName(ctx) {
-	let r;
-	outer: for (;;) {
-		r = ctx.next();
-		switch (r) {
-			case 92: {
-				const next = ctx.next();
-				if (next !== 10 && next !== EOF) break;
-				r = next;
-			}
-			case 91:
-			case 93:
-			case 123:
-			case 125:
-			case 10:
-			case EOF:
-				if (r !== EOF) ctx.backup();
-				break outer;
-		}
-	}
-	ctx.emit(ItemType.Name);
-	switch (r) {
-		case 91: return lexTags;
-		case 93: return ctx.errorf(`unexpected right square bracket ']'`);
-		case 123: return lexMetadata;
-		case 125: return ctx.errorf(`unexpected right curly brace '}'`);
-		case 10:
-			ctx.pos++;
-			ctx.ignore();
-			return lexContent;
-	}
-	ctx.emit(ItemType.EOF);
-	return null;
+/** Validate that a JSON value conforms to the SFAIndex shape. */
+function validateSFAIndex(json) {
+	if (typeof json !== "object" || json === null) throw new Error("SFA index is not an object");
+	const obj = json;
+	return {
+		twine1: Array.isArray(obj["twine1"]) ? obj["twine1"].filter(isValidEntry) : [],
+		twine2: Array.isArray(obj["twine2"]) ? obj["twine2"].filter(isValidEntry) : []
+	};
 }
-function lexNextOptionalBlock(ctx) {
-	ctx.acceptRun(" 	");
-	ctx.ignore();
-	const r = ctx.peek();
-	switch (r) {
-		case 91: return lexTags;
-		case 93: return ctx.errorf(`unexpected right square bracket ']'`);
+/** Fetch and parse an SFA index.json, with in-memory caching. */
+async function fetchIndex(url) {
+	const cached = indexCache.get(url);
+	if (cached) return cached;
+	const res = await fetch(url);
+	if (!res.ok) throw new Error(`Failed to fetch format index from ${url}: ${res.status} ${res.statusText}`);
+	const data = validateSFAIndex(await res.json());
+	indexCache.set(url, data);
+	return data;
+}
+/** Find the best matching entry in an SFA index for a name or ID request (twine2 entries first). */
+function findEntryForRequest(index, request) {
+	return selectFormatCandidate(request, [...(index.twine2 ?? []).map((entry) => ({
+		entry,
+		formatType: "twine2"
+	})), ...(index.twine1 ?? []).map((entry) => ({
+		entry,
+		formatType: "twine1"
+	}))], (c) => c.entry);
+}
+/** Verify SHA-256 checksum using Web Crypto API (Node 22 built-in). */
+async function verifySHA256(content, expectedHex) {
+	const digest = await crypto.subtle.digest("SHA-256", content);
+	return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("") === expectedHex.toLowerCase();
+}
+/** Derive the download URL for a format.js from the index URL and entry. */
+function getDownloadUrl(indexUrl, entry, formatType) {
+	return `${indexUrl.replace(/\/index\.json$/, "")}/${formatType}/${entry.name}/${entry.version}/format.js`;
+}
+/** Download a format, verify its checksum, write to cache, and return StoryFormatInfo. */
+async function fetchAndCacheFormat(entry, downloadUrl) {
+	cachedFormatDir(entry.name, entry.version);
+	const res = await fetch(downloadUrl);
+	if (!res.ok) throw new Error(`Failed to download format from ${downloadUrl}: ${res.status} ${res.statusText}`);
+	const text = await res.text();
+	const checksumKey = Object.keys(entry.checksums ?? {}).find((k) => k.endsWith("format.js"));
+	if (checksumKey) {
+		const expected = entry.checksums[checksumKey];
+		if (!expected) throw new Error(`Missing checksum value for key "${checksumKey}"`);
+		if (!await verifySHA256(new TextEncoder().encode(text), expected)) throw new Error(`Checksum verification failed for ${entry.name} ${entry.version}`);
+	}
+	const id = makeFormatId(entry.name, entry.version);
+	const data = parseFormatJSON(text, id);
+	if (!data) throw new Error(`Failed to parse format JSON from ${downloadUrl}`);
+	return {
+		id,
+		filename: writeCachedFormat(entry.name, entry.version, text),
+		isTwine2: true,
+		name: data.name,
+		version: data.version,
+		proofing: data.proofing ?? false
+	};
+}
+/** Download a direct format.js URL, parse its JSON, cache it, and return StoryFormatInfo. */
+async function fetchDirectFormat(url) {
+	const res = await fetch(url);
+	if (!res.ok) throw new Error(`Failed to download format from ${url}: ${res.status} ${res.statusText}`);
+	const text = await res.text();
+	const data = parseFormatJSON(text);
+	if (!data) throw new Error(`Failed to parse format JSON from ${url}`);
+	return {
+		id: makeFormatId(data.name, data.version),
+		filename: writeCachedFormat(data.name, data.version, text),
+		isTwine2: true,
+		name: data.name,
+		version: data.version,
+		proofing: data.proofing ?? false
+	};
+}
+/**
+* Try to resolve a remote story format by name and version.
+* 0. Use an exactly matching cached download, without touching the network
+* 1. Try direct format URLs
+* 2. Try custom index URLs
+* 3. Try default SFA indices
+* 4. Fall back to a compatible cached download (e.g. when offline)
+*/
+async function resolveRemoteFormat(name, version, indices, urls) {
+	return resolveRemoteFormatRequest({
+		kind: "name",
+		name,
+		version
+	}, indices, urls);
+}
+/**
+* Resolve a story format request remotely, in the same order as {@link resolveRemoteFormat}.
+* An ID request such as 'sugarcube-2' matches the format whose name and major version build that ID
+* (SugarCube 2.x), taking the greatest version available.
+*/
+async function resolveRemoteFormatRequest(request, indices, urls) {
+	let lastError;
+	const cached = findCachedFormat(request);
+	if (cached && request.kind === "name" && isExactVersion(cached.version, request.version)) return cached;
+	for (const url of urls ?? []) try {
+		const info = await fetchDirectFormat(url);
+		if (selectFormatCandidate(request, [info], (f) => f)) return info;
+	} catch (e) {
+		lastError = e instanceof Error ? e : new Error(String(e));
+	}
+	const allIndices = [...indices ?? [], ...DEFAULT_SFA_INDICES];
+	for (const indexUrl of allIndices) try {
+		const result = findEntryForRequest(await fetchIndex(indexUrl), request);
+		if (result) {
+			const hit = getCachedFormat(result.entry.name, result.entry.version);
+			if (hit) return hit;
+			const downloadUrl = getDownloadUrl(indexUrl, result.entry, result.formatType);
+			return await fetchAndCacheFormat(result.entry, downloadUrl);
+		}
+	} catch (e) {
+		lastError = e instanceof Error ? e : new Error(String(e));
+	}
+	if (cached) return cached;
+	if (lastError) throw lastError;
+}
+/** Whether two version strings name the same SemVer version. */
+function isExactVersion(have, wanted) {
+	const a = parseSemver(have);
+	const b = parseSemver(wanted);
+	return a !== null && b !== null && a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+}
+/**
+* Find the cached download that best answers a format request, without network access.
+* Matching follows {@link selectFormatCandidate}.
+*/
+function findCachedFormat(request, options = {}) {
+	return selectFormatCandidate(request, [...discoverCachedFormats().values()], (f) => f, options);
+}
+/** Check if a format is already in the local cache. */
+function getCachedFormat(name, version) {
+	if (!isSafeSegment(name) || !isSafeSegment(version)) return void 0;
+	const formatPath = join(getCacheDir(), name, version, "format.js");
+	try {
+		if (!existsSync(formatPath)) return void 0;
+		const source = readFileSync(formatPath, "utf-8");
+		const id = makeFormatId(name, version);
+		const data = parseFormatJSON(source, id);
+		if (!data) return void 0;
+		return {
+			id,
+			filename: formatPath,
+			isTwine2: true,
+			name: data.name,
+			version: data.version,
+			proofing: data.proofing ?? false
+		};
+	} catch {
+		return;
+	}
+}
+/** Discover all cached remote formats. Returns a Map like discoverFormats(). */
+function discoverCachedFormats() {
+	const formats = /* @__PURE__ */ new Map();
+	const cacheDir = getCacheDir();
+	try {
+		if (!existsSync(cacheDir)) return formats;
+	} catch {
+		return formats;
+	}
+	let names;
+	try {
+		names = readdirSync(cacheDir);
+	} catch {
+		return formats;
+	}
+	for (const name of names) {
+		const nameDir = join(cacheDir, name);
+		try {
+			if (!statSync(nameDir).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		let versions;
+		try {
+			versions = readdirSync(nameDir);
+		} catch {
+			continue;
+		}
+		for (const version of versions) {
+			const info = getCachedFormat(name, version);
+			if (info) formats.set(`${info.id}-${version}`, info);
+		}
+	}
+	return formats;
+}
+/** List all cached formats with size and modification date. */
+function listCachedFormats() {
+	const cacheDir = getCacheDir();
+	const entries = [];
+	try {
+		if (!existsSync(cacheDir)) return entries;
+	} catch {
+		return entries;
+	}
+	let names;
+	try {
+		names = readdirSync(cacheDir);
+	} catch {
+		return entries;
+	}
+	for (const name of names) {
+		const nameDir = join(cacheDir, name);
+		try {
+			if (!statSync(nameDir).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		let versions;
+		try {
+			versions = readdirSync(nameDir);
+		} catch {
+			continue;
+		}
+		for (const version of versions) {
+			const formatPath = join(nameDir, version, "format.js");
+			try {
+				const stat = statSync(formatPath);
+				entries.push({
+					name,
+					version,
+					sizeBytes: stat.size,
+					modifiedAt: stat.mtime
+				});
+			} catch {}
+		}
+	}
+	return entries;
+}
+/**
+* Clear all cached formats, or only those matching a given name. Returns the number of entries removed.
+* A name must be a single cache entry name (as `listCachedFormats()` reports it); anything with a
+* path separator or `.`/`..` throws instead of deleting outside the format's own directory.
+*/
+function clearCachedFormats(name) {
+	if (name && !isSafeSegment(name)) throw new Error(`Refusing to clear ${JSON.stringify(name)}: it is not a cached format name. Use a name as "cache list" shows it.`);
+	const cacheDir = getCacheDir();
+	if (!existsSync(cacheDir)) return 0;
+	if (!name) {
+		const count = listCachedFormats().length;
+		rmSync(cacheDir, {
+			recursive: true,
+			force: true
+		});
+		return count;
+	}
+	const root = resolve(cacheDir);
+	const nameDir = resolve(root, name);
+	if (!isInside(root, nameDir)) throw new Error(`Refusing to clear ${JSON.stringify(name)}: it is not a cached format name.`);
+	if (!lstatSync(nameDir, { throwIfNoEntry: false })?.isDirectory()) return 0;
+	let versions;
+	try {
+		versions = readdirSync(nameDir);
+	} catch {
+		return 0;
+	}
+	const count = versions.length;
+	rmSync(nameDir, {
+		recursive: true,
+		force: true
+	});
+	return count;
+}
+/** Get total cache size in bytes and format count. */
+function getCacheSize() {
+	const entries = listCachedFormats();
+	return {
+		totalBytes: entries.reduce((sum, e) => sum + e.sizeBytes, 0),
+		count: entries.length
+	};
+}
+//#endregion
+//#region src/format-resolution.ts
+/** Choose the format request: explicit format ID > StoryData format > default ID. */
+function formatRequestFor(formatId, storyFormat, storyFormatVersion, defaultId) {
+	if (formatId) return {
+		kind: "id",
+		id: formatId
+	};
+	if (storyFormat) return {
+		kind: "name",
+		name: storyFormat,
+		version: storyFormatVersion
+	};
+	return {
+		kind: "id",
+		id: defaultId
+	};
+}
+/** Look a request up among the formats found in local format directories. */
+function findLocalFormat(formats, request) {
+	switch (request.kind) {
+		case "id": return formats.get(request.id);
+		case "name": {
+			const id = getFormatIdByNameAndVersion(formats, request.name, request.version);
+			return id === void 0 ? void 0 : formats.get(id);
+		}
+		default: throw new Error(`unhandled format request: ${JSON.stringify(request)}`);
+	}
+}
+/**
+* Resolve a format request to a story format.
+*
+* Order: local format directories, then the download cache, then remote sources (unless
+* `noRemote`). When a StoryData request names a version that none of them has, an older version of
+* the same format and major version is used with a warning. Anything else is an error diagnostic,
+* and the result is `undefined`.
+*/
+async function resolveStoryFormat(request, options, diagnostics) {
+	const noRemote = options.noRemote ?? false;
+	const formats = discoverFormats(getFormatSearchDirs(options.formatPaths, options.useTweegoPath ?? true));
+	const wanted = describeFormatRequest(request);
+	const local = findLocalFormat(formats, request);
+	if (local) return local;
+	const cached = findCachedFormat(request);
+	if (cached) return cached;
+	if (!noRemote) try {
+		const remote = await resolveRemoteFormatRequest(request, options.formatIndices, options.formatUrls);
+		if (remote) return remote;
+	} catch (e) {
+		diagnostics.push({
+			level: "warning",
+			message: `Remote format fetch failed for ${wanted}: ${e instanceof Error ? e.message : String(e)}`
+		});
+	}
+	if (request.kind === "name") {
+		const older = selectFormatCandidate(request, [...formats.values()].filter((f) => f.isTwine2), (f) => f, { allowOlder: true }) ?? findCachedFormat(request, { allowOlder: true });
+		if (older) {
+			diagnostics.push({
+				level: "warning",
+				message: `Story format ${wanted} is not available; using ${older.name} ${older.version} instead.`
+			});
+			return older;
+		}
+	}
+	const reason = noRemote ? " (remote fetching disabled)" : "";
+	diagnostics.push({
+		level: "error",
+		message: `Story format ${wanted} is not available${reason}. Found: ${[...formats.keys()].join(", ") || "none"}`
+	});
+}
+//#endregion
+//#region src/types.ts
+const ItemType = {
+	Error: 0,
+	EOF: 1,
+	Header: 2,
+	Name: 3,
+	Tags: 4,
+	Metadata: 5,
+	Content: 6
+};
+//#endregion
+//#region src/lexer.ts
+const EOF = -1;
+const HEADER_DELIM = "::";
+const NEWLINE_HEADER_DELIM = "\n::";
+var LexerContext = class {
+	input;
+	line = 1;
+	start = 0;
+	pos = 0;
+	items = [];
+	constructor(input) {
+		this.input = input;
+	}
+	next() {
+		if (this.pos >= this.input.length) return EOF;
+		const ch = this.input.charCodeAt(this.pos);
+		this.pos++;
+		if (ch === 10) this.line++;
+		return ch;
+	}
+	peek() {
+		if (this.pos >= this.input.length) return EOF;
+		return this.input.charCodeAt(this.pos);
+	}
+	backup() {
+		if (this.pos > this.start) {
+			this.pos--;
+			if (this.input.charCodeAt(this.pos) === 10) this.line--;
+		} else throw new Error("backup would leave pos < start");
+	}
+	emit(type) {
+		const val = this.input.slice(this.start, this.pos);
+		this.items.push({
+			type,
+			line: this.line,
+			pos: this.start,
+			val
+		});
+		if (type === ItemType.Content) {
+			for (let i = this.start; i < this.pos; i++) if (this.input.charCodeAt(i) === 10) this.line++;
+		}
+		this.start = this.pos;
+	}
+	ignore() {
+		for (let i = this.start; i < this.pos; i++) if (this.input.charCodeAt(i) === 10) this.line++;
+		this.start = this.pos;
+	}
+	acceptRun(valid) {
+		let ch;
+		for (ch = this.next(); ch !== EOF && valid.includes(String.fromCharCode(ch)); ch = this.next());
+		if (ch !== EOF) this.backup();
+	}
+	errorf(message) {
+		this.items.push({
+			type: ItemType.Error,
+			line: this.line,
+			pos: this.start,
+			val: message
+		});
+		return null;
+	}
+	/** Drain all pending items and return them. */
+	drainItems() {
+		const result = this.items;
+		this.items = [];
+		return result;
+	}
+};
+function acceptQuoted(ctx, quote) {
+	for (;;) {
+		const ch = ctx.next();
+		switch (ch) {
+			case 92: {
+				const r = ctx.next();
+				if (r !== 10 && r !== EOF) break;
+			}
+			case 10:
+			case EOF: return "unterminated quoted string";
+			default: if (ch === quote) return null;
+		}
+	}
+}
+function lexProlog(ctx) {
+	if (ctx.input.startsWith(HEADER_DELIM, ctx.pos)) return lexHeaderDelim;
+	const i = ctx.input.indexOf(NEWLINE_HEADER_DELIM, ctx.pos);
+	if (i > -1) {
+		ctx.pos = i + 1;
+		ctx.ignore();
+		return lexHeaderDelim;
+	}
+	ctx.emit(ItemType.EOF);
+	return null;
+}
+function lexContent(ctx) {
+	if (ctx.input.startsWith(HEADER_DELIM, ctx.pos)) return lexHeaderDelim;
+	const i = ctx.input.indexOf(NEWLINE_HEADER_DELIM, ctx.pos);
+	if (i > -1) {
+		ctx.pos = i + 1;
+		ctx.emit(ItemType.Content);
+		return lexHeaderDelim;
+	}
+	ctx.pos = ctx.input.length;
+	if (ctx.pos > ctx.start) ctx.emit(ItemType.Content);
+	ctx.emit(ItemType.EOF);
+	return null;
+}
+function lexHeaderDelim(ctx) {
+	ctx.pos += 2;
+	ctx.emit(ItemType.Header);
+	return lexName;
+}
+function lexName(ctx) {
+	let r;
+	outer: for (;;) {
+		r = ctx.next();
+		switch (r) {
+			case 92: {
+				const next = ctx.next();
+				if (next !== 10 && next !== EOF) break;
+				r = next;
+			}
+			case 91:
+			case 93:
+			case 123:
+			case 125:
+			case 10:
+			case EOF:
+				if (r !== EOF) ctx.backup();
+				break outer;
+		}
+	}
+	ctx.emit(ItemType.Name);
+	switch (r) {
+		case 91: return lexTags;
+		case 93: return ctx.errorf(`unexpected right square bracket ']'`);
+		case 123: return lexMetadata;
+		case 125: return ctx.errorf(`unexpected right curly brace '}'`);
+		case 10:
+			ctx.pos++;
+			ctx.ignore();
+			return lexContent;
+	}
+	ctx.emit(ItemType.EOF);
+	return null;
+}
+function lexNextOptionalBlock(ctx) {
+	ctx.acceptRun(" 	");
+	ctx.ignore();
+	const r = ctx.peek();
+	switch (r) {
+		case 91: return lexTags;
+		case 93: return ctx.errorf(`unexpected right square bracket ']'`);
 		case 123: return lexMetadata;
 		case 125: return ctx.errorf(`unexpected right curly brace '}'`);
 		case 10:
@@ -1259,16 +1853,20 @@ function twee2ToV3(s) {
 //#region src/parser.ts
 /**
 * Parse Twee source text into passages.
+*
+* The source is normalized first, as files are when they are read: a leading UTF-8 BOM is
+* removed and CRLF and bare CR line endings become LF.
 */
 function parseTwee(source, options = {}) {
 	const { filename = "<inline>", trim = true, twee2Compat = false } = options;
 	const diagnostics = [];
-	if (twee2Compat) source = twee2ToV3(source);
+	const normalized = normalizeSourceText(source);
+	const tweeSource = twee2Compat ? twee2ToV3(normalized) : normalized;
 	const passages = [];
 	let current = null;
 	let pCount = 0;
 	let lastType = ItemType.EOF;
-	for (const item of tweeLexer(source)) {
+	for (const item of tweeLexer(tweeSource)) {
 		switch (item.type) {
 			case ItemType.Error:
 				diagnostics.push({
@@ -4149,6 +4747,7 @@ function decompileTwine2(storyData, story, diagnostics) {
 		});
 		else story.twine2.zoom = parsed;
 	}
+	if (attrs["tags"]) story.twine2.tags = attrs["tags"];
 	if (attrs["format"]) story.twine2.format = attrs["format"];
 	if (attrs["format-version"]) story.twine2.formatVersion = attrs["format-version"];
 	if (attrs["options"]) for (const opt of attrs["options"].split(/\s+/).filter((s) => s.length > 0)) story.twine2.options.set(opt, true);
@@ -4208,22 +4807,32 @@ function decompileTwine2(storyData, story, diagnostics) {
 	}, diagnostics);
 }
 function decompileTwine1(storeArea, story, diagnostics) {
-	for (const node of storeArea.children ?? []) {
-		if (node.type !== "tag" || node.name !== "div") continue;
-		const nodeAttrs = node.attribs ?? {};
-		if (!("tiddler" in nodeAttrs)) continue;
-		const name = nodeAttrs["tiddler"] ?? "";
-		const tags = nodeAttrs["tags"] ? nodeAttrs["tags"].split(/\s+/).filter((s) => s.length > 0) : [];
-		const metadata = {};
-		if (nodeAttrs["twine-position"]) metadata.position = nodeAttrs["twine-position"];
-		const passage = {
-			name,
-			tags,
-			text: tiddlerUnescape(getTextContent(node)).trim()
-		};
-		if (metadata.position) passage.metadata = metadata;
-		storyAdd(story, passage, diagnostics);
-	}
+	const passages = (storeArea.children ?? []).filter(isTiddler).map(tiddlerToPassage);
+	const obfuscated = isRot13Obfuscated(passages);
+	for (const p of passages) storyAdd(story, obfuscated && p.name !== "StorySettings" ? {
+		...p,
+		text: rot13(p.text)
+	} : p, diagnostics);
+}
+function isTiddler(node) {
+	return node.type === "tag" && node.name === "div" && node.attribs !== void 0 && "tiddler" in node.attribs;
+}
+function tiddlerToPassage(node) {
+	const nodeAttrs = node.attribs ?? {};
+	const passage = {
+		name: nodeAttrs["tiddler"] ?? "",
+		tags: nodeAttrs["tags"] ? nodeAttrs["tags"].split(/\s+/).filter((s) => s.length > 0) : [],
+		text: tiddlerUnescape(getTextContent(node)).trim()
+	};
+	const position = nodeAttrs["twine-position"];
+	if (position) passage.metadata = { position };
+	return passage;
+}
+/** Whether the StorySettings tiddlers turn on ROT13 obfuscation, read the way the writer reads them. */
+function isRot13Obfuscated(passages) {
+	const settings = createStory();
+	for (const p of passages) if (p.name === "StorySettings") unmarshalStorySettings(settings, p.text, []);
+	return settings.twine1.settings.get("obfuscate") === "rot13";
 }
 function findElement(node, tagName) {
 	if (node.type === "tag" && node.name === tagName) return node;
@@ -4311,242 +4920,19 @@ function loadSources(story, filenames, opts, diagnostics, processedFiles) {
 				case "opus":
 				case "wav":
 				case "wave":
-				case "weba":
-					loadMedia(story, "Twine.audio", filename, diagnostics);
-					break;
-				case "mp4":
-				case "ogv":
-				case "webm":
-					loadMedia(story, "Twine.video", filename, diagnostics);
-					break;
-				case "vtt":
-					loadMedia(story, "Twine.vtt", filename, diagnostics);
-					break;
-				default: continue;
-			}
-		} catch (e) {
-			diagnostics.push({
-				level: "error",
-				message: `load ${filename}: ${e instanceof Error ? e.message : String(e)}`,
-				file: filename
-			});
-			continue;
-		}
-		processedFiles.add(filename);
-	}
-	if (story.name !== "" && !story.passages.some((p) => p.name === "StoryTitle")) storyPrepend(story, {
-		name: "StoryTitle",
-		tags: [],
-		text: story.name
-	}, diagnostics);
-}
-/**
-* Load inline sources (string content or InlineSource objects).
-*/
-function loadInlineSources(story, sources, opts, diagnostics) {
-	for (const source of sources) {
-		if (typeof source === "string") continue;
-		const content = typeof source.content === "string" ? source.content : source.content.toString("utf-8");
-		const ext = normalizedFileExt(source.filename);
-		switch (ext) {
-			case "":
-			case "tw":
-			case "twee":
-			case "tw2":
-			case "twee2": {
-				const twee2 = ext === "tw2" || ext === "twee2" || opts.twee2Compat;
-				const result = parseTwee(content, {
-					filename: source.filename,
-					trim: opts.trim ?? true,
-					twee2Compat: twee2
-				});
-				diagnostics.push(...result.diagnostics);
-				for (const p of result.passages) storyAdd(story, p, diagnostics);
-				break;
-			}
-			case "css":
-				storyAdd(story, {
-					name: basename(source.filename),
-					tags: ["stylesheet"],
-					text: content
-				}, diagnostics);
-				break;
-			case "js":
-				storyAdd(story, {
-					name: basename(source.filename),
-					tags: ["script"],
-					text: content
-				}, diagnostics);
-				break;
-			default: diagnostics.push({
-				level: "warning",
-				message: `load ${source.filename}: in-memory sources of type .${ext} are not supported; skipped.`
-			});
-		}
-	}
-}
-function parseTweeFile(filename, opts) {
-	const result = parseTwee(readUTF8(filename), {
-		filename,
-		trim: opts.trim ?? true,
-		twee2Compat: opts.twee2Compat ?? false
-	});
-	return {
-		passages: result.passages,
-		diagnostics: [...result.diagnostics]
-	};
-}
-function parseTaggedFile(tag, filename) {
-	const source = readUTF8(filename);
-	return {
-		passages: [{
-			name: basename(filename),
-			tags: [tag],
-			text: source
-		}],
-		diagnostics: []
-	};
-}
-function parseMediaFile(tag, filename) {
-	const source = readBase64(filename);
-	return {
-		passages: [{
-			name: baseNameWithoutExt(filename),
-			tags: [tag],
-			text: `data:${mediaTypeFromFilename(filename)};base64,${source}`
-		}],
-		diagnostics: []
-	};
-}
-function parseFontFile(filename) {
-	const source = readBase64(filename);
-	const name = basename(filename);
-	const family = baseNameWithoutExt(filename);
-	const ext = normalizedFileExt(filename);
-	return {
-		passages: [{
-			name,
-			tags: ["stylesheet"],
-			text: `@font-face {\n\tfont-family: "${family}";\n\tsrc: url("data:${mediaTypeFromExt(ext)};base64,${source}") format("${fontFormatHint(ext)}");\n}`
-		}],
-		diagnostics: []
-	};
-}
-function parseHTMLFile(filename) {
-	const result = decompileHTML(readUTF8(filename));
-	return {
-		passages: result.story.passages,
-		diagnostics: [...result.diagnostics]
-	};
-}
-function parseFile(filename, opts) {
-	switch (normalizedFileExt(filename)) {
-		case "tw":
-		case "twee": return parseTweeFile(filename, opts);
-		case "tw2":
-		case "twee2": return parseTweeFile(filename, {
-			...opts,
-			twee2Compat: true
-		});
-		case "htm":
-		case "html": return parseHTMLFile(filename);
-		case "css": return parseTaggedFile("stylesheet", filename);
-		case "js": return parseTaggedFile("script", filename);
-		case "otf":
-		case "ttf":
-		case "woff":
-		case "woff2": return parseFontFile(filename);
-		case "gif":
-		case "jpeg":
-		case "jpg":
-		case "png":
-		case "svg":
-		case "tif":
-		case "tiff":
-		case "webp": return parseMediaFile("Twine.image", filename);
-		case "aac":
-		case "flac":
-		case "m4a":
-		case "mp3":
-		case "oga":
-		case "ogg":
-		case "opus":
-		case "wav":
-		case "wave":
-		case "weba": return parseMediaFile("Twine.audio", filename);
-		case "mp4":
-		case "ogv":
-		case "webm": return parseMediaFile("Twine.video", filename);
-		case "vtt": return parseMediaFile("Twine.vtt", filename);
-		default: return;
-	}
-}
-function loadHTML(story, filename, diagnostics) {
-	const result = parseHTMLFile(filename);
-	diagnostics.push(...result.diagnostics);
-	for (const p of result.passages) storyAdd(story, p, diagnostics);
-}
-function loadTwee(story, filename, opts, diagnostics) {
-	const result = parseTweeFile(filename, opts);
-	diagnostics.push(...result.diagnostics);
-	for (const p of result.passages) storyAdd(story, p, diagnostics);
-}
-function loadTagged(story, tag, filename, diagnostics) {
-	const result = parseTaggedFile(tag, filename);
-	for (const p of result.passages) storyAdd(story, p, diagnostics);
-}
-function loadMedia(story, tag, filename, diagnostics) {
-	const result = parseMediaFile(tag, filename);
-	for (const p of result.passages) storyAdd(story, p, diagnostics);
-}
-function loadFont(story, filename, diagnostics) {
-	const result = parseFontFile(filename);
-	for (const p of result.passages) storyAdd(story, p, diagnostics);
-}
-/**
-* Load sources with mtime-based caching for incremental rebuilds.
-* Always creates a fresh Story; cached passages are replayed via storyAdd().
-*/
-function loadSourcesCached(story, filenames, opts, diagnostics, processedFiles, cache, changedFiles) {
-	const currentFiles = /* @__PURE__ */ new Set();
-	for (const filename of filenames) {
-		if (processedFiles.has(filename)) {
-			diagnostics.push({
-				level: "warning",
-				message: `load ${filename}: Skipping duplicate.`
-			});
-			continue;
-		}
-		currentFiles.add(filename);
-		const cached = cache.get(filename);
-		if (changedFiles && cached && !changedFiles.has(filename)) {
-			diagnostics.push(...cached.diagnostics);
-			for (const p of cached.passages) storyAdd(story, p, diagnostics);
-			processedFiles.add(filename);
-			continue;
-		}
-		let mtimeMs;
-		try {
-			mtimeMs = statSync(filename).mtimeMs;
-		} catch {
-			continue;
-		}
-		if (cached && cached.mtimeMs === mtimeMs) {
-			diagnostics.push(...cached.diagnostics);
-			for (const p of cached.passages) storyAdd(story, p, diagnostics);
-			processedFiles.add(filename);
-			continue;
-		}
-		try {
-			const result = parseFile(filename, opts);
-			if (!result) continue;
-			cache.set(filename, {
-				mtimeMs,
-				passages: result.passages,
-				diagnostics: result.diagnostics
-			});
-			diagnostics.push(...result.diagnostics);
-			for (const p of result.passages) storyAdd(story, p, diagnostics);
+				case "weba":
+					loadMedia(story, "Twine.audio", filename, diagnostics);
+					break;
+				case "mp4":
+				case "ogv":
+				case "webm":
+					loadMedia(story, "Twine.video", filename, diagnostics);
+					break;
+				case "vtt":
+					loadMedia(story, "Twine.vtt", filename, diagnostics);
+					break;
+				default: continue;
+			}
 		} catch (e) {
 			diagnostics.push({
 				level: "error",
@@ -4557,572 +4943,577 @@ function loadSourcesCached(story, filenames, opts, diagnostics, processedFiles,
 		}
 		processedFiles.add(filename);
 	}
-	for (const key of cache.keys()) if (!currentFiles.has(key)) cache.delete(key);
 	if (story.name !== "" && !story.passages.some((p) => p.name === "StoryTitle")) storyPrepend(story, {
 		name: "StoryTitle",
 		tags: [],
 		text: story.name
 	}, diagnostics);
 }
-//#endregion
-//#region src/version.ts
-/**
-* The twee-ts version, read at runtime from the package's own package.json.
-*
-* The release workflow (semantic-release) writes the new version into the
-* published package.json only; git keeps the old one. Reading it at runtime
-* is the only way the CLI and `creator-version` report the published version.
-*/
-const PACKAGE_NAME = "@rohal12/twee-ts";
-/** Walks up from `startDir` to the nearest package.json named @rohal12/twee-ts and returns its version. */
-function findPackageVersion(startDir) {
-	let dir = startDir;
-	for (;;) {
-		try {
-			const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
-			if (pkg.name === PACKAGE_NAME && typeof pkg.version === "string") return pkg.version;
-		} catch {}
-		const parent = dirname(dir);
-		if (parent === dir) return void 0;
-		dir = parent;
-	}
-}
-/** This module's directory: `__dirname` in the CJS build, `import.meta.url` in ESM and in source. */
-function moduleDir() {
-	return typeof __dirname === "string" ? __dirname : dirname(fileURLToPath(import.meta.url));
-}
-const VERSION = findPackageVersion(moduleDir()) ?? "0.0.0";
-//#endregion
-//#region src/output-twine2.ts
-const CREATOR_NAME$2 = "Twee-ts";
-function toTwine2Archive(story, startName, options) {
-	return getTwine2DataChunk(story, startName, options) + "\n";
-}
-function toTwine2HTML(story, format, startName, options) {
-	let template = readFormatSource(format);
-	if (template.includes("{{STORY_NAME}}")) {
-		const name = htmlEscape(story.name);
-		template = template.replaceAll("{{STORY_NAME}}", () => name);
-	}
-	if (template.includes("{{STORY_DATA}}")) {
-		const data = getTwine2DataChunk(story, startName, options);
-		template = template.replace("{{STORY_DATA}}", () => data);
-	}
-	return template;
-}
-function getTwine2DataChunk(story, startName, options) {
-	const parts = [];
-	let startID = "";
-	let pid = 0;
-	const scripts = [];
-	const stylesheets = [];
-	for (const p of story.passages) {
-		if (hasTag(p, "Twine.private")) continue;
-		if (hasTag(p, "script")) scripts.push(p);
-		else if (hasTag(p, "stylesheet")) stylesheets.push(p);
-	}
-	let styleContent = "";
-	if (stylesheets.length === 1) styleContent = stylesheets[0]?.text ?? "";
-	else if (stylesheets.length > 1) {
-		let pidS = 1;
-		for (const p of stylesheets) {
-			if (pidS > 1 && !styleContent.endsWith("\n")) styleContent += "\n";
-			styleContent += `/* twine-user-stylesheet #${pidS}: "${commentSanitize(p.name)}" */\n`;
-			styleContent += p.text;
-			pidS++;
-		}
-	}
-	parts.push(`<style role="stylesheet" id="twine-user-stylesheet" type="text/twine-css">${styleContent}</style>`);
-	let scriptContent = "";
-	if (scripts.length === 1) scriptContent = scripts[0]?.text ?? "";
-	else if (scripts.length > 1) {
-		let pidS = 1;
-		for (const p of scripts) {
-			if (pidS > 1 && !scriptContent.endsWith("\n")) scriptContent += "\n";
-			scriptContent += `/* twine-user-script #${pidS}: "${commentSanitize(p.name)}" */\n`;
-			scriptContent += p.text;
-			pidS++;
-		}
-	}
-	parts.push(`<script role="script" id="twine-user-script" type="text/twine-javascript">${scriptContent}<\/script>`);
-	const validTagColors = /* @__PURE__ */ new Set([
-		"gray",
-		"red",
-		"orange",
-		"yellow",
-		"green",
-		"blue",
-		"purple"
-	]);
-	const hexColorPattern = /^#[0-9a-fA-F]{3,8}$/;
-	for (const [tag, color] of story.twine2.tagColors) if (validTagColors.has(color) || hexColorPattern.test(color)) parts.push(`<tw-tag name="${attrEscape(tag)}" color="${attrEscape(color)}"></tw-tag>`);
-	pid = 1;
-	for (const p of story.passages) {
-		if (p.name === "StoryTitle" || p.name === "StoryData" || hasAnyTag(p, "script", "stylesheet", "Twine.private")) continue;
-		if (p.name === "StorySettings" && story.twine1.settings.size === 0) continue;
-		parts.push(passageToPassagedata(p, pid, options));
-		if (startName === p.name) startID = String(pid);
-		pid++;
-	}
-	const opts = [];
-	for (const [opt, val] of story.twine2.options) if (val) opts.push(opt);
-	const optionsStr = opts.join(" ");
-	const zoom = String(story.twine2.zoom);
-	return `<!-- UUID://${htmlCommentSanitize(story.ifid)}// --><tw-storydata name="${attrEscape(story.name)}" startnode="${attrEscape(startID)}" creator="${attrEscape(CREATOR_NAME$2)}" creator-version="${attrEscape(VERSION)}" ifid="${attrEscape(story.ifid)}" zoom="${attrEscape(zoom)}" format="${attrEscape(story.twine2.format)}" format-version="${attrEscape(story.twine2.formatVersion)}" options="${attrEscape(optionsStr)}" tags="${attrEscape(story.twine2.tags)}" hidden>` + parts.join("") + "</tw-storydata>";
-}
-//#endregion
-//#region src/output-twine1.ts
-/**
-* Twine 1 HTML and archive output.
-* Ported from storyout.go.
-*/
-const CREATOR_NAME$1 = "twee-ts";
-function toTwine1Archive(story, _startName) {
-	const { data, count } = getTwine1PassageChunk(story);
-	return `<div id="storeArea" data-size="${count}">${data}</div>\n`;
-}
-function toTwine1HTML(story, format, startName) {
-	const formatDir = dirname(format.filename);
-	const parentDir = dirname(formatDir);
-	let template = readFormatSource(format);
-	const { data, count } = getTwine1PassageChunk(story);
-	template = tryReplaceComponent(template, "\"USER_LIB\"", join(formatDir, "userlib.js"), false);
-	template = tryReplaceComponent(template, "\"ENGINE\"", join(parentDir, "engine.js"), true);
-	template = tryReplaceComponent(template, "\"SUGARCANE\"", join(formatDir, "code.js"), true);
-	template = tryReplaceComponent(template, "\"JONAH\"", join(formatDir, "code.js"), true);
-	if (story.twine1.settings.get("jquery") === "on") template = tryReplaceComponent(template, "\"JQUERY\"", join(parentDir, "jquery.js"), true);
-	if (story.twine1.settings.get("modernizr") === "on") template = tryReplaceComponent(template, "\"MODERNIZR\"", join(parentDir, "modernizr.js"), true);
-	const displayStart = startName === "Start" ? "" : startName;
-	template = template.replace("\"VERSION\"", `Compiled with ${CREATOR_NAME$1}, ${VERSION}`);
-	template = template.replace("\"TIME\"", `Built on ${(/* @__PURE__ */ new Date()).toUTCString()}`);
-	const startAtValue = `"${jsStringEscape(displayStart)}"`;
-	template = template.replace("\"START_AT\"", () => startAtValue);
-	template = template.replace("\"STORY_SIZE\"", `"${count}"`);
-	if (template.includes("\"STORY\"")) template = template.replace("\"STORY\"", () => data);
-	else {
-		let footer;
-		try {
-			footer = readFileSync(join(formatDir, "footer.html"), "utf-8");
-		} catch {
-			footer = "</div>\n</body>\n</html>\n";
-		}
-		template += data + footer;
-	}
-	if (story.ifid) {
-		const safeIfid = htmlCommentSanitize(story.ifid);
-		if (template.includes("<div id=\"store-area\"")) template = template.replace("<div id=\"store-area\"", `<!-- UUID://${safeIfid}// --><div id="store-area"`);
-		else template = template.replace("<div id=\"storeArea\"", `<!-- UUID://${safeIfid}// --><div id="storeArea"`);
-	}
-	return template;
-}
-function getTwine1PassageChunk(story) {
-	const obfuscateRot13 = story.twine1.settings.get("obfuscate") === "rot13";
-	let data = "";
-	let count = 0;
-	for (const p of story.passages) {
-		if (hasTag(p, "Twine.private")) continue;
-		count++;
-		data += passageToTiddler(p, count, obfuscateRot13);
-	}
-	return {
-		data,
-		count
-	};
-}
-function tryReplaceComponent(template, placeholder, componentPath, required) {
-	if (!template.includes(placeholder)) return template;
-	try {
-		let content = readFileSync(componentPath, "utf-8");
-		if (content.charCodeAt(0) === 65279) content = content.slice(1);
-		return template.replace(placeholder, () => content);
-	} catch (e) {
-		if (required) throw new Error(`Required format component not found: ${componentPath}: ${e instanceof Error ? e.message : String(e)}`);
-		return template;
-	}
-}
-//#endregion
-//#region src/output-twee.ts
-function toTwee(story, outMode) {
-	let data = "";
-	for (const p of story.passages) data += passageToTwee(p, outMode);
-	return data;
-}
-//#endregion
-//#region src/modules.ts
 /**
-* Load modules and return HTML tags to inject before </head>.
+* Load inline sources (string content or InlineSource objects).
 */
-function loadModules(filenames) {
-	const processed = /* @__PURE__ */ new Set();
-	const headTags = [];
-	for (const filename of filenames) {
-		if (processed.has(filename)) continue;
-		const ext = normalizedFileExt(filename);
-		let tag = null;
+function loadInlineSources(story, sources, opts, diagnostics) {
+	for (const source of sources) {
+		if (typeof source === "string") continue;
+		const content = normalizeSourceText(typeof source.content === "string" ? source.content : source.content.toString("utf-8"));
+		const ext = normalizedFileExt(source.filename);
 		switch (ext) {
+			case "":
+			case "tw":
+			case "twee":
+			case "tw2":
+			case "twee2": {
+				const twee2 = ext === "tw2" || ext === "twee2" || opts.twee2Compat;
+				const result = parseTwee(content, {
+					filename: source.filename,
+					trim: opts.trim ?? true,
+					twee2Compat: twee2
+				});
+				diagnostics.push(...result.diagnostics);
+				for (const p of result.passages) storyAdd(story, p, diagnostics);
+				break;
+			}
 			case "css":
-				tag = loadModuleTagged("style", filename);
+				storyAdd(story, {
+					name: basename(source.filename),
+					tags: ["stylesheet"],
+					text: content
+				}, diagnostics);
 				break;
 			case "js":
-				tag = loadModuleTagged("script", filename);
-				break;
-			case "otf":
-			case "ttf":
-			case "woff":
-			case "woff2":
-				tag = loadModuleFont(filename);
+				storyAdd(story, {
+					name: basename(source.filename),
+					tags: ["script"],
+					text: content
+				}, diagnostics);
 				break;
-			default: continue;
+			default: diagnostics.push({
+				level: "warning",
+				message: `load ${source.filename}: in-memory sources of type .${ext} are not supported; skipped.`
+			});
 		}
-		if (tag) headTags.push(tag);
-		processed.add(filename);
 	}
-	return headTags.join("\n");
 }
-function loadModuleTagged(tag, filename) {
-	const source = readUTF8(filename).trim();
-	if (source.length === 0) return null;
-	return `<${tag} id="${`${tag}-module-${slugify(baseNameWithoutExt(filename))}`}" type="${tag === "script" ? "text/javascript" : "text/css"}">${source}</${tag}>`;
+function parseTweeFile(filename, opts) {
+	const result = parseTwee(readUTF8(filename), {
+		filename,
+		trim: opts.trim ?? true,
+		twee2Compat: opts.twee2Compat ?? false
+	});
+	return {
+		passages: result.passages,
+		diagnostics: [...result.diagnostics]
+	};
+}
+function parseTaggedFile(tag, filename) {
+	const source = readUTF8(filename);
+	return {
+		passages: [{
+			name: basename(filename),
+			tags: [tag],
+			text: source
+		}],
+		diagnostics: []
+	};
 }
-function loadModuleFont(filename) {
+function parseMediaFile(tag, filename) {
+	const source = readBase64(filename);
+	return {
+		passages: [{
+			name: baseNameWithoutExt(filename),
+			tags: [tag],
+			text: `data:${mediaTypeFromFilename(filename)};base64,${source}`
+		}],
+		diagnostics: []
+	};
+}
+function parseFontFile(filename) {
 	const source = readBase64(filename);
+	const name = basename(filename);
 	const family = baseNameWithoutExt(filename);
-	const idSlug = `style-module-${slugify(family)}`;
 	const ext = normalizedFileExt(filename);
-	return `<style id="${idSlug}" type="text/css">@font-face {\n\tfont-family: "${family}";\n\tsrc: url("data:${mediaTypeFromExt(ext)};base64,${source}") format("${fontFormatHint(ext)}");\n}</style>`;
+	return {
+		passages: [{
+			name,
+			tags: ["stylesheet"],
+			text: `@font-face {\n\tfont-family: "${family}";\n\tsrc: url("data:${mediaTypeFromExt(ext)};base64,${source}") format("${fontFormatHint(ext)}");\n}`
+		}],
+		diagnostics: []
+	};
+}
+function parseHTMLFile(filename) {
+	const { story, diagnostics } = decompileHTML(readUTF8(filename));
+	return {
+		passages: story.name !== "" && !storyHas(story, "StoryTitle") ? [{
+			name: "StoryTitle",
+			tags: [],
+			text: story.name
+		}, ...story.passages] : story.passages,
+		diagnostics: [...diagnostics]
+	};
 }
 /**
-* Inject modules and head file content before </head>.
+* Identity of the options that affect how a file parses, stored on its cache entry.
+* Only Twee files depend on them; every other file type yields the same key for all options.
 */
-function modifyHead(html, modulePaths, headFile, diagnostics) {
-	const parts = [];
-	if (modulePaths.length > 0) {
-		const modules = loadModules(modulePaths).trim();
-		if (modules.length > 0) parts.push(modules);
-	}
-	if (headFile) try {
-		const source = readUTF8(headFile).trim();
-		if (source.length > 0) parts.push(source);
-	} catch (e) {
-		diagnostics?.push({
-			level: "warning",
-			message: `Failed to read head file "${headFile}": ${e instanceof Error ? e.message : String(e)}`
+function parseOptionsKey(filename, opts) {
+	const ext = normalizedFileExt(filename);
+	const twee2File = ext === "tw2" || ext === "twee2";
+	if (!twee2File && ext !== "tw" && ext !== "twee") return "";
+	return JSON.stringify({
+		trim: opts.trim ?? true,
+		twee2Compat: twee2File || (opts.twee2Compat ?? false)
+	});
+}
+function parseFile(filename, opts) {
+	switch (normalizedFileExt(filename)) {
+		case "tw":
+		case "twee": return parseTweeFile(filename, opts);
+		case "tw2":
+		case "twee2": return parseTweeFile(filename, {
+			...opts,
+			twee2Compat: true
 		});
+		case "htm":
+		case "html": return parseHTMLFile(filename);
+		case "css": return parseTaggedFile("stylesheet", filename);
+		case "js": return parseTaggedFile("script", filename);
+		case "otf":
+		case "ttf":
+		case "woff":
+		case "woff2": return parseFontFile(filename);
+		case "gif":
+		case "jpeg":
+		case "jpg":
+		case "png":
+		case "svg":
+		case "tif":
+		case "tiff":
+		case "webp": return parseMediaFile("Twine.image", filename);
+		case "aac":
+		case "flac":
+		case "m4a":
+		case "mp3":
+		case "oga":
+		case "ogg":
+		case "opus":
+		case "wav":
+		case "wave":
+		case "weba": return parseMediaFile("Twine.audio", filename);
+		case "mp4":
+		case "ogv":
+		case "webm": return parseMediaFile("Twine.video", filename);
+		case "vtt": return parseMediaFile("Twine.vtt", filename);
+		default: return;
 	}
-	if (parts.length > 0) {
-		parts.push("</head>");
-		const replacement = parts.join("\n");
-		return html.replace("</head>", () => replacement);
-	}
-	return html;
-}
-//#endregion
-//#region src/remote-formats.ts
-/**
-* Remote story format fetching, caching, and checksum verification.
-* Uses the Story Formats Archive (SFA) as the default source.
-*/
-const DEFAULT_SFA_INDICES = ["https://videlais.github.io/story-formats-archive/official/index.json", "https://videlais.github.io/story-formats-archive/unofficial/index.json"];
-/** Get the cache directory for downloaded story formats. */
-function getCacheDir() {
-	const base = process.env["XDG_CACHE_HOME"] || join(homedir(), ".cache");
-	return join(base, "twee-ts", "storyformats");
 }
-/** In-memory index cache, keyed by URL. Cleared each compile. */
-const indexCache = /* @__PURE__ */ new Map();
-/** Clear the in-memory index cache. */
-function clearIndexCache() {
-	indexCache.clear();
+function loadHTML(story, filename, diagnostics) {
+	const result = parseHTMLFile(filename);
+	diagnostics.push(...result.diagnostics);
+	for (const p of result.passages) storyAdd(story, p, diagnostics);
 }
-/** Validate that a JSON value is a valid SFAIndexEntry. */
-function isValidEntry(val) {
-	if (typeof val !== "object" || val === null || Array.isArray(val)) return false;
-	const obj = val;
-	return typeof obj.name === "string" && typeof obj.version === "string" && typeof obj.checksums === "object" && obj.checksums !== null && !Array.isArray(obj.checksums);
+function loadTwee(story, filename, opts, diagnostics) {
+	const result = parseTweeFile(filename, opts);
+	diagnostics.push(...result.diagnostics);
+	for (const p of result.passages) storyAdd(story, p, diagnostics);
 }
-/** Validate that a JSON value conforms to the SFAIndex shape. */
-function validateSFAIndex(json) {
-	if (typeof json !== "object" || json === null) throw new Error("SFA index is not an object");
-	const obj = json;
-	return {
-		twine1: Array.isArray(obj["twine1"]) ? obj["twine1"].filter(isValidEntry) : [],
-		twine2: Array.isArray(obj["twine2"]) ? obj["twine2"].filter(isValidEntry) : []
-	};
+function loadTagged(story, tag, filename, diagnostics) {
+	const result = parseTaggedFile(tag, filename);
+	for (const p of result.passages) storyAdd(story, p, diagnostics);
 }
-/** Generate a format ID from name and version. */
-function makeFormatId(name, version) {
-	const major = parseSemver(version)?.[0] ?? "0";
-	return `${name.toLowerCase().replace(/\s+/g, "-")}-${major}`;
+function loadMedia(story, tag, filename, diagnostics) {
+	const result = parseMediaFile(tag, filename);
+	for (const p of result.passages) storyAdd(story, p, diagnostics);
 }
-/** Fetch and parse an SFA index.json, with in-memory caching. */
-async function fetchIndex(url) {
-	const cached = indexCache.get(url);
-	if (cached) return cached;
-	const res = await fetch(url);
-	if (!res.ok) throw new Error(`Failed to fetch format index from ${url}: ${res.status} ${res.statusText}`);
-	const data = validateSFAIndex(await res.json());
-	indexCache.set(url, data);
-	return data;
+function loadFont(story, filename, diagnostics) {
+	const result = parseFontFile(filename);
+	for (const p of result.passages) storyAdd(story, p, diagnostics);
 }
 /**
-* Find the best matching entry in an SFA index.
-* Exact version preferred, then highest version with same major.
+* Load sources with mtime-based caching for incremental rebuilds.
+* Always creates a fresh Story; cached passages are replayed via storyAdd().
 */
-function findEntry(index, name, version) {
-	const wanted = parseSemver(version);
-	const searchArrays = [{
-		entries: index.twine2 ?? [],
-		formatType: "twine2"
-	}, {
-		entries: index.twine1 ?? [],
-		formatType: "twine1"
-	}];
-	let bestResult;
-	let bestVersion = null;
-	for (const { entries, formatType } of searchArrays) for (const entry of entries) {
-		if (entry.name.toLowerCase() !== name.toLowerCase()) continue;
-		const have = parseSemver(entry.version);
-		if (!have) continue;
-		if (wanted && semverCompare(have, wanted) === 0) return {
-			entry,
-			formatType
-		};
-		if (wanted === null || have[0] === wanted[0] && semverCompare(have, wanted) >= 0) {
-			if (!bestVersion || semverCompare(have, bestVersion) > 0) {
-				bestVersion = have;
-				bestResult = {
-					entry,
-					formatType
-				};
-			}
+function loadSourcesCached(story, filenames, opts, diagnostics, processedFiles, cache, changedFiles) {
+	const currentFiles = /* @__PURE__ */ new Set();
+	for (const filename of filenames) {
+		if (processedFiles.has(filename)) {
+			diagnostics.push({
+				level: "warning",
+				message: `load ${filename}: Skipping duplicate.`
+			});
+			continue;
+		}
+		currentFiles.add(filename);
+		const optionsKey = parseOptionsKey(filename, opts);
+		const entry = cache.get(filename);
+		const cached = entry?.parseOptionsKey === optionsKey ? entry : void 0;
+		if (changedFiles && cached && !changedFiles.has(filename)) {
+			diagnostics.push(...cached.diagnostics);
+			for (const p of cached.passages) storyAdd(story, p, diagnostics);
+			processedFiles.add(filename);
+			continue;
+		}
+		let mtimeMs;
+		try {
+			mtimeMs = statSync(filename).mtimeMs;
+		} catch {
+			continue;
+		}
+		if (cached && cached.mtimeMs === mtimeMs) {
+			diagnostics.push(...cached.diagnostics);
+			for (const p of cached.passages) storyAdd(story, p, diagnostics);
+			processedFiles.add(filename);
+			continue;
+		}
+		try {
+			const result = parseFile(filename, opts);
+			if (!result) continue;
+			cache.set(filename, {
+				mtimeMs,
+				parseOptionsKey: optionsKey,
+				passages: result.passages,
+				diagnostics: result.diagnostics
+			});
+			diagnostics.push(...result.diagnostics);
+			for (const p of result.passages) storyAdd(story, p, diagnostics);
+		} catch (e) {
+			diagnostics.push({
+				level: "error",
+				message: `load ${filename}: ${e instanceof Error ? e.message : String(e)}`,
+				file: filename
+			});
+			continue;
 		}
+		processedFiles.add(filename);
+	}
+	for (const key of cache.keys()) if (!currentFiles.has(key)) cache.delete(key);
+	if (story.name !== "" && !story.passages.some((p) => p.name === "StoryTitle")) storyPrepend(story, {
+		name: "StoryTitle",
+		tags: [],
+		text: story.name
+	}, diagnostics);
+}
+//#endregion
+//#region src/version.ts
+/**
+* The twee-ts version, read at runtime from the package's own package.json.
+*
+* The release workflow (semantic-release) writes the new version into the
+* published package.json only; git keeps the old one. Reading it at runtime
+* is the only way the CLI and `creator-version` report the published version.
+*/
+const PACKAGE_NAME = "@rohal12/twee-ts";
+/** Walks up from `startDir` to the nearest package.json named @rohal12/twee-ts and returns its version. */
+function findPackageVersion(startDir) {
+	let dir = startDir;
+	for (;;) {
+		try {
+			const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
+			if (pkg.name === PACKAGE_NAME && typeof pkg.version === "string") return pkg.version;
+		} catch {}
+		const parent = dirname(dir);
+		if (parent === dir) return void 0;
+		dir = parent;
 	}
-	return bestResult;
 }
-/** Verify SHA-256 checksum using Web Crypto API (Node 22 built-in). */
-async function verifySHA256(content, expectedHex) {
-	const digest = await crypto.subtle.digest("SHA-256", content);
-	return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("") === expectedHex.toLowerCase();
+/** This module's directory: `__dirname` in the CJS build, `import.meta.url` in ESM and in source. */
+function moduleDir() {
+	return typeof __dirname === "string" ? __dirname : dirname(fileURLToPath(import.meta.url));
 }
-/** Derive the download URL for a format.js from the index URL and entry. */
-function getDownloadUrl(indexUrl, entry, formatType) {
-	return `${indexUrl.replace(/\/index\.json$/, "")}/${formatType}/${entry.name}/${entry.version}/format.js`;
+const VERSION = findPackageVersion(moduleDir()) ?? "0.0.0";
+//#endregion
+//#region src/output-twine2.ts
+const CREATOR_NAME$2 = "Twee-ts";
+function toTwine2Archive(story, startName, options) {
+	return getTwine2DataChunk(story, startName, options) + "\n";
 }
-/** Download a format, verify its checksum, write to cache, and return StoryFormatInfo. */
-async function fetchAndCacheFormat(entry, downloadUrl) {
-	const res = await fetch(downloadUrl);
-	if (!res.ok) throw new Error(`Failed to download format from ${downloadUrl}: ${res.status} ${res.statusText}`);
-	const text = await res.text();
-	const checksumKey = Object.keys(entry.checksums ?? {}).find((k) => k.endsWith("format.js"));
-	if (checksumKey) {
-		const expected = entry.checksums[checksumKey];
-		if (!expected) throw new Error(`Missing checksum value for key "${checksumKey}"`);
-		if (!await verifySHA256(new TextEncoder().encode(text), expected)) throw new Error(`Checksum verification failed for ${entry.name} ${entry.version}`);
+function toTwine2HTML(story, format, startName, options) {
+	let template = readFormatSource(format);
+	if (template.includes("{{STORY_NAME}}")) {
+		const name = htmlEscape(story.name);
+		template = template.replaceAll("{{STORY_NAME}}", () => name);
 	}
-	const id = makeFormatId(entry.name, entry.version);
-	const data = parseFormatJSON(text, id);
-	if (!data) throw new Error(`Failed to parse format JSON from ${downloadUrl}`);
-	const cacheDir = getCacheDir();
-	const formatDir = join(cacheDir, entry.name, entry.version);
-	mkdirSync(formatDir, { recursive: true });
-	const formatPath = join(formatDir, "format.js");
-	writeFileSync(formatPath, text, "utf-8");
-	return {
-		id,
-		filename: formatPath,
-		isTwine2: true,
-		name: data.name,
-		version: data.version,
-		proofing: data.proofing ?? false
-	};
-}
-/** Download a direct format.js URL, parse its JSON, cache it, and return StoryFormatInfo. */
-async function fetchDirectFormat(url) {
-	const res = await fetch(url);
-	if (!res.ok) throw new Error(`Failed to download format from ${url}: ${res.status} ${res.statusText}`);
-	const text = await res.text();
-	const data = parseFormatJSON(text, "direct-url");
-	if (!data) throw new Error(`Failed to parse format JSON from ${url}`);
-	const id = makeFormatId(data.name, data.version);
-	const cacheDir = getCacheDir();
-	const formatDir = join(cacheDir, data.name, data.version);
-	mkdirSync(formatDir, { recursive: true });
-	const formatPath = join(formatDir, "format.js");
-	writeFileSync(formatPath, text, "utf-8");
-	return {
-		id,
-		filename: formatPath,
-		isTwine2: true,
-		name: data.name,
-		version: data.version,
-		proofing: data.proofing ?? false
-	};
+	if (template.includes("{{STORY_DATA}}")) {
+		const data = getTwine2DataChunk({
+			...story,
+			twine2: {
+				...story.twine2,
+				format: format.name,
+				formatVersion: format.version
+			}
+		}, startName, options);
+		template = template.replace("{{STORY_DATA}}", () => data);
+	}
+	return template;
 }
+const OMITTING_TAGS = [
+	"Twine.private",
+	"script",
+	"stylesheet"
+];
 /**
-* Try to resolve a remote story format by name and version.
-* 1. Try direct format URLs
-* 2. Try custom index URLs
-* 3. Try default SFA indices
+* Why Twine 2 output leaves a passage out of its `<tw-passagedata>` elements,
+* or `undefined` when the passage is emitted (and so can be the starting passage).
 */
-async function resolveRemoteFormat(name, version, indices, urls) {
-	let lastError;
-	if (urls) for (const url of urls) try {
-		const info = await fetchDirectFormat(url);
-		if (info.name.toLowerCase() === name.toLowerCase()) {
-			const wanted = parseSemver(version);
-			const have = parseSemver(info.version);
-			if (!wanted || have && have[0] === wanted[0] && semverCompare(have, wanted) >= 0) return info;
+function twine2PassageOmission(story, p) {
+	if (p.name === "StoryTitle" || p.name === "StoryData") return {
+		kind: "special-name",
+		name: p.name
+	};
+	const tag = OMITTING_TAGS.find((t) => hasTag(p, t));
+	if (tag !== void 0) return {
+		kind: "tag",
+		tag
+	};
+	if (p.name === "StorySettings" && story.twine1.settings.size === 0) return { kind: "empty-story-settings" };
+}
+function getTwine2DataChunk(story, startName, options) {
+	const parts = [];
+	let startID = "";
+	let pid = 0;
+	const scripts = [];
+	const stylesheets = [];
+	for (const p of story.passages) {
+		if (hasTag(p, "Twine.private")) continue;
+		if (hasTag(p, "script")) scripts.push(p);
+		else if (hasTag(p, "stylesheet")) stylesheets.push(p);
+	}
+	let styleContent = "";
+	if (stylesheets.length === 1) styleContent = stylesheets[0]?.text ?? "";
+	else if (stylesheets.length > 1) {
+		let pidS = 1;
+		for (const p of stylesheets) {
+			if (pidS > 1 && !styleContent.endsWith("\n")) styleContent += "\n";
+			styleContent += `/* twine-user-stylesheet #${pidS}: "${commentSanitize(p.name)}" */\n`;
+			styleContent += p.text;
+			pidS++;
 		}
-	} catch (e) {
-		lastError = e instanceof Error ? e : new Error(String(e));
 	}
-	const allIndices = [...indices ?? [], ...DEFAULT_SFA_INDICES];
-	for (const indexUrl of allIndices) try {
-		const result = findEntry(await fetchIndex(indexUrl), name, version);
-		if (result) {
-			const cached = getCachedFormat(result.entry.name, result.entry.version);
-			if (cached) return cached;
-			const downloadUrl = getDownloadUrl(indexUrl, result.entry, result.formatType);
-			return await fetchAndCacheFormat(result.entry, downloadUrl);
+	parts.push(`<style role="stylesheet" id="twine-user-stylesheet" type="text/twine-css">${styleContentEscape(styleContent)}</style>`);
+	let scriptContent = "";
+	if (scripts.length === 1) scriptContent = scripts[0]?.text ?? "";
+	else if (scripts.length > 1) {
+		let pidS = 1;
+		for (const p of scripts) {
+			if (pidS > 1 && !scriptContent.endsWith("\n")) scriptContent += "\n";
+			scriptContent += `/* twine-user-script #${pidS}: "${commentSanitize(p.name)}" */\n`;
+			scriptContent += p.text;
+			pidS++;
 		}
-	} catch (e) {
-		lastError = e instanceof Error ? e : new Error(String(e));
 	}
-	if (lastError) throw lastError;
+	parts.push(`<script role="script" id="twine-user-script" type="text/twine-javascript">${scriptContentEscape(scriptContent)}<\/script>`);
+	const validTagColors = /* @__PURE__ */ new Set([
+		"gray",
+		"red",
+		"orange",
+		"yellow",
+		"green",
+		"blue",
+		"purple"
+	]);
+	const hexColorPattern = /^#[0-9a-fA-F]{3,8}$/;
+	for (const [tag, color] of story.twine2.tagColors) if (validTagColors.has(color) || hexColorPattern.test(color)) parts.push(`<tw-tag name="${attrEscape(tag)}" color="${attrEscape(color)}"></tw-tag>`);
+	pid = 1;
+	for (const p of story.passages) {
+		if (twine2PassageOmission(story, p) !== void 0) continue;
+		parts.push(passageToPassagedata(p, pid, options));
+		if (startName === p.name) startID = String(pid);
+		pid++;
+	}
+	const opts = [];
+	for (const [opt, val] of story.twine2.options) if (val) opts.push(opt);
+	const optionsStr = opts.join(" ");
+	const zoom = String(story.twine2.zoom);
+	return `<!-- UUID://${htmlCommentSanitize(story.ifid)}// --><tw-storydata name="${attrEscape(story.name)}" startnode="${attrEscape(startID)}" creator="${attrEscape(CREATOR_NAME$2)}" creator-version="${attrEscape(VERSION)}" ifid="${attrEscape(story.ifid)}" zoom="${attrEscape(zoom)}" format="${attrEscape(story.twine2.format)}" format-version="${attrEscape(story.twine2.formatVersion)}" options="${attrEscape(optionsStr)}" tags="${attrEscape(story.twine2.tags)}" hidden>` + parts.join("") + "</tw-storydata>";
 }
-/** Check if a format is already in the local cache. */
-function getCachedFormat(name, version) {
-	const formatPath = join(getCacheDir(), name, version, "format.js");
-	try {
-		if (!existsSync(formatPath)) return void 0;
-		const source = readFileSync(formatPath, "utf-8");
-		const id = makeFormatId(name, version);
-		const data = parseFormatJSON(source, id);
-		if (!data) return void 0;
-		return {
-			id,
-			filename: formatPath,
-			isTwine2: true,
-			name: data.name,
-			version: data.version,
-			proofing: data.proofing ?? false
-		};
-	} catch {
-		return;
+//#endregion
+//#region src/output-twine1.ts
+/**
+* Twine 1 HTML and archive output.
+* Ported from storyout.go.
+*/
+const CREATOR_NAME$1 = "twee-ts";
+function toTwine1Archive(story, _startName) {
+	const { data, count } = getTwine1PassageChunk(story);
+	return `<div id="storeArea" data-size="${count}">${data}</div>\n`;
+}
+function toTwine1HTML(story, format, startName) {
+	const formatDir = dirname(format.filename);
+	const parentDir = dirname(formatDir);
+	let template = readFormatSource(format);
+	const { data, count } = getTwine1PassageChunk(story);
+	template = tryReplaceComponent(template, "\"USER_LIB\"", join(formatDir, "userlib.js"), false);
+	template = tryReplaceComponent(template, "\"ENGINE\"", join(parentDir, "engine.js"), true);
+	template = tryReplaceComponent(template, "\"SUGARCANE\"", join(formatDir, "code.js"), true);
+	template = tryReplaceComponent(template, "\"JONAH\"", join(formatDir, "code.js"), true);
+	if (story.twine1.settings.get("jquery") === "on") template = tryReplaceComponent(template, "\"JQUERY\"", join(parentDir, "jquery.js"), true);
+	if (story.twine1.settings.get("modernizr") === "on") template = tryReplaceComponent(template, "\"MODERNIZR\"", join(parentDir, "modernizr.js"), true);
+	const displayStart = startName === "Start" ? "" : startName;
+	template = template.replace("\"VERSION\"", `Compiled with ${CREATOR_NAME$1}, ${VERSION}`);
+	template = template.replace("\"TIME\"", `Built on ${(/* @__PURE__ */ new Date()).toUTCString()}`);
+	const startAtValue = `"${jsStringEscape(displayStart)}"`;
+	template = template.replace("\"START_AT\"", () => startAtValue);
+	template = template.replace("\"STORY_SIZE\"", `"${count}"`);
+	if (template.includes("\"STORY\"")) template = template.replace("\"STORY\"", () => data);
+	else {
+		let footer;
+		try {
+			footer = readFileSync(join(formatDir, "footer.html"), "utf-8");
+		} catch {
+			footer = "</div>\n</body>\n</html>\n";
+		}
+		template += data + footer;
+	}
+	if (story.ifid) {
+		const safeIfid = htmlCommentSanitize(story.ifid);
+		if (template.includes("<div id=\"store-area\"")) template = template.replace("<div id=\"store-area\"", `<!-- UUID://${safeIfid}// --><div id="store-area"`);
+		else template = template.replace("<div id=\"storeArea\"", `<!-- UUID://${safeIfid}// --><div id="storeArea"`);
 	}
+	return template;
 }
-/** Discover all cached remote formats. Returns a Map like discoverFormats(). */
-function discoverCachedFormats() {
-	const formats = /* @__PURE__ */ new Map();
-	const cacheDir = getCacheDir();
-	try {
-		if (!existsSync(cacheDir)) return formats;
-	} catch {
-		return formats;
+/**
+* Why Twine 1 output leaves a passage out of its tiddlers, or `undefined` when the passage is emitted.
+*/
+function twine1PassageOmission(p) {
+	return hasTag(p, "Twine.private") ? {
+		kind: "tag",
+		tag: "Twine.private"
+	} : void 0;
+}
+function getTwine1PassageChunk(story) {
+	const obfuscateRot13 = story.twine1.settings.get("obfuscate") === "rot13";
+	let data = "";
+	let count = 0;
+	for (const p of story.passages) {
+		if (twine1PassageOmission(p) !== void 0) continue;
+		count++;
+		data += passageToTiddler(p, count, obfuscateRot13);
 	}
-	let names;
+	return {
+		data,
+		count
+	};
+}
+function tryReplaceComponent(template, placeholder, componentPath, required) {
+	if (!template.includes(placeholder)) return template;
 	try {
-		names = readdirSync(cacheDir);
-	} catch {
-		return formats;
+		let content = readFileSync(componentPath, "utf-8");
+		if (content.charCodeAt(0) === 65279) content = content.slice(1);
+		return template.replace(placeholder, () => content);
+	} catch (e) {
+		if (required) throw new Error(`Required format component not found: ${componentPath}: ${e instanceof Error ? e.message : String(e)}`);
+		return template;
 	}
-	for (const name of names) {
-		const nameDir = join(cacheDir, name);
-		try {
-			if (!statSync(nameDir).isDirectory()) continue;
-		} catch {
-			continue;
-		}
-		let versions;
-		try {
-			versions = readdirSync(nameDir);
-		} catch {
-			continue;
-		}
-		for (const version of versions) {
-			const info = getCachedFormat(name, version);
-			if (info) formats.set(`${info.id}-${version}`, info);
+}
+//#endregion
+//#region src/output-twee.ts
+function toTwee(story, outMode) {
+	let data = "";
+	for (const p of story.passages) data += passageToTwee(p, outMode);
+	return data;
+}
+//#endregion
+//#region src/modules.ts
+/**
+* Load modules and return HTML tags to inject before </head>.
+*/
+function loadModules(filenames) {
+	const processed = /* @__PURE__ */ new Set();
+	const headTags = [];
+	for (const filename of filenames) {
+		if (processed.has(filename)) continue;
+		const ext = normalizedFileExt(filename);
+		let tag = null;
+		switch (ext) {
+			case "css":
+				tag = loadModuleTagged("style", filename);
+				break;
+			case "js":
+				tag = loadModuleTagged("script", filename);
+				break;
+			case "otf":
+			case "ttf":
+			case "woff":
+			case "woff2":
+				tag = loadModuleFont(filename);
+				break;
+			default: continue;
 		}
+		if (tag) headTags.push(tag);
+		processed.add(filename);
 	}
-	return formats;
+	return headTags.join("\n");
 }
-/** List all cached formats with size and modification date. */
-function listCachedFormats() {
-	const cacheDir = getCacheDir();
-	const entries = [];
-	try {
-		if (!existsSync(cacheDir)) return entries;
-	} catch {
-		return entries;
+function loadModuleTagged(tag, filename) {
+	const source = readUTF8(filename).trim();
+	if (source.length === 0) return null;
+	return `<${tag} id="${`${tag}-module-${slugify(baseNameWithoutExt(filename))}`}" type="${tag === "script" ? "text/javascript" : "text/css"}">${tag === "script" ? scriptContentEscape(source) : styleContentEscape(source)}</${tag}>`;
+}
+function loadModuleFont(filename) {
+	const source = readBase64(filename);
+	const family = baseNameWithoutExt(filename);
+	const idSlug = `style-module-${slugify(family)}`;
+	const ext = normalizedFileExt(filename);
+	return `<style id="${idSlug}" type="text/css">@font-face {\n\tfont-family: "${family}";\n\tsrc: url("data:${mediaTypeFromExt(ext)};base64,${source}") format("${fontFormatHint(ext)}");\n}</style>`;
+}
+/**
+* Inject modules and head file content before </head>.
+*/
+function modifyHead(html, modulePaths, headFile, diagnostics) {
+	const parts = [];
+	if (modulePaths.length > 0) {
+		const modules = loadModules(modulePaths).trim();
+		if (modules.length > 0) parts.push(modules);
 	}
-	let names;
-	try {
-		names = readdirSync(cacheDir);
-	} catch {
-		return entries;
+	if (headFile) try {
+		const source = readUTF8(headFile).trim();
+		if (source.length > 0) parts.push(source);
+	} catch (e) {
+		diagnostics?.push({
+			level: "warning",
+			message: `Failed to read head file "${headFile}": ${e instanceof Error ? e.message : String(e)}`
+		});
 	}
-	for (const name of names) {
-		const nameDir = join(cacheDir, name);
-		try {
-			if (!statSync(nameDir).isDirectory()) continue;
-		} catch {
-			continue;
-		}
-		let versions;
-		try {
-			versions = readdirSync(nameDir);
-		} catch {
-			continue;
-		}
-		for (const version of versions) {
-			const formatPath = join(nameDir, version, "format.js");
-			try {
-				const stat = statSync(formatPath);
-				entries.push({
-					name,
-					version,
-					sizeBytes: stat.size,
-					modifiedAt: stat.mtime
-				});
-			} catch {}
-		}
+	if (parts.length > 0) {
+		parts.push("</head>");
+		const replacement = parts.join("\n");
+		return html.replace("</head>", () => replacement);
 	}
-	return entries;
+	return html;
 }
-/** Clear all cached formats, or only those matching a given name. Returns the number of entries removed. */
-function clearCachedFormats(name) {
-	const cacheDir = getCacheDir();
-	if (!existsSync(cacheDir)) return 0;
-	if (!name) {
-		const count = listCachedFormats().length;
-		rmSync(cacheDir, {
-			recursive: true,
-			force: true
-		});
-		return count;
+//#endregion
+//#region src/start-passage.ts
+function describeOmission(omission) {
+	switch (omission.kind) {
+		case "special-name": return `is the special "${omission.name}" passage`;
+		case "tag": return `is tagged "${omission.tag}"`;
+		case "empty-story-settings": return "is an empty \"StorySettings\" passage";
+		default: throw new Error(`unhandled passage omission: ${JSON.stringify(omission)}`);
 	}
-	const nameDir = join(cacheDir, name);
-	if (!existsSync(nameDir)) return 0;
-	let versions;
-	try {
-		versions = readdirSync(nameDir);
-	} catch {
-		return 0;
+}
+function omissionFor(story, passage, target) {
+	switch (target) {
+		case "twine2": return twine2PassageOmission(story, passage);
+		case "twine1": return twine1PassageOmission(passage);
+		default: throw new Error(`unhandled start passage target: ${String(target)}`);
 	}
-	const count = versions.length;
-	rmSync(nameDir, {
-		recursive: true,
-		force: true
-	});
-	return count;
 }
-/** Get total cache size in bytes and format count. */
-function getCacheSize() {
-	const entries = listCachedFormats();
-	return {
-		totalBytes: entries.reduce((sum, e) => sum + e.sizeBytes, 0),
-		count: entries.length
-	};
+/**
+* Check that `startName` names a passage the `target` output emits.
+* Returns the error diagnostics to report (empty when the start is usable).
+*/
+function startPassageDiagnostics(story, startName, target) {
+	const passage = story.passages.find((p) => p.name === startName);
+	if (passage === void 0) return [{
+		level: "error",
+		message: `Starting passage "${startName}" not found.`
+	}];
+	const omission = omissionFor(story, passage, target);
+	if (omission === void 0) return [];
+	return [{
+		level: "error",
+		message: `Starting passage "${startName}" ${describeOmission(omission)}, so it is left out of the story data. Choose a story passage.`
+	}];
 }
 //#endregion
 //#region src/compiler.ts
@@ -5152,7 +5543,7 @@ async function compile(options) {
 * Compile and write to a file.
 */
 async function compileToFile(options) {
-	const result = await compile(options);
+	const result = await buildOutput(options, void 0, void 0, options.outFile);
 	writeFileSync(options.outFile, result.output, "utf-8");
 	return result;
 }
@@ -5171,18 +5562,35 @@ async function watch(options) {
 	const cache = /* @__PURE__ */ new Map();
 	const filePaths = options.sources.filter((s) => typeof s === "string");
 	const modulePaths = options.modules ?? [];
-	const handle = watchFilesystem([...filePaths, ...modulePaths], options.outFile, (changedFiles) => {
-		buildOutput(options, cache, changedFiles).then((result) => {
+	const headPaths = options.headFile ? [options.headFile] : [];
+	const allPaths = [
+		...filePaths,
+		...modulePaths,
+		...headPaths
+	];
+	const exclude = options.exclude ?? [];
+	const notExcludable = [...modulePaths, ...headPaths].map((p) => resolve(p));
+	const ignore = (filename) => {
+		if (!isExcluded(filename, exclude)) return false;
+		const abs = resolve(filename);
+		return !notExcludable.some((root) => abs === root || abs.startsWith(root + sep));
+	};
+	const handle = watchFilesystem(allPaths, options.outFile, (changedFiles) => {
+		buildOutput(options, cache, changedFiles, options.outFile).then((result) => {
 			writeFileSync(options.outFile, result.output, "utf-8");
 			options.onBuild?.(result);
 		}).catch((e) => {
 			options.onError?.(e instanceof Error ? e : new Error(String(e)));
 		});
-	});
+	}, ignore);
 	controller.signal.addEventListener("abort", () => handle.close());
 	return controller;
 }
-async function buildOutput(options, cache, changedFiles) {
+/**
+* `outFile`: the file the build is written to, which source and module discovery
+* skip (as Tweego does), so an output inside a source folder is never loaded back.
+*/
+async function buildOutput(options, cache, changedFiles, outFile) {
 	const diagnostics = [];
 	const outputMode = options.outputMode ?? "html";
 	const trim = options.trim ?? true;
@@ -5195,7 +5603,7 @@ async function buildOutput(options, cache, changedFiles) {
 	const inlineSources = [];
 	for (const source of options.sources) if (typeof source === "string") filePaths.push(source);
 	else inlineSources.push(source);
-	const { filenames: sourceFilenames, diagnostics: sourcePathDiagnostics } = getFilenames(filePaths);
+	const { filenames: sourceFilenames, diagnostics: sourcePathDiagnostics } = getFilenames(filePaths, outFile, options.exclude);
 	diagnostics.push(...sourcePathDiagnostics);
 	const story = createStory();
 	const processedFiles = /* @__PURE__ */ new Set();
@@ -5213,33 +5621,12 @@ async function buildOutput(options, cache, changedFiles) {
 	}, diagnostics);
 	if (options.tagAliases) story.passages = applyTagAliases(story.passages, options.tagAliases);
 	let format;
-	let formatId = options.formatId ?? "";
-	if (outputMode === "html") {
-		const formats = discoverFormats(getFormatSearchDirs(options.formatPaths, options.useTweegoPath ?? true));
-		if (!formatId && story.twine2.format) formatId = getFormatIdByNameAndVersion(formats, story.twine2.format, story.twine2.formatVersion) ?? "";
-		if (!formatId) formatId = DEFAULT_FORMAT_ID;
-		format = formats.get(formatId);
-		if (!format && !noRemote) {
-			const remoteName = story.twine2.format || formatId;
-			const remoteVersion = story.twine2.formatVersion || "";
-			try {
-				format = await resolveRemoteFormat(remoteName, remoteVersion, options.formatIndices, options.formatUrls);
-			} catch (e) {
-				diagnostics.push({
-					level: "warning",
-					message: `Remote format fetch failed for "${remoteName}": ${e instanceof Error ? e.message : String(e)}`
-				});
-			}
-		}
-		if (!format) {
-			const reason = noRemote ? " (remote fetching disabled)" : "";
-			diagnostics.push({
-				level: "error",
-				message: `Story format "${formatId}" is not available${reason}. Found: ${[...formats.keys()].join(", ") || "none"}`
-			});
-		}
-	}
-	const startName = options.startPassage || story.twine2.start || DEFAULT_START_NAME;
+	if (outputMode === "html") format = await resolveStoryFormat(formatRequestFor(options.formatId, story.twine2.format, story.twine2.formatVersion, DEFAULT_FORMAT_ID), {
+		...options,
+		noRemote
+	}, diagnostics);
+	if (options.startPassage) story.twine2.start = options.startPassage;
+	const startName = story.twine2.start || DEFAULT_START_NAME;
 	if (testMode) story.twine2.options.set("debug", true);
 	ensureIFID(story, diagnostics);
 	let output;
@@ -5258,10 +5645,7 @@ async function buildOutput(options, cache, changedFiles) {
 			output = storyToJSON(story);
 			break;
 		case "html": {
-			if (!storyHas(story, startName)) diagnostics.push({
-				level: "error",
-				message: `Starting passage "${startName}" not found.`
-			});
+			diagnostics.push(...startPassageDiagnostics(story, startName, format?.isTwine2 === false ? "twine1" : "twine2"));
 			if (!format) throw new TweeTsError("No story format available for HTML output.", diagnostics);
 			if (format.isTwine2) output = toTwine2HTML(story, format, startName, { sourceInfo });
 			else {
@@ -5271,7 +5655,7 @@ async function buildOutput(options, cache, changedFiles) {
 				});
 				output = toTwine1HTML(story, format, startName);
 			}
-			const modules = getFilenames(options.modules ?? []);
+			const modules = getFilenames(options.modules ?? [], outFile);
 			diagnostics.push(...modules.diagnostics);
 			output = modifyHead(output, modules.filenames, options.headFile, diagnostics);
 			break;
@@ -5691,19 +6075,227 @@ function endOfRegularExpression(source, pos) {
 	};
 }
 //#endregion
+//#region src/link-markup.ts
+/**
+* Reads link or image markup that starts at `start` in `text`, or returns `undefined` where
+* SugarCube rejects it (and so prints the text instead).
+*
+* `budget.left`, if given, is how many characters the reading may look at; it is reduced by as
+* many as were read, and once it runs out, every reading fails. Unclosed markup is read to the end
+* of its line, so reading every `[[` of a long line that never closes one would otherwise take
+* quadratic time.
+*/
+function readSquareBracketedMarkup(text, start, budget = { left: Infinity }) {
+	const reader = {
+		text,
+		limit: Math.min(text.length, start + Math.max(budget.left, 0))
+	};
+	const markup = readMarkup(reader, start);
+	budget.left -= (markup?.end ?? reader.limit) - start;
+	return markup;
+}
+function readMarkup(reader, start) {
+	const { text } = reader;
+	if (text[start] !== "[") return;
+	let pos = start + 1;
+	let type;
+	if (text[pos] === "[") {
+		type = "link";
+		pos += 1;
+	} else {
+		if (text[pos] === "<" || text[pos] === ">") pos += 1;
+		if (!/^[Ii][Mm][Gg]\[/.test(text.slice(pos, pos + 4))) return;
+		type = "image";
+		pos += 4;
+	}
+	const core = readCoreComponents(reader, pos);
+	if (core === void 0) return;
+	if (type === "link") {
+		if (!core.end.last) {
+			const setterEnd = readSetter(reader, core.end.next);
+			if (setterEnd === void 0) return;
+			return {
+				type,
+				link: linkName(core.link),
+				end: setterEnd
+			};
+		}
+		return {
+			type,
+			link: linkName(core.link),
+			end: core.end.next
+		};
+	}
+	if (core.end.last) return {
+		type,
+		link: void 0,
+		end: core.end.next
+	};
+	const linkEnd = readComponent(reader, core.end.next, false);
+	if (linkEnd === void 0) return;
+	const link = linkName(text.slice(core.end.next, linkEnd.textEnd));
+	if (linkEnd.last) return {
+		type,
+		link,
+		end: linkEnd.next
+	};
+	const setterEnd = readSetter(reader, linkEnd.next);
+	return setterEnd === void 0 ? void 0 : {
+		type,
+		link,
+		end: setterEnd
+	};
+}
+/** The link component as SugarCube keeps it: trimmed, and without a leading `~`. */
+function linkName(component) {
+	const trimmed = component.trim();
+	return trimmed.startsWith("~") ? trimmed.slice(1) : trimmed;
+}
+/**
+* Reads the first components: the text and the link of link markup, or the title and the source
+* of image markup, divided by the first delimiter. `link` is the text of the link (or source)
+* component, untrimmed.
+*/
+function readCoreComponents(reader, from) {
+	const { text } = reader;
+	let delimiter = "none";
+	let componentStart = from;
+	let link;
+	let depth = 2;
+	let pos = from;
+	while (pos < reader.limit) {
+		const ch = text[pos];
+		pos += 1;
+		switch (ch) {
+			case "\n": return;
+			case "\"": {
+				const end = readQuoted(reader, pos, "\"");
+				if (end === void 0) return;
+				pos = end;
+				break;
+			}
+			case "|":
+				if (delimiter === "none") {
+					delimiter = "ltr";
+					componentStart = pos;
+				}
+				break;
+			case "-":
+				if (delimiter === "none" && text[pos] === ">") {
+					delimiter = "ltr";
+					pos += 1;
+					componentStart = pos;
+				}
+				break;
+			case "<":
+				if (delimiter === "none" && text[pos] === "-") {
+					delimiter = "rtl";
+					link = text.slice(componentStart, pos - 1);
+					pos += 1;
+					componentStart = pos;
+				}
+				break;
+			case "[":
+				depth += 1;
+				break;
+			case "]":
+				depth -= 1;
+				if (depth === 1) {
+					const end = componentEnd(text, pos);
+					if (end === void 0) return;
+					return {
+						link: link ?? text.slice(componentStart, end.textEnd),
+						end
+					};
+				}
+		}
+	}
+}
+/**
+* Reads a component after `][` that holds no delimiter: an image's link (`setter` false) or a
+* setter, in which single quotes also quote.
+*/
+function readComponent(reader, from, setter) {
+	const { text } = reader;
+	let depth = 2;
+	let pos = from;
+	while (pos < reader.limit) {
+		const ch = text[pos];
+		pos += 1;
+		switch (ch) {
+			case "\n": return;
+			case "\"":
+			case "'": {
+				if (ch === "'" && !setter) break;
+				const end = readQuoted(reader, pos, ch);
+				if (end === void 0) return;
+				pos = end;
+				break;
+			}
+			case "[":
+				depth += 1;
+				break;
+			case "]":
+				depth -= 1;
+				if (depth === 1) return componentEnd(text, pos);
+		}
+	}
+}
+/** Reads a setter, the last component; returns the index after its closing `]]`. */
+function readSetter(reader, from) {
+	const end = readComponent(reader, from, true);
+	return end?.last === true ? end.next : void 0;
+}
+/** What the `]` just before `pos`, which brings the depth back to one, ends; `undefined` if malformed. */
+function componentEnd(text, pos) {
+	switch (text[pos]) {
+		case "[": return {
+			textEnd: pos - 1,
+			next: pos + 1,
+			last: false
+		};
+		case "]": return {
+			textEnd: pos - 1,
+			next: pos + 1,
+			last: true
+		};
+		default: return;
+	}
+}
+/**
+* Reads a quoted string from just after its opening quote; a backslash escapes the character
+* after it. A line feed, or the end of the text, ends it unterminated. Returns the index after the
+* closing quote.
+*/
+function readQuoted(reader, from, quote) {
+	const { text } = reader;
+	let pos = from;
+	while (pos < reader.limit) {
+		const ch = text[pos];
+		pos += 1;
+		if (ch === quote) return pos;
+		if (ch === "\n") return;
+		if (ch === "\\") {
+			if (pos >= reader.limit || text[pos] === "\n") return;
+			pos += 1;
+		}
+	}
+}
+//#endregion
 //#region src/sugarcube-macros.ts
 /**
-* Reads SugarCube 2 macro calls the way SugarCube 2.37.3 does, so the link check sees the same
-* passage names that `<<link>>` and `<<goto>>` use when the story plays.
+* Reads SugarCube 2 macro calls and link markup the way SugarCube 2.37.3 does, so the link check
+* sees the same passage names that `[[…]]` links, `<<link>>` and `<<goto>>` use when the story
+* plays.
 *
 * Each step follows a part of SugarCube's macro parser:
 * - `findMacroTags` finds where a tag starts and ends (the parser's `lookahead` pattern);
 * - `parseMacroArgs` splits the text after the macro name into arguments (`parseArgs`);
 * - quoted arguments are evaluated as strict-mode JavaScript strings (`evalStringLiteral`).
 *
+* Link and image markup is read as `parseSquareBracketedMarkup` reads it (see `link-markup.ts`).
 * Of the rest of the wikifier, only comments, `<script>` elements and `<<script>>` bodies are
-* told apart; other markup, such as verbatim text, is read as markup (see
-* `findMacroPassageLinks`).
+* told apart; other markup, such as verbatim text, is read as markup (see `findPassageLinks`).
 */
 const NAME_RE = /\/?[A-Za-z][\w-]*|[=-]/y;
 const SPACES_RE = /\s*/y;
@@ -5748,17 +6340,22 @@ const RAW_ARGUMENT_MACROS = /* @__PURE__ */ new Set([
 * levels; the limit keeps the work linear in the size of the text on any input.
 */
 const MAX_STRING_DEPTH = 10;
-/** A context for reading `text`: the closer search may read four times it, plus an allowance. */
+/**
+* A context for reading `text`: the closer search, and the markup reading, may each read four
+* times it, plus an allowance.
+*/
 function readContext(text) {
+	const allowance = () => ({ left: 4 * text.length + 1e5 });
 	return {
 		depth: 0,
-		budget: { left: 4 * text.length + 1e5 }
+		budget: allowance(),
+		markupBudget: allowance()
 	};
 }
 function deeper(context) {
 	return {
-		depth: context.depth + 1,
-		budget: context.budget
+		...context,
+		depth: context.depth + 1
 	};
 }
 /** Index of the first match of a global `re` at or after `from`, or -1. */
@@ -5988,7 +6585,10 @@ function lexArgument(raw, pos) {
 		case "[": {
 			const end = lexSquareBracketed(raw, pos + 1);
 			return end === void 0 ? void 0 : {
-				arg: { kind: "markup" },
+				arg: {
+					kind: "markup",
+					text: raw.slice(pos, end)
+				},
 				end
 			};
 		}
@@ -6132,13 +6732,44 @@ function ownPassageLink(tag, lexed) {
 	const arg = passageArgument(tag.name, lexed);
 	const passage = arg === void 0 ? void 0 : passageName(arg);
 	return passage === void 0 ? void 0 : {
-		macro: tag.name,
+		via: tag.name,
 		passage
 	};
 }
 /**
-* The passages a tag names: its own, if it is a `<<link>>` or `<<goto>>` call, then those of the
-* calls inside the strings of its arguments, which the macro may print or pass on
+* The passage a link's destination names. SugarCube evaluates a destination that no passage is
+* named by, and a quoted string gives its value (`[[Go|"Room"]]`), unless that is blank.
+*/
+function linkDestination(link) {
+	const value = evalStringLiteral(link);
+	return value === void 0 || value.trim() === "" ? link : value;
+}
+/**
+* The passage that link markup from `start` in `text` names, and where the markup ends, or
+* `undefined` where SugarCube rejects the markup. Image markup names none here, nor does markup
+* with a template literal's `${…}` in it, whose passage is known only in play.
+*/
+function linkMarkupAt(text, start, budget) {
+	const markup = readSquareBracketedMarkup(text, start, budget);
+	if (markup === void 0) return;
+	const passage = markup.type === "link" && !text.slice(start, markup.end).includes("﷐") ? markup.link : void 0;
+	return {
+		link: passage === void 0 ? void 0 : {
+			via: "markup",
+			passage: linkDestination(passage)
+		},
+		end: markup.end
+	};
+}
+/** The passage that a link markup argument names, if SugarCube reads the whole argument as markup. */
+function markupArgumentLinks(raw) {
+	const markup = linkMarkupAt(raw, 0);
+	return markup?.link === void 0 || markup.end !== raw.length ? [] : [markup.link];
+}
+/**
+* The passages a tag names: its own, if it is a `<<link>>` or `<<goto>>` call, then those of its
+* link markup arguments (`<<button [[Go|Room]]>>`), and those of the links and calls inside the
+* strings of its arguments, which the macro may print or pass on
 * (`<<set _out to '<<link "Go" "Room">><</link>>'>>`). The arguments of the macros SugarCube
 * doesn't split are read as JavaScript; in others, a backquoted expression is.
 */
@@ -6151,7 +6782,7 @@ function tagPassageLinks(tag, context) {
 		switch (arg.kind) {
 			case "string": return markupPassageLinks(arg.value, deeper(context));
 			case "expression": return javaScriptPassageLinks(arg.code, context);
-			case "markup":
+			case "markup": return markupArgumentLinks(arg.text);
 			case "word": return [];
 			default: throw new Error(`unhandled macro argument: ${JSON.stringify(arg)}`);
 		}
@@ -6161,16 +6792,26 @@ function tagPassageLinks(tag, context) {
 /**
 * The passage named by a `<<link>>` or `<<goto>>` that appears unquoted inside another tag's
 * arguments, at `start`. SugarCube never sees such an outer "tag" when its `<<` lies in text it
-* reads as something else, such as link markup (`[[<<-- Back|Prev]]`); the call inside it then
-* runs. The call ends where the outer tag ends.
+* reads as something else, such as verbatim text (`{{{<<if}}}`); the call inside it then runs.
+* The call ends where the outer tag ends.
 */
 function innerPassageLink(matchTagAt, start) {
 	const inner = matchTagAt(start)?.tag;
 	const lexed = inner === void 0 ? void 0 : lexMacroArgs(inner.args);
 	return inner === void 0 || lexed === void 0 ? void 0 : ownPassageLink(inner, lexed);
 }
-const REGION_OPEN_RE = /\/\/|\/\*|\/%|<!--|<[Ss][Cc][Rr][Ii][Pp][Tt]/g;
+const REGION_OPEN_RE = /\[\[[^[]|\[[<>]?[Ii][Mm][Gg]\[|\/\/|\/\*|\/%|<!--|<[Ss][Cc][Rr][Ii][Pp][Tt]/g;
 const HAS_SCRIPT_OPEN_RE = /<[Ss][Cc][Rr][Ii][Pp][Tt]/;
+function regionKind(opener) {
+	if (opener.startsWith("[")) return "markup";
+	switch (opener) {
+		case "//":
+		case "/*":
+		case "/%":
+		case "<!--": return opener;
+		default: return "script";
+	}
+}
 const SCRIPT_CLOSE_RE = /<\/[Ss][Cc][Rr][Ii][Pp][Tt]>|[\r\u2028\u2029]/g;
 const COMMENT_CLOSE_RES = {
 	"/*": /\*\/|[\r\u2028\u2029]/g,
@@ -6324,22 +6965,31 @@ function append(links, more) {
 	for (const link of more) links.push(link);
 }
 /**
-* The passages that `<<link>>` and `<<goto>>` calls in passage markup name. Calls whose passage
-* is known only in play (a variable or an expression) are left out. A tag's own passage comes
-* before those of the calls inside its arguments' strings.
+* The passages that link markup (`[[…]]`) and `<<link>>` and `<<goto>>` calls in passage markup
+* name, in the order they come. Calls whose passage is known only in play (a variable or an
+* expression) are left out. A tag's own passage comes before those that its arguments name, as
+* link markup or inside strings.
 *
 * The markup is walked in order, as SugarCube's wikifier walks it, with a tag tried at each
-* `<<` the walk reaches. Of the wikifier's other parsers, only those whose text holds no call
-* are told apart: comments (`/* … *` + `/`, `/% … %/`, `<!-- … -->`), whose calls never run,
-* and `<script>` elements and `<<script>>` bodies, which are JavaScript: only the calls in their
-* strings are read (see `findJavaScriptPassageLinks`). Everything else, verbatim text included,
-* is read as markup.
+* `<<` the walk reaches, and link or image markup read at each `[[` or `[img[`; markup SugarCube
+* rejects is read on from just after its opener, and so is markup after a limit on how much
+* markup a reading may scan, which only input built to take quadratic time reaches (see
+* `readSquareBracketedMarkup`). Image markup names no passage here. Of the wikifier's other
+* parsers, only those whose text holds no link or call are told apart: comments (`/* … *` + `/`,
+* `/% … %/`, `<!-- … -->`), whose links and calls never run, and `<script>` elements and
+* `<<script>>` bodies, which are JavaScript: only the links and calls in their strings are read
+* (see `findJavaScriptPassageLinks`). Everything else, verbatim text included, is read as markup.
 *
 * Where this differs from SugarCube:
+* - a link whose passage SugarCube evaluates, because no passage has its name, is taken by its
+*   name, `[[Go|$next]]` naming the passage `$next`, unless it is a quoted string, which is taken
+*   by its value even when a passage has the name with the quotes;
+* - a link SugarCube takes for a URL, because no passage has its name and it looks like one or
+*   holds a `/`, `.`, `?` or `#`, is still read as naming a passage;
 * - a comment or a `<<script>>` body is skipped whole, even where `parseBody` ends a container
 *   such as `<<if>>` at a closing tag inside it and the rest then runs;
-* - a `/*`, `<!--` or `<script` inside other markup that holds no call, such as link markup or a
-*   `<style>` element, still starts a comment or an element;
+* - a `[[`, `/*`, `<!--` or `<script` inside other markup that holds no call, such as verbatim
+*   text or a `<style>` element, still starts link markup, a comment or an element;
 * - a `<<` in such other markup still starts a tag. When that tag runs over a `<<link` or
 *   `<<goto` outside the parts of its arguments that the tag pattern reads as units, that call
 *   is still read (see `innerPassageLink`), even where the tag's arguments would be JavaScript,
@@ -6354,33 +7004,43 @@ function append(links, more) {
 *   `Config.passages.nobr`, are not joined before they are read (see `storyInspect` for passages
 *   tagged `nobr`).
 */
-function findMacroPassageLinks(text) {
+function findPassageLinks(text) {
 	return markupPassageLinks(text, readContext(text));
 }
 function markupPassageLinks(text, context) {
-	if (context.depth > MAX_STRING_DEPTH || !text.includes("<<") && !HAS_SCRIPT_OPEN_RE.test(text)) return [];
+	if (context.depth > MAX_STRING_DEPTH || !text.includes("<<") && !text.includes("[[") && !HAS_SCRIPT_OPEN_RE.test(text)) return [];
 	const matchTagAt = tagMatcher(text);
 	const matchInnerTagAt = tagMatcher(text);
 	const readComment = commentReader(text);
 	const readScriptElement = scriptElementReader(text);
 	let findScriptCloser;
 	const links = [];
-	/** Reads the region `opener` opens, adding the calls in a `<script>` element; returns where the walk goes on. */
+	/**
+	* Reads the region `opener` opens, adding the passage that link markup names and the links and
+	* calls in a `<script>` element; returns where the walk goes on.
+	*/
 	const regionEnd = (opener) => {
 		const start = opener.index;
-		const kind = opener[0];
+		const kind = regionKind(opener[0]);
 		switch (kind) {
+			case "markup": {
+				const markup = linkMarkupAt(text, start, context.markupBudget);
+				if (markup === void 0) return start + opener[0].length;
+				if (markup.link !== void 0) links.push(markup.link);
+				return markup.end;
+			}
 			case "//": return start + 2;
 			case "/*":
 			case "/%":
 			case "<!--": return readComment(kind, start) ?? start + kind.length;
-			default: {
+			case "script": {
 				const element = readScriptElement(start);
 				if (element.openerEnd === void 0) return start + 1;
 				if (element.close === void 0) return element.openerEnd;
 				append(links, javaScriptPassageLinks(text.slice(element.openerEnd, element.close), context));
 				return element.close + 9;
 			}
+			default: throw new Error(`unhandled region: ${String(kind)}`);
 		}
 	};
 	let macro = -2;
@@ -6420,24 +7080,26 @@ function markupPassageLinks(text, context) {
 	}
 }
 /**
-* The passages that `<<link>>` and `<<goto>>` calls in the strings of JavaScript source name,
-* such as a script passage or a `<<script>>` body: `$.wiki('<<goto "Room">>')`. Code outside
-* the strings isn't markup, so a call put together while the story plays, such as
-* `'<<goto "' + target + '">>'`, names no passage here.
+* The passages that link markup and `<<link>>` and `<<goto>>` calls in the strings of JavaScript
+* source name, such as a script passage or a `<<script>>` body: `$.wiki('<<goto "Room">>')`.
+* Code outside the strings isn't markup, so a call put together while the story plays, such as
+* `'<<goto "' + target + '">>'`, names no passage here, nor does an array of arrays (`[[0, 1]]`).
 */
 function findJavaScriptPassageLinks(source) {
 	return javaScriptPassageLinks(source, readContext(source));
 }
 /**
 * What JavaScript source must contain for one of its string or template literals to hold a call
-* that is read. A value holding `<<`: each `<` in it is written as `<`, `\<`, `\x3c`, `\u003c` or
-* `\u{…}`, two can be next to each other with only line continuations between, and the first
-* is `<` or `\<` (then the source holds `<<` or `<\`) or one of the others. Or a value holding a
-* `<script>` element, whose own strings can make `<<` from escapes the outer string encodes.
+* or link markup that is read. A value holding `<<`: each `<` in it is written as `<`, `\<`,
+* `\x3c`, `\u003c` or `\u{…}`, two can be next to each other with only line continuations
+* between, and the first is `<` or `\<` (then the source holds `<<` or `<\`) or one of the others.
+* A value holding `[[`, likewise: the source holds `[[`, a `[` before `\[` or a line continuation,
+* `\x5b`, `\u005b` or `\u{`. Or a value holding a `<script>` element, whose own strings can make
+* `<<` or `[[` from escapes the outer string encodes.
 */
-const MAY_HOLD_MACRO_RE = /<<|<\\|\\x3c|\\u003c|\\u\{|<script/i;
+const MAY_HOLD_LINK_RE = /<<|<\\|\\x3c|\\u003c|\\u\{|<script|\[\[|\[\\[[\n\r\u2028\u2029]|\\x5b|\\u005b/i;
 function javaScriptPassageLinks(source, context) {
-	if (context.depth >= MAX_STRING_DEPTH || !MAY_HOLD_MACRO_RE.test(source)) return [];
+	if (context.depth >= MAX_STRING_DEPTH || !MAY_HOLD_LINK_RE.test(source)) return [];
 	const inner = deeper(context);
 	const links = [];
 	for (const value of javaScriptStrings(source)) append(links, markupPassageLinks(value, inner));
@@ -6446,43 +7108,34 @@ function javaScriptPassageLinks(source, context) {
 //#endregion
 //#region src/inspect.ts
 /**
-* Extract all [[wiki-style links]] from passage text.
+* Extract the passages that passage text links to, read as SugarCube 2 reads them.
 *
 * Supported syntaxes:
 * - `[[PassageName]]`
-* - `[[Display Text->PassageName]]`  (Twine 2 / SugarCube arrow)
-* - `[[Display Text|PassageName]]`   (Twine 1 / Harlowe pipe)
-* - `<<goto "PassageName">>`         (SugarCube macro)
+* - `[[Display Text|PassageName]]`
+* - `[[Display Text->PassageName]]`
+* - `[[PassageName<-Display Text]]`
+* - any of those with a setter: `[[Display Text|PassageName][$x to 1]]`
+* - `<<goto "PassageName">>`            (SugarCube macro)
 * - `<<link "Display" "PassageName">>`  (SugarCube macro)
 *
-* SugarCube macro arguments may be double- or single-quoted, with backslash escapes, or bare
-* words; a passage named by a variable or an expression is known only in play and is skipped.
-* Macro calls are also read inside the quoted strings of other macros' arguments, and inside the
-* strings of `<<script>>` bodies and `<script>` elements; calls in comments are not read. A
-* script passage (`isScript`) is JavaScript, so its macro calls are read only inside its strings.
-* See `sugarcube-macros.ts` for the details and the known differences from SugarCube.
+* In link markup, the first `|`, `->` or `<-` divides the text from the passage name; image
+* markup (`[img[…][PassageName]]`) is not read. SugarCube macro arguments may be double- or
+* single-quoted, with backslash escapes, or bare words; a passage named by a variable or an
+* expression is known only in play and is skipped. Links and macro calls are also read inside the
+* quoted strings of macros' arguments, and inside the strings of `<<script>>` bodies and
+* `<script>` elements; links and calls in comments are not read. A script passage (`isScript`) is
+* JavaScript, so its links and calls are read only inside its strings. See `sugarcube-macros.ts`
+* for the details and the known differences from SugarCube.
 */
 function extractLinksFromText(text, isScript) {
-	const targets = /* @__PURE__ */ new Set();
-	const wikiLinkRe = /\[\[([^\]]+)\]\]/g;
-	let m;
-	while ((m = wikiLinkRe.exec(text)) !== null) {
-		const content = m[1];
-		const arrowIdx = content.indexOf("->");
-		if (arrowIdx !== -1) {
-			targets.add(content.slice(arrowIdx + 2).trim());
-			continue;
-		}
-		const pipeIdx = content.indexOf("|");
-		if (pipeIdx !== -1) {
-			targets.add(content.slice(pipeIdx + 1).trim());
-			continue;
-		}
-		targets.add(content.trim());
-	}
-	const macroLinks = isScript ? findJavaScriptPassageLinks(text) : findMacroPassageLinks(text);
-	for (const macro of ["goto", "link"]) for (const link of macroLinks) if (link.macro === macro) targets.add(link.passage);
-	return [...targets];
+	const found = isScript ? findJavaScriptPassageLinks(text) : findPassageLinks(text);
+	const ordered = [
+		"markup",
+		"goto",
+		"link"
+	].flatMap((via) => found.filter((link) => link.via === via).map((link) => link.passage));
+	return [...new Set(ordered)];
 }
 /** Passages SugarCube runs from their raw text, never joining their lines. */
 const RAW_TEXT_PASSAGES = /* @__PURE__ */ new Set([
@@ -6585,7 +7238,8 @@ function storyInspect(story) {
 //#region src/lint.ts
 /**
 * Lint a story: compile without output rendering, then inspect structure.
-* Uses JSON output mode internally to avoid format resolution.
+* Uses JSON output mode internally to avoid format resolution, so it checks
+* the starting passage itself, against the Twine 2 passage rules.
 */
 async function lint(options) {
 	const result = await compile({
@@ -6594,7 +7248,7 @@ async function lint(options) {
 	});
 	const map = storyInspect(result.story);
 	return {
-		diagnostics: result.diagnostics,
+		diagnostics: [...result.diagnostics, ...startPassageDiagnostics(result.story, map.start, "twine2")],
 		stats: result.stats,
 		formatName: result.story.twine2.format,
 		formatVersion: result.story.twine2.formatVersion,
@@ -6720,6 +7374,7 @@ function validateConfig(data) {
 	]) if (key in obj && typeof obj[key] !== "boolean") errors.push(`"${key}" must be a boolean.`);
 	for (const key of [
 		"sources",
+		"exclude",
 		"formatPaths",
 		"formatIndices",
 		"formatUrls",