@silkweaver/build 1.1.0 → 1.2.0

package/dist/build.d.ts

@@ -15,6 +15,16 @@ import type { project_file as project_data } from '@silkweaver/project';
 export type { project_data };
 /** Reads and parses a project's project.json. */
 export declare function read_project(project_folder: string): Promise<project_data>;
+/** Public: the engine version this toolchain ships — what "Update engine" would pin a project to. */
+export declare function toolchain_engine_version(): string;
+/**
+ * Vendors the toolchain's current engine into a project as one self-contained bundle
+ * (`.engine/engine.mjs`, matter-js inlined) and records its version (`.engine/version.json` +
+ * project.json `engineVersion`). Called at project creation; safe to re-run to upgrade the pin.
+ * @param project_folder - Absolute path to the project folder
+ * @returns The vendored engine version.
+ */
+export declare function vendor_engine(project_folder: string): Promise<string>;
 /**
  * Builds the game to a single bundled game.js at out_path, for the in-IDE preview.
  * @param out_path - Where to write game.js (the caller decides — e.g. exports/game.js)

package/dist/build.js

@@ -47,6 +47,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.read_project = read_project;
+exports.toolchain_engine_version = toolchain_engine_version;
+exports.vendor_engine = vendor_engine;
 exports.build_preview = build_preview;
 exports.export_html5 = export_html5;
 exports.export_executable = export_executable;
@@ -65,18 +67,73 @@ async function read_project(project_folder) {
  * entry can import the whole API (keeping it in sync with the IDE's autocomplete).
  * esbuild tree-shakes whatever the game doesn't actually use.
  */
-let _engine_names = null;
+const _engine_names = new Map(); // engine path → its export names (per vendored engine)
 async function engine_export_names(engine_path) {
-    if (_engine_names)
-        return _engine_names;
+    const cached = _engine_names.get(engine_path);
+    if (cached)
+        return cached;
     const mod = await import((0, node_url_1.pathToFileURL)(engine_path).href);
-    _engine_names = Object.keys(mod).filter(n => n !== 'default' && /^[A-Za-z_$][\w$]*$/.test(n));
-    return _engine_names;
+    const names = Object.keys(mod).filter(n => n !== 'default' && /^[A-Za-z_$][\w$]*$/.test(n));
+    _engine_names.set(engine_path, names);
+    return names;
 }
-/** Absolute path to the engine package entry — the esbuild alias target + export-name source. */
+/** Absolute path to the toolchain's own engine entry (the vendoring source + pre-vendoring fallback). */
 function engine_entry() {
     return require.resolve('@silkweaver/engine');
 }
+/** The version of the toolchain's own engine (what a freshly-vendored project pins). */
+function engine_version() {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(path.dirname(engine_entry()), '..', 'package.json'), 'utf8')).version;
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/** Public: the engine version this toolchain ships — what "Update engine" would pin a project to. */
+function toolchain_engine_version() {
+    return engine_version();
+}
+/**
+ * Resolves the engine a project builds against: its vendored copy (`.engine/engine.mjs`) when
+ * present, else the toolchain's own engine (projects created before per-project vendoring). This is
+ * what lets a project keep building against the exact engine it was made with — IDE updates don't
+ * touch it.
+ */
+function resolve_engine(project_folder) {
+    const vendored = path.join(project_folder, '.engine', 'engine.mjs');
+    return fs.existsSync(vendored) ? vendored : engine_entry();
+}
+/**
+ * Vendors the toolchain's current engine into a project as one self-contained bundle
+ * (`.engine/engine.mjs`, matter-js inlined) and records its version (`.engine/version.json` +
+ * project.json `engineVersion`). Called at project creation; safe to re-run to upgrade the pin.
+ * @param project_folder - Absolute path to the project folder
+ * @returns The vendored engine version.
+ */
+async function vendor_engine(project_folder) {
+    const version = engine_version();
+    const dir = path.join(project_folder, '.engine');
+    await fs.promises.mkdir(dir, { recursive: true });
+    const esbuild_api = require('esbuild');
+    await esbuild_api.build({
+        entryPoints: [engine_entry()],
+        bundle: true,
+        format: 'esm',
+        outfile: path.join(dir, 'engine.mjs'),
+        keepNames: true, // the engine reads constructor.name at runtime
+    });
+    await fs.promises.writeFile(path.join(dir, 'version.json'), JSON.stringify({ version, vendoredAt: new Date().toISOString() }, null, 2) + '\n', 'utf8');
+    // Pin the version in project.json so the IDE can display it / gate features on it.
+    try {
+        const proj_path = path.join(project_folder, 'project.json');
+        const proj = JSON.parse(await fs.promises.readFile(proj_path, 'utf8'));
+        proj.engineVersion = version;
+        await fs.promises.writeFile(proj_path, JSON.stringify(proj, null, 2) + '\n', 'utf8');
+    }
+    catch { /* no project.json yet — caller sets engineVersion */ }
+    return version;
+}
 /**
  * Strips leading `import …` lines from a code snippet so it can be inlined inside a
  * function body (timeline moments). Engine references auto-resolve via the inject shim,
@@ -101,7 +158,7 @@ function hex_to_bgr(hex) {
  * Generates the bootstrapper (_entry.ts) source for a project.
  * @param asset_mode - 'preview' (file:// into project) or 'export' (relative assets/)
  */
-async function generate_entry_code(project_folder, proj, asset_mode) {
+async function generate_entry_code(project_folder, proj, asset_mode, engine_path) {
     // Parent-before-child so generated imports/registrations init objects in dependency order.
     const object_names = await _objects_parent_first(project_folder, Object.keys(proj.resources.objects ?? {}));
     const room_names = Object.keys(proj.resources.rooms ?? {});
@@ -110,8 +167,7 @@ async function generate_entry_code(project_folder, proj, asset_mode) {
     const font_names = Object.keys(proj.resources.fonts ?? {});
     const path_names = Object.keys(proj.resources.paths ?? {});
     const timeline_names = Object.keys(proj.resources.timelines ?? {});
-    // The engine is resolved from the @silkweaver/engine package (no path coupling).
-    const engine_path = engine_entry();
+    // engine_path is whatever the project resolves to — its vendored copy, or the toolchain's.
     // Each object is a single class file: objects/<name>.ts (a gm_object subclass).
     // It is imported as-is; metadata/variables/events all live in the class.
     const object_imports = [];
@@ -492,7 +548,8 @@ ${room_physics[start_room] ? `    physics_world_create(${room_physics[start_room
  * ESM game.js at out_path via esbuild, then removes the temporary file.
  */
 async function bundle_game(project_folder, proj, asset_mode, out_path, minify) {
-    const entry_code = await generate_entry_code(project_folder, proj, asset_mode);
+    const engine_path = resolve_engine(project_folder);
+    const entry_code = await generate_entry_code(project_folder, proj, asset_mode, engine_path);
     const entry_path = path.join(project_folder, '_entry.ts');
     const globals_path = path.join(project_folder, '_engine_globals.ts');
     await fs.promises.writeFile(entry_path, entry_code, 'utf8');
@@ -500,7 +557,7 @@ async function bundle_game(project_folder, proj, asset_mode, out_path, minify) {
     // `inject`, it makes any *bare* engine reference in an object/script file (e.g. `gm_object`,
     // `draw_sprite`) resolve to an auto-injected import — tree-shaken — so users never write or
     // manage `import … from '@silkweaver/engine'` themselves.
-    const engine_names = await engine_export_names(engine_entry());
+    const engine_names = await engine_export_names(engine_path);
     // Also re-export the project's OBJECT classes by name, so they can be referenced bare —
     // GMS-style, e.g. `place_meeting(x, y, obj_wall)` or `static parent = par_solid` — with no
     // import (matching what the IDE editor already declares). The defining file won't self-import;
@@ -533,7 +590,7 @@ async function bundle_game(project_folder, proj, asset_mode, out_path, minify) {
             // `this.constructor.name` (resource.name, room type checks, object_get_name),
             // so identifier mangling would otherwise break exported (minified) games.
             keepNames: true,
-            alias: { '@silkweaver/engine': engine_entry() },
+            alias: { '@silkweaver/engine': engine_path },
             inject: [globals_path],
         });
     }

package/dist/templates.js

@@ -45,6 +45,7 @@ exports.list_templates = list_templates;
 exports.create_from_template = create_from_template;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const build_js_1 = require("./build.js");
 /** Ordered registry of the bundled starter templates (folders live under ../templates/<id>). */
 const TEMPLATE_REGISTRY = [
     { id: 'empty', label: 'Empty', description: 'A blank project with a single empty room.' },
@@ -56,7 +57,7 @@ function templates_dir() {
     return path.join(__dirname, '..', 'templates');
 }
 /** Names never copied into a new project (build artifacts / VCS / deps), as a defensive guard. */
-const COPY_DENYLIST = new Set(['_entry.ts', '_engine_globals.ts', 'node_modules', '.git', 'exports', 'game.js']);
+const COPY_DENYLIST = new Set(['_entry.ts', '_engine_globals.ts', 'node_modules', '.git', 'exports', 'game.js', '.engine']);
 /** Returns the available starter templates — only those whose folder is actually installed. */
 function list_templates() {
     const out = [];
@@ -103,4 +104,11 @@ async function create_from_template(template_id, dest_folder, name) {
         }
         catch { /* keep the template's bundled name */ }
     }
+    // Vendor the current engine into the new project so it's pinned to this version (a later IDE
+    // update won't change it). Best-effort: if it fails, the project still builds against the
+    // toolchain engine via the resolve_engine fallback.
+    try {
+        await (0, build_js_1.vendor_engine)(dest_folder);
+    }
+    catch { /* falls back to the toolchain engine */ }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@silkweaver/build",
-    "version": "1.1.0",
+    "version": "1.2.0",
     "description": "Silkweaver toolchain — compiles a project folder into a runnable game (HTML5 / desktop executable). Usable from a CLI or the IDE.",
     "type": "commonjs",
     "license": "GPL-3.0",