@blastlauncher/engine 0.0.0-stage → 3.0.0-alpha.1

package/dist/tsconfig-paths.js

@@ -0,0 +1,329 @@
+// The subset of tsconfig `compilerOptions` that affects module resolution:
+// `baseUrl` and `paths`. Extensions import their own modules through them
+// (control-d's `common/...`), and esbuild never gets to apply them itself —
+// the dependency plugin resolves every bare specifier first — so the plugin
+// probes them here. Aliasing never reads outside the extension directory:
+// package-preset and out-of-tree `extends` targets (also via symlinks) are
+// skipped with a warning, and candidate paths are probed only inside it.
+import { readFile, realpath, stat } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve } from "node:path";
+/** File extensions tried for an extensionless alias target, esbuild's order. */
+const RESOLVE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs"];
+/**
+ * Parses the JSON with comments and trailing commas accepted by tsconfig.
+ * This stays local so loading a config cannot expand the host dependency
+ * surface. Strings are copied byte-for-byte, including URL-like `//` text.
+ */
+function parseJsonc(source) {
+    // Editors on Windows often save tsconfig with a UTF-8 byte-order mark,
+    // which tsc accepts and JSON.parse does not.
+    const text = source.startsWith("\uFEFF") ? source.slice(1) : source;
+    let withoutComments = "";
+    let inString = false;
+    let escaped = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let index = 0; index < text.length; index += 1) {
+        const character = text[index];
+        const next = text[index + 1];
+        if (inLineComment) {
+            if (character === "\n" || character === "\r") {
+                inLineComment = false;
+                withoutComments += character;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (character === "*" && next === "/") {
+                inBlockComment = false;
+                index += 1;
+            }
+            else if (character === "\n" || character === "\r") {
+                withoutComments += character;
+            }
+            continue;
+        }
+        if (inString) {
+            withoutComments += character;
+            if (escaped)
+                escaped = false;
+            else if (character === "\\")
+                escaped = true;
+            else if (character === '"')
+                inString = false;
+            continue;
+        }
+        if (character === '"') {
+            inString = true;
+            withoutComments += character;
+        }
+        else if (character === "/" && next === "/") {
+            inLineComment = true;
+            index += 1;
+        }
+        else if (character === "/" && next === "*") {
+            inBlockComment = true;
+            index += 1;
+        }
+        else {
+            withoutComments += character;
+        }
+    }
+    if (inString || inBlockComment)
+        throw new Error("unterminated JSONC token");
+    let json = "";
+    inString = false;
+    escaped = false;
+    for (let index = 0; index < withoutComments.length; index += 1) {
+        const character = withoutComments[index];
+        if (inString) {
+            json += character;
+            if (escaped)
+                escaped = false;
+            else if (character === "\\")
+                escaped = true;
+            else if (character === '"')
+                inString = false;
+            continue;
+        }
+        if (character === '"') {
+            inString = true;
+            json += character;
+            continue;
+        }
+        if (character === ",") {
+            let next = index + 1;
+            while (/\s/.test(withoutComments[next] ?? ""))
+                next += 1;
+            if (withoutComments[next] === "]" || withoutComments[next] === "}") {
+                index = next - 1;
+                continue;
+            }
+        }
+        json += character;
+    }
+    return JSON.parse(json);
+}
+async function kindOf(path) {
+    try {
+        const stats = await stat(path);
+        return stats.isFile() ? "file" : stats.isDirectory() ? "directory" : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** True when `path` is strictly inside `directory` (lexical, symlink-blind). */
+function inside(directory, path) {
+    const rel = relative(directory, path);
+    return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+/**
+ * Loads one tsconfig chain position: parents first (`extends`, lowest
+ * precedence first), then the file's own `compilerOptions` overriding per key.
+ * Returns `undefined` when the file cannot be used; every skip is explained
+ * in `warnings` so a broken config degrades to "no aliasing", never to a
+ * failed bundle.
+ */
+async function loadChain(file, extensionDir, stack, warnings) {
+    const path = resolve(file);
+    // A cycle is an extension bug; stop instead of looping.
+    if (stack.has(path))
+        return undefined;
+    const name = relative(extensionDir, path) || path;
+    // Never read a config outside the extension, including through a relative
+    // `extends` or a symlink: bundling runs outside any sandbox.
+    const [realDir, realPath] = await Promise.all([
+        realpath(extensionDir).catch(() => resolve(extensionDir)),
+        realpath(path).catch(() => path),
+    ]);
+    if (!inside(realDir, realPath)) {
+        warnings.push(`Blast ignored tsconfig ${JSON.stringify(name)}: outside the extension, so its path aliases are off`);
+        return undefined;
+    }
+    let text;
+    try {
+        text = await readFile(path, "utf8");
+    }
+    catch {
+        warnings.push(`Blast skipped unreadable tsconfig ${name} for path aliases`);
+        return undefined;
+    }
+    let json;
+    try {
+        json = parseJsonc(text);
+    }
+    catch {
+        warnings.push(`Blast skipped tsconfig ${name}: not valid JSON, so path aliases are off`);
+        return undefined;
+    }
+    if (typeof json !== "object" || json === null || Array.isArray(json))
+        return undefined;
+    const config = json;
+    stack.add(path);
+    const chain = {};
+    const parents = Array.isArray(config.extends)
+        ? config.extends
+        : config.extends === undefined
+            ? []
+            : [config.extends];
+    for (const parent of parents) {
+        // Package presets (`@tsconfig/strictest/tsconfig.json`) are resolved by
+        // tsc through node_modules, which aliasing never reads.
+        if (typeof parent !== "string" || (!parent.startsWith(".") && !isAbsolute(parent))) {
+            warnings.push(`Blast ignored the tsconfig extends target ${JSON.stringify(String(parent))}: ` +
+                "outside the extension, so its path aliases are off");
+            continue;
+        }
+        let parentFile = resolve(join(path, ".."), parent);
+        if ((await kindOf(parentFile)) === "directory")
+            parentFile = join(parentFile, "tsconfig.json");
+        const inherited = await loadChain(parentFile, extensionDir, stack, warnings);
+        if (inherited?.baseUrl)
+            chain.baseUrl = inherited.baseUrl;
+        if (inherited?.paths)
+            chain.paths = inherited.paths;
+    }
+    stack.delete(path);
+    if (typeof config.compilerOptions === "object" && config.compilerOptions !== null) {
+        const options = config.compilerOptions;
+        for (const key of ["baseUrl", "paths"]) {
+            if (options[key] !== undefined)
+                chain[key] = { value: options[key], directory: join(path, "..") };
+        }
+    }
+    return chain;
+}
+function parsePaths(declared, baseUrl) {
+    const value = declared?.value;
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return [];
+    // `paths` targets are relative to `baseUrl` when it is set (in any config
+    // of the chain), else to the config that declared `paths` (TS ≥ 4.1).
+    const base = baseUrl ?? declared.directory;
+    const patterns = [];
+    for (const [pattern, targets] of Object.entries(value)) {
+        if (!Array.isArray(targets))
+            continue;
+        const absolute = targets
+            .filter((target) => typeof target === "string")
+            .map((target) => resolve(base, target));
+        if (absolute.length > 0)
+            patterns.push([pattern, absolute]);
+    }
+    return patterns;
+}
+/** Exact patterns first, then wildcards by longest prefix, then longest suffix. */
+function matchPatterns(patterns, specifier) {
+    const matches = [];
+    for (const [pattern, targets] of patterns) {
+        const star = pattern.indexOf("*");
+        if (star === -1) {
+            if (pattern === specifier)
+                matches.push({ targets, capture: "", prefix: Infinity, suffix: 0 });
+            continue;
+        }
+        const prefix = pattern.slice(0, star);
+        const suffix = pattern.slice(star + 1);
+        if (specifier.length >= prefix.length + suffix.length &&
+            specifier.startsWith(prefix) &&
+            specifier.endsWith(suffix)) {
+            matches.push({
+                targets,
+                capture: specifier.slice(prefix.length, specifier.length - suffix.length),
+                prefix: prefix.length,
+                suffix: suffix.length,
+            });
+        }
+    }
+    return matches
+        .toSorted((a, b) => b.prefix - a.prefix || b.suffix - a.suffix)
+        .map(({ targets, capture }) => ({ targets, capture }));
+}
+async function firstFile(candidates) {
+    for (const candidate of candidates) {
+        if ((await kindOf(candidate)) === "file")
+            return candidate;
+    }
+    return undefined;
+}
+/** A candidate is a file, a file with an implied extension, or a directory. */
+async function probe(candidate) {
+    const kind = await kindOf(candidate);
+    if (kind === "file")
+        return candidate;
+    if (kind === "directory") {
+        // tsc honours a directory's package.json `main`; index files otherwise.
+        let main;
+        try {
+            const manifest = JSON.parse(await readFile(join(candidate, "package.json"), "utf8"));
+            if (typeof manifest.main === "string")
+                main = manifest.main;
+        }
+        catch {
+            // No package.json: fall back to index files.
+        }
+        if (main !== undefined) {
+            const direct = await firstFile([join(candidate, main)]);
+            if (direct)
+                return direct;
+            const implied = await firstFile(RESOLVE_EXTENSIONS.map((ext) => join(candidate, main + ext)));
+            if (implied)
+                return implied;
+        }
+        return firstFile(RESOLVE_EXTENSIONS.map((ext) => join(candidate, `index${ext}`)));
+    }
+    return firstFile(RESOLVE_EXTENSIONS.map((ext) => candidate + ext));
+}
+/**
+ * Reads the extension's tsconfig chain and returns a resolver for bare
+ * specifiers, or `undefined` when the extension has no `baseUrl`/`paths`.
+ */
+export async function loadTsconfigAliases(extensionDir) {
+    const root = join(extensionDir, "tsconfig.json");
+    // Most extensions have no tsconfig; that is normal, not a warning.
+    if ((await kindOf(root)) !== "file")
+        return undefined;
+    const warnings = [];
+    const chain = await loadChain(root, extensionDir, new Set(), warnings);
+    if (!chain)
+        // The config exists but cannot be used at all; resolution stays
+        // package-only and the warning explains why.
+        return {
+            warnings,
+            resolve: () => Promise.resolve(undefined),
+        };
+    const baseUrlField = chain.baseUrl;
+    const baseUrl = typeof baseUrlField?.value === "string"
+        ? resolve(baseUrlField.directory, baseUrlField.value)
+        : undefined;
+    const patterns = parsePaths(chain.paths, baseUrl);
+    if (!baseUrl && patterns.length === 0)
+        return undefined;
+    const extensionDirAbsolute = resolve(extensionDir);
+    return {
+        warnings,
+        async resolve(specifier) {
+            // `paths` wins over `baseUrl`, which wins over packages — as tsc does.
+            for (const { targets, capture } of matchPatterns(patterns, specifier)) {
+                for (const template of targets) {
+                    const candidate = template.replace("*", capture);
+                    if (!inside(extensionDirAbsolute, candidate))
+                        continue;
+                    const found = await probe(candidate);
+                    if (found)
+                        return found;
+                }
+            }
+            if (baseUrl !== undefined) {
+                const candidate = join(baseUrl, specifier);
+                if (inside(extensionDirAbsolute, candidate)) {
+                    const found = await probe(candidate);
+                    if (found)
+                        return found;
+                }
+            }
+            return undefined;
+        },
+    };
+}

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "@blastlauncher/engine",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@blastlauncher/protocol": "3.0.0-alpha.1",
+    "@blastlauncher/runtime": "3.0.0-alpha.1",
+    "esbuild": "0.28.2",
+    "semver": "7.8.5"
+  },
+  "version": "3.0.0-alpha.1",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BlastLauncher/blast.git",
+    "directory": "packages/host"
+  },
+  "homepage": "https://github.com/BlastLauncher/blast#readme",
+  "engines": {
+    "node": ">=24.20.0"
+  },
+  "files": [
+    "dist",
+    "schema",
+    "LICENSE",
+    "README.md"
+  ]
+}