pelican-engine 0.0.0-stage → 0.3.1

package/lib/assets/texture.js

@@ -0,0 +1,187 @@
+import path from "node:path";
+import { inflateSync } from "node:zlib";
+import { inspectJPEG } from "./jpeg.js";
+const signature = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+const crcTable = Array.from({ length: 256 }, (_, n) => {
+    for (let i = 0; i < 8; i++)
+        n = n & 1 ? 0xedb88320 ^ (n >>> 1) : n >>> 1;
+    return n >>> 0;
+});
+export function crc32(data) {
+    let n = 0xffffffff;
+    for (const b of data)
+        n = crcTable[(n ^ b) & 255] ^ (n >>> 8);
+    return (n ^ 0xffffffff) >>> 0;
+}
+// A bounded, fully checked decode of the lossless pixel stream. No browser or native service.
+function inspectPNG(data, ctx) {
+    let offset = 8, width = 0, height = 0, bitDepth = 0, colorType = 0, interlace = 0;
+    let paletteEntries = 0, ended = false, idatClosed = false;
+    const compressed = [];
+    const seen = new Set();
+    while (offset < data.length) {
+        ctx.check(offset + 12 <= data.length, "PNG/chunk", "Truncated chunk header.");
+        const size = data.readUInt32BE(offset);
+        const type = data.toString("latin1", offset + 4, offset + 8);
+        const end = offset + 12 + size;
+        ctx.check(end <= data.length &&
+            /^[A-Za-z]{4}$/.test(type) &&
+            type[2] === type[2].toUpperCase(), `PNG/${type}`, "Invalid chunk type or chunk length exceeds file.");
+        ctx.check(data.readUInt32BE(end - 4) === crc32(data.subarray(offset + 4, end - 4)), `PNG/${type}`, "Chunk CRC mismatch.");
+        const chunk = data.subarray(offset + 8, end - 4);
+        ctx.check(seen.has("IHDR") || type === "IHDR", "PNG/IHDR", "IHDR must be first.");
+        if (type === "IHDR") {
+            ctx.check(!seen.has(type) && size === 13, "PNG/IHDR", "Invalid or duplicate IHDR.");
+            width = ctx.integer(chunk.readUInt32BE(0), "PNG/width", 1, 0x7fffffff);
+            height = ctx.integer(chunk.readUInt32BE(4), "PNG/height", 1, 0x7fffffff);
+            bitDepth = chunk[8];
+            colorType = chunk[9];
+            const depths = {
+                0: [1, 2, 4, 8, 16],
+                2: [8, 16],
+                3: [1, 2, 4, 8],
+                4: [8, 16],
+                6: [8, 16],
+            };
+            ctx.check(depths[colorType]?.includes(bitDepth), "PNG/IHDR", "Invalid bit depth/color type.");
+            ctx.check(chunk[10] === 0 && chunk[11] === 0 && chunk[12] <= 1, "PNG/IHDR", "Invalid compression, filter or interlace method.");
+            interlace = chunk[12];
+        }
+        else if (type === "PLTE") {
+            ctx.check(!seen.has(type) &&
+                !compressed.length &&
+                size > 0 &&
+                size % 3 === 0 &&
+                size <= 768 &&
+                ![0, 4].includes(colorType), "PNG/PLTE", "Invalid, duplicate or misplaced palette.");
+            paletteEntries = size / 3;
+            ctx.check(colorType !== 3 || paletteEntries <= 2 ** bitDepth, "PNG/PLTE", "Palette exceeds bit depth.");
+        }
+        else if (type === "IDAT") {
+            ctx.check(!idatClosed && (colorType !== 3 || paletteEntries > 0), "PNG/IDAT", "Non-contiguous IDAT or missing palette.");
+            compressed.push(chunk);
+        }
+        else if (type === "IEND") {
+            ctx.check(size === 0 && compressed.length > 0 && end === data.length, "PNG/IEND", "Invalid end chunk, missing pixels or trailing bytes.");
+            ended = true;
+        }
+        else {
+            if (compressed.length)
+                idatClosed = true;
+            if (type === "tRNS") {
+                ctx.check(!seen.has(type) &&
+                    !compressed.length &&
+                    ((colorType === 0 && size === 2) ||
+                        (colorType === 2 && size === 6) ||
+                        (colorType === 3 && size > 0 && size <= paletteEntries)), "PNG/tRNS", "Invalid transparency chunk.");
+            }
+            else if (type === "acTL" || type === "fcTL" || type === "fdAT") {
+                ctx.unsupported(`PNG/${type}`, "Animated PNG is not implemented.");
+            }
+            else if (type[0] === type[0].toUpperCase()) {
+                ctx.unsupported(`PNG/${type}`, "Unknown critical PNG chunk.");
+            }
+        }
+        seen.add(type);
+        offset = end;
+    }
+    ctx.check(ended, "PNG/IEND", "Missing IEND chunk.");
+    const channels = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 }[colorType];
+    const patterns = interlace
+        ? [
+            [0, 0, 8, 8],
+            [4, 0, 8, 8],
+            [0, 4, 4, 8],
+            [2, 0, 4, 4],
+            [0, 2, 2, 4],
+            [1, 0, 2, 2],
+            [0, 1, 1, 2],
+        ]
+        : [[0, 0, 1, 1]];
+    const passes = patterns.map(([x, y, dx, dy]) => {
+        const passWidth = Math.max(0, Math.ceil((width - x) / dx));
+        const passHeight = Math.max(0, Math.ceil((height - y) / dy));
+        const rowBytes = Math.ceil((passWidth * channels * bitDepth) / 8);
+        return { width: passWidth, height: passHeight, rowBytes };
+    });
+    const decodedSize = passes.reduce((sum, pass) => sum + (pass.width && pass.height ? (pass.rowBytes + 1) * pass.height : 0), 0);
+    if (decodedSize > 256 * 1024 * 1024)
+        ctx.unsupported("PNG/pixels", "Decoded image exceeds the 256 MiB inspection limit.");
+    let pixels;
+    const encoded = Buffer.concat(compressed);
+    try {
+        const inflated = inflateSync(encoded, {
+            maxOutputLength: decodedSize + 1,
+            info: true,
+        });
+        ctx.check(inflated.engine.bytesWritten === encoded.length, "PNG/IDAT", "Trailing compressed stream data.");
+        pixels = inflated.buffer;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AssetInspectionError")
+            throw error;
+        ctx.invalid("PNG/IDAT", "Invalid or truncated zlib pixel stream.");
+    }
+    ctx.check(pixels.length === decodedSize, "PNG/IDAT", "Pixel stream length does not match dimensions.");
+    const bpp = Math.max(1, Math.ceil((channels * bitDepth) / 8));
+    let start = 0;
+    for (const [passIndex, pass] of passes.entries()) {
+        if (!pass.width || !pass.height)
+            continue;
+        const { rowBytes } = pass;
+        let previous = Buffer.alloc(rowBytes);
+        for (let y = 0; y < pass.height; y++) {
+            const resource = interlace
+                ? `PNG/pass/${passIndex + 1}/row/${y}`
+                : `PNG/row/${y}`;
+            const filter = pixels[start];
+            ctx.check(filter <= 4, resource, "Invalid PNG row filter.");
+            const row = pixels.subarray(start + 1, start + 1 + rowBytes);
+            for (let x = 0; x < rowBytes; x++) {
+                const a = x >= bpp ? row[x - bpp] : 0, b = previous[x], c = x >= bpp ? previous[x - bpp] : 0;
+                let predictor = 0;
+                if (filter === 1)
+                    predictor = a;
+                if (filter === 2)
+                    predictor = b;
+                if (filter === 3)
+                    predictor = Math.floor((a + b) / 2);
+                if (filter === 4) {
+                    const p = a + b - c, pa = Math.abs(p - a), pb = Math.abs(p - b), pc = Math.abs(p - c);
+                    predictor = pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+                }
+                row[x] = (row[x] + predictor) & 255;
+            }
+            if (colorType === 3)
+                for (let x = 0; x < pass.width; x++) {
+                    const index = (row[Math.floor((x * bitDepth) / 8)] >>>
+                        (8 - bitDepth - ((x * bitDepth) % 8))) &
+                        ((1 << bitDepth) - 1);
+                    ctx.check(index < paletteEntries, resource, "Pixel references a missing palette entry.");
+                }
+            previous = row;
+            start += rowBytes + 1;
+        }
+    }
+    return {
+        format: "png",
+        width,
+        height,
+        bitDepth,
+        colorType,
+        channels,
+        hasAlpha: [4, 6].includes(colorType) || seen.has("tRNS"),
+    };
+}
+export function inspectTexture(data, ctx) {
+    if (data.subarray(0, 8).equals(signature))
+        return inspectPNG(data, ctx);
+    if (data[0] === 0xff && data[1] === 0xd8)
+        return inspectJPEG(data, ctx);
+    // Recognizable damaged signatures must not produce metadata.
+    if (data.toString("latin1", 1, 4) === "PNG")
+        ctx.invalid("PNG/signature", "Invalid PNG signature.");
+    if ([".png", ".jpg", ".jpeg"].includes(path.extname(ctx.file).toLowerCase()))
+        ctx.invalid("texture/signature", "Missing or damaged PNG/JPEG signature.");
+    return ctx.unsupported("texture/format", "Expected PNG or baseline JPEG image bytes.");
+}

package/lib/compiler/distribution.js

@@ -0,0 +1,17 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export function compilerLayout(url, selectedRoot) {
+    const compiled = url.endsWith("/lib/compiler/index.js");
+    const root = selectedRoot
+        ? path.resolve(selectedRoot)
+        : fileURLToPath(new URL(compiled ? "../../" : "../../../", url));
+    const installed = existsSync(path.join(root, "distribution.json"));
+    const sdk = path.join(root, installed ? "lib/sdk/index.js" : "packages/sdk/src/index.ts");
+    return {
+        root,
+        installed,
+        sdk,
+        types: installed ? sdk.replace(/\.js$/, ".d.ts") : sdk,
+    };
+}

package/lib/compiler/extract.js

@@ -0,0 +1,425 @@
+import ts from "typescript";
+import path from "node:path";
+const declarations = {
+    defineComponent: "component",
+    defineMaterial: "material",
+    defineCompute: "compute",
+    definePostProcess: "postprocess",
+    defineAsset: "asset",
+    definePrefab: "prefab",
+    defineScene: "scene",
+    defineSystem: "system",
+    defineGame: "game",
+};
+export class ExtractionFailure extends Error {
+}
+export class Extractor {
+    program;
+    projectRoot;
+    sdkPath;
+    diagnostics = [];
+    definitions = [];
+    origins = new WeakMap();
+    propertyOrigins = new WeakMap();
+    modules = new Map();
+    memo = new Map();
+    active = new Set();
+    constructor(program, projectRoot, sdkPath) {
+        this.program = program;
+        this.projectRoot = projectRoot;
+        this.sdkPath = sdkPath;
+    }
+    location(node) {
+        const source = node.getSourceFile();
+        const start = node.getStart(source);
+        const pos = source.getLineAndCharacterOfPosition(start);
+        return {
+            file: path
+                .relative(this.projectRoot, source.fileName)
+                .replaceAll("\\", "/"),
+            line: pos.line + 1,
+            column: pos.character + 1,
+            length: Math.max(1, node.end - start),
+        };
+    }
+    source(value, key) {
+        const node = (key !== undefined
+            ? this.propertyOrigins.get(value)?.get(key)
+            : undefined) ?? this.origins.get(value);
+        return node ? this.location(node) : undefined;
+    }
+    fail(code, message, node, suggestion = "Use literal data and supported pelican-engine declaration calls.") {
+        this.diagnostics.push({
+            code,
+            severity: "error",
+            message,
+            suggestion,
+            source: this.location(node),
+        });
+        throw new ExtractionFailure(message);
+    }
+    key(file) {
+        return path.resolve(file).toLowerCase();
+    }
+    module(file) {
+        const key = this.key(file);
+        const cached = this.modules.get(key);
+        if (cached)
+            return cached;
+        const source = this.program.getSourceFile(file);
+        if (!source)
+            throw new Error("Compiler could not load source: " + file);
+        const mod = {
+            source,
+            bindings: new Map(),
+            imports: new Map(),
+            exports: new Map(),
+        };
+        this.modules.set(key, mod);
+        const inspectImports = (node) => {
+            const argument = ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument)
+                ? node.argument.literal
+                : ts.isCallExpression(node) &&
+                    node.expression.kind === ts.SyntaxKind.ImportKeyword
+                    ? node.arguments[0]
+                    : ts.isExportDeclaration(node)
+                        ? node.moduleSpecifier
+                        : undefined;
+            if (argument) {
+                if (!ts.isStringLiteral(argument))
+                    this.fail("TC_PUBLIC_API", "Module references must be static strings.", argument);
+                const specifier = argument.text;
+                if (specifier !== "pelican-engine") {
+                    if (!specifier.startsWith("."))
+                        this.fail("TC_PUBLIC_API", "Only the public SDK and project-local modules may be referenced.", argument);
+                    const resolved = ts.resolveModuleName(specifier, file, this.program.getCompilerOptions(), ts.sys).resolvedModule?.resolvedFileName;
+                    if (resolved) {
+                        const relative = path.relative(this.projectRoot, resolved);
+                        if (relative.startsWith("..") ||
+                            path.isAbsolute(relative) ||
+                            relative.split(path.sep).includes("node_modules"))
+                            this.fail("TC_PUBLIC_API", "Module reference leaves the game project.", argument);
+                    }
+                }
+            }
+            ts.forEachChild(node, inspectImports);
+        };
+        inspectImports(source);
+        const addExport = (name, node) => {
+            if (ts.canHaveModifiers(node) &&
+                ts
+                    .getModifiers(node)
+                    ?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword))
+                mod.exports.set(name, name);
+        };
+        for (const statement of source.statements) {
+            if (ts.isImportDeclaration(statement)) {
+                const specifier = statement.moduleSpecifier.text;
+                if (!statement.importClause)
+                    this.fail("TC_STATIC_SIDE_EFFECT", "Side-effect imports are not allowed in declaration modules.", statement, "Use named imports of declarations or gameplay functions.");
+                const clause = statement.importClause;
+                let resolved;
+                if (specifier !== "pelican-engine") {
+                    if (!specifier.startsWith("."))
+                        this.fail("TC_PUBLIC_API", "Game code may import pelican-engine and project-local modules only: " +
+                            specifier, statement, "Access engine capabilities through pelican-engine.");
+                    resolved = ts.resolveModuleName(specifier, file, this.program.getCompilerOptions(), ts.sys).resolvedModule?.resolvedFileName;
+                    if (!resolved)
+                        this.fail("TC_MODULE_MISSING", "Cannot resolve local module: " + specifier, statement, "Check the relative import path and file name.");
+                    const relative = path.relative(this.projectRoot, resolved);
+                    if (relative.startsWith("..") ||
+                        path.isAbsolute(relative) ||
+                        relative.split(path.sep).includes("node_modules"))
+                        this.fail("TC_PUBLIC_API", "Local imports must remain inside the game project.", statement, "Reference engine functionality through pelican-engine.");
+                }
+                // Type-only imports obey the same public API boundary as value imports.
+                if (clause.isTypeOnly)
+                    continue;
+                if (clause.name)
+                    mod.imports.set(clause.name.text, {
+                        file: resolved,
+                        name: "default",
+                    });
+                if (clause.namedBindings) {
+                    if (!ts.isNamedImports(clause.namedBindings))
+                        this.fail("TC_STATIC_SYNTAX", "Namespace imports are not supported by the M0 declaration extractor.", clause.namedBindings, "Use named imports.");
+                    for (const item of clause.namedBindings.elements)
+                        if (!item.isTypeOnly)
+                            mod.imports.set(item.name.text, {
+                                file: resolved,
+                                name: item.propertyName?.text ?? item.name.text,
+                            });
+                }
+            }
+            else if (ts.isVariableStatement(statement)) {
+                if (!(statement.declarationList.flags & ts.NodeFlags.Const))
+                    this.fail("TC_STATIC_SIDE_EFFECT", "Top-level declaration bindings must be const.", statement, "Keep mutable state in components or inside system functions.");
+                for (const decl of statement.declarationList.declarations) {
+                    if (!ts.isIdentifier(decl.name) || !decl.initializer)
+                        this.fail("TC_STATIC_SYNTAX", "Use initialized const identifiers for definitions.", decl);
+                    mod.bindings.set(decl.name.text, decl.initializer);
+                    addExport(decl.name.text, statement);
+                }
+            }
+            else if (ts.isFunctionDeclaration(statement)) {
+                if (statement.name) {
+                    mod.bindings.set(statement.name.text, statement);
+                    addExport(statement.name.text, statement);
+                }
+                if (statement.modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword))
+                    mod.exports.set("default", statement.name?.text ?? statement);
+            }
+            else if (ts.isExportAssignment(statement)) {
+                if (statement.isExportEquals)
+                    this.fail("TC_STATIC_SYNTAX", "CommonJS export assignments are not supported.", statement);
+                mod.exports.set("default", statement.expression);
+            }
+            else if (ts.isExportDeclaration(statement)) {
+                if (statement.isTypeOnly)
+                    continue;
+                if (statement.moduleSpecifier)
+                    this.fail("TC_STATIC_SYNTAX", "M0 does not statically extract re-exported declarations.", statement, "Import a local definition and export the imported identifier.");
+                if (statement.exportClause && ts.isNamedExports(statement.exportClause))
+                    for (const e of statement.exportClause.elements)
+                        mod.exports.set(e.name.text, e.propertyName?.text ?? e.name.text);
+            }
+            else if (ts.isInterfaceDeclaration(statement) ||
+                ts.isTypeAliasDeclaration(statement) ||
+                ts.isEmptyStatement(statement)) {
+                // Type declarations are erased; no executable source is evaluated.
+            }
+            else
+                this.fail("TC_STATIC_SIDE_EFFECT", "Unsupported executable top-level statement; no source module is executed during compilation.", statement, "Move gameplay behavior into a system run function.");
+        }
+        return mod;
+    }
+    binding(mod, name) {
+        const key = this.key(mod.source.fileName) + ":" + name;
+        if (this.memo.has(key))
+            return this.memo.get(key);
+        if (this.active.has(key))
+            this.fail("TC_DECLARATION_CYCLE", "Cyclic static declaration: " + name, mod.bindings.get(name) ?? mod.source, "Remove the circular const or prefab reference.");
+        this.active.add(key);
+        try {
+            const imported = mod.imports.get(name);
+            let value;
+            if (imported) {
+                if (!imported.file)
+                    this.fail("TC_STATIC_REFERENCE", "SDK functions are only permitted as supported declaration calls.", mod.source);
+                const target = this.module(imported.file);
+                const exported = target.exports.get(imported.name);
+                if (exported === undefined)
+                    this.fail("TC_STATIC_REFERENCE", "Local module does not export: " + imported.name, mod.source);
+                value =
+                    typeof exported === "string"
+                        ? this.binding(target, exported)
+                        : this.evaluate(exported, target);
+            }
+            else {
+                const expression = mod.bindings.get(name);
+                if (!expression)
+                    this.fail("TC_STATIC_REFERENCE", "Unknown static identifier: " + name, mod.source);
+                value = this.evaluate(expression, mod);
+            }
+            this.memo.set(key, value);
+            return value;
+        }
+        finally {
+            this.active.delete(key);
+        }
+    }
+    evaluate(node, mod) {
+        if (ts.isParenthesizedExpression(node) ||
+            ts.isAsExpression(node) ||
+            ts.isSatisfiesExpression(node) ||
+            ts.isTypeAssertionExpression(node))
+            return this.evaluate(node.expression, mod);
+        if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+            return node.text;
+        if (ts.isNumericLiteral(node))
+            return Number(node.text);
+        if (node.kind === ts.SyntaxKind.TrueKeyword)
+            return true;
+        if (node.kind === ts.SyntaxKind.FalseKeyword)
+            return false;
+        if (node.kind === ts.SyntaxKind.NullKeyword)
+            return null;
+        if (ts.isIdentifier(node))
+            return this.binding(mod, node.text);
+        if (ts.isArrowFunction(node) ||
+            ts.isFunctionExpression(node) ||
+            ts.isFunctionDeclaration(node) ||
+            ts.isMethodDeclaration(node)) {
+            const result = { __runtime: true };
+            this.origins.set(result, node);
+            return result;
+        }
+        if (ts.isArrayLiteralExpression(node)) {
+            const result = [];
+            const origins = new Map();
+            for (const element of node.elements) {
+                if (ts.isSpreadElement(element)) {
+                    const value = this.evaluate(element.expression, mod);
+                    if (!Array.isArray(value))
+                        this.fail("TC_STATIC_TYPE", "Array spread requires a static array.", element);
+                    for (const item of value) {
+                        origins.set(String(result.length), element);
+                        result.push(item);
+                    }
+                }
+                else {
+                    origins.set(String(result.length), element);
+                    result.push(this.evaluate(element, mod));
+                }
+            }
+            this.origins.set(result, node);
+            this.propertyOrigins.set(result, origins);
+            return result;
+        }
+        if (ts.isObjectLiteralExpression(node)) {
+            const result = Object.create(null);
+            const origins = new Map();
+            for (const prop of node.properties) {
+                if (ts.isSpreadAssignment(prop)) {
+                    const value = this.evaluate(prop.expression, mod);
+                    if (!value || Array.isArray(value) || typeof value !== "object")
+                        this.fail("TC_STATIC_TYPE", "Object spread requires static object data.", prop);
+                    Object.assign(result, value);
+                    for (const k of Object.keys(value))
+                        origins.set(k, this.propertyOrigins.get(value)?.get(k) ?? prop);
+                    continue;
+                }
+                if (!prop.name || ts.isComputedPropertyName(prop.name))
+                    this.fail("TC_STATIC_SYNTAX", "Computed property names and accessors are not supported.", prop);
+                const name = prop.name.getText().replace(/^['"]|['"]$/g, "");
+                if (name === "__proto__" ||
+                    name === "constructor" ||
+                    name === "prototype")
+                    this.fail("TC_STATIC_SYNTAX", "Reserved declaration property: " + name, prop);
+                if (ts.isPropertyAssignment(prop)) {
+                    result[name] = this.evaluate(prop.initializer, mod);
+                    origins.set(name, prop.initializer);
+                }
+                else if (ts.isShorthandPropertyAssignment(prop)) {
+                    result[name] = this.binding(mod, prop.name.text);
+                    origins.set(name, prop);
+                }
+                else if (ts.isMethodDeclaration(prop) && name === "run") {
+                    result[name] = this.evaluate(prop, mod);
+                    origins.set(name, prop);
+                }
+                else
+                    this.fail("TC_STATIC_SYNTAX", "Only data properties and system run functions are supported.", prop);
+            }
+            this.origins.set(result, node);
+            this.propertyOrigins.set(result, origins);
+            return result;
+        }
+        if (ts.isCallExpression(node)) {
+            const name = ts.isIdentifier(node.expression)
+                ? mod.imports.get(node.expression.text)
+                : undefined;
+            const kind = name && !name.file ? declarations[name.name] : undefined;
+            if (!kind || node.arguments.length !== 1)
+                this.fail("TC_STATIC_SIDE_EFFECT", "Arbitrary function calls are not evaluated in definitions.", node, "Use a supported define* call from pelican-engine; put executable behavior inside systems.");
+            const input = this.evaluate(node.arguments[0], mod);
+            if (!input || Array.isArray(input) || typeof input !== "object")
+                this.fail("TC_STATIC_TYPE", "A declaration requires an object.", node);
+            if (kind === "system" && input.run && typeof input.run === "object") {
+                const run = this.origins.get(input.run);
+                if (!run ||
+                    !(ts.isArrowFunction(run) ||
+                        ts.isFunctionExpression(run) ||
+                        ts.isFunctionDeclaration(run) ||
+                        ts.isMethodDeclaration(run)))
+                    this.fail("TC_SYSTEM_RUN", "System run must be an actual function declaration.", run ?? node);
+                if (run &&
+                    ts.canHaveModifiers(run) &&
+                    ts
+                        .getModifiers(run)
+                        ?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword))
+                    this.fail("TC_SYSTEM_ASYNC", "Game systems must be synchronous in every phase.", run, "Move asynchronous preparation outside the update loop; apply ready data synchronously.");
+                if (run && "asteriskToken" in run && run.asteriskToken)
+                    this.fail("TC_SYSTEM_GENERATOR", "M0 update systems cannot be generator functions.", run);
+                const checker = this.program.getTypeChecker();
+                const signature = checker.getSignatureFromDeclaration(run);
+                if (signature) {
+                    const result = checker.getReturnTypeOfSignature(signature);
+                    const results = result.isUnion() ? result.types : [result];
+                    if (results.some((type) => type.getProperty("then")))
+                        this.fail("TC_SYSTEM_ASYNC", "System run cannot return a Promise/thenable.", run, "Prepare asynchronous data outside systems and apply it synchronously at a safe boundary.");
+                }
+            }
+            const result = { ...input, kind };
+            this.origins.set(result, node);
+            this.propertyOrigins.set(result, this.propertyOrigins.get(input) ?? new Map());
+            this.definitions.push(result);
+            return result;
+        }
+        if (ts.isPrefixUnaryExpression(node)) {
+            const value = this.evaluate(node.operand, mod);
+            if (typeof value === "number" &&
+                [ts.SyntaxKind.PlusToken, ts.SyntaxKind.MinusToken].includes(node.operator))
+                return node.operator === ts.SyntaxKind.MinusToken ? -value : value;
+        }
+        if (ts.isBinaryExpression(node)) {
+            const a = this.evaluate(node.left, mod);
+            const b = this.evaluate(node.right, mod);
+            let value;
+            if (typeof a === "number" && typeof b === "number") {
+                switch (node.operatorToken.kind) {
+                    case ts.SyntaxKind.PlusToken:
+                        value = a + b;
+                        break;
+                    case ts.SyntaxKind.MinusToken:
+                        value = a - b;
+                        break;
+                    case ts.SyntaxKind.AsteriskToken:
+                        value = a * b;
+                        break;
+                    case ts.SyntaxKind.SlashToken:
+                        value = a / b;
+                        break;
+                }
+            }
+            if (value !== undefined && Number.isFinite(value))
+                return value;
+            this.fail("TC_STATIC_TYPE", "Static arithmetic must produce a finite number.", node);
+        }
+        this.fail("TC_STATIC_SYNTAX", "Unsupported static expression: " + ts.SyntaxKind[node.kind], node);
+    }
+    extract(entry) {
+        try {
+            const mod = this.module(entry);
+            // Every project source is inspected, including imports unused by the bundler.
+            for (const sf of this.program.getSourceFiles()) {
+                if (sf.isDeclarationFile ||
+                    path.resolve(sf.fileName) === path.resolve(this.sdkPath))
+                    continue;
+                const rel = path.relative(this.projectRoot, sf.fileName);
+                if (!rel.startsWith("..") && !path.isAbsolute(rel))
+                    this.module(sf.fileName);
+            }
+            for (const item of this.modules.values())
+                for (const name of item.bindings.keys())
+                    this.binding(item, name);
+            const exported = mod.exports.get("default");
+            if (!exported)
+                this.fail("TC_GAME_ENTRY", "Entry must default-export defineGame(...).", mod.source);
+            const result = typeof exported === "string"
+                ? this.binding(mod, exported)
+                : this.evaluate(exported, mod);
+            if (!result ||
+                Array.isArray(result) ||
+                typeof result !== "object" ||
+                result.kind !== "game")
+                this.fail("TC_GAME_ENTRY", "Default export must be a defineGame declaration.", mod.source);
+            return result;
+        }
+        catch (error) {
+            if (!(error instanceof ExtractionFailure))
+                throw error;
+            return undefined;
+        }
+    }
+}