@silkweaver/build 1.0.0 → 1.1.0

package/dist/build.js

@@ -54,6 +54,7 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const os = __importStar(require("node:os"));
 const node_url_1 = require("node:url");
+const object_format_js_1 = require("./object_format.js");
 /** Reads and parses a project's project.json. */
 async function read_project(project_folder) {
     const proj_text = await fs.promises.readFile(path.join(project_folder, 'project.json'), 'utf8');
@@ -101,7 +102,8 @@ function hex_to_bgr(hex) {
  * @param asset_mode - 'preview' (file:// into project) or 'export' (relative assets/)
  */
 async function generate_entry_code(project_folder, proj, asset_mode) {
-    const object_names = Object.keys(proj.resources.objects ?? {});
+    // 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 ?? {});
     const sprite_names = Object.keys(proj.resources.sprites ?? {});
     const script_names = Object.keys(proj.resources.scripts ?? {});
@@ -113,10 +115,12 @@ async function generate_entry_code(project_folder, proj, asset_mode) {
     // 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 = [];
+    const object_registrations = []; // object_register_name('x', x) → resolves object_get('x')
     for (const obj_name of object_names) {
         const class_file = path.join(project_folder, 'objects', `${obj_name}.ts`);
         if (await _path_exists(class_file)) {
             object_imports.push(`import { ${obj_name} } from '${class_file.replace(/\\/g, '/')}'`);
+            object_registrations.push(`object_register_name('${obj_name}', ${obj_name})`);
         }
         else {
             console.warn(`[build] object '${obj_name}' has no objects/${obj_name}.ts — skipped`);
@@ -323,6 +327,9 @@ ${engine_import}
 
 ${object_imports.join('\n')}
 
+// Register objects by name so object_get('name') resolves them at runtime.
+${object_registrations.join('\n')}
+
 ${script_imports}
 
 // ── Sprite loader ───────────────────────────────────────────────────────────
@@ -494,7 +501,23 @@ async function bundle_game(project_folder, proj, asset_mode, out_path, minify) {
     // `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());
-    await fs.promises.writeFile(globals_path, `export { ${engine_names.join(', ')} } from '@silkweaver/engine'\n`, 'utf8');
+    // 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;
+    // skip any object whose name would collide with an engine export.
+    // Parent-before-child order: the re-export order here becomes the module init order, so an
+    // object's `static parent = par` resolves to a defined class instead of undefined.
+    const object_order = await _objects_parent_first(project_folder, Object.keys(proj.resources.objects ?? {}));
+    const object_lines = [];
+    for (const obj_name of object_order) {
+        if (engine_names.includes(obj_name))
+            continue;
+        const class_file = path.join(project_folder, 'objects', `${obj_name}.ts`);
+        if (await _path_exists(class_file)) {
+            object_lines.push(`export { ${obj_name} } from '${class_file.replace(/\\/g, '/')}'`);
+        }
+    }
+    await fs.promises.writeFile(globals_path, `export { ${engine_names.join(', ')} } from '@silkweaver/engine'\n${object_lines.join('\n')}\n`, 'utf8');
     try {
         // Run esbuild via its Node API. Alias the package specifier to the resolved engine
         // entry so the generated entry AND any class-per-object files resolve to the same
@@ -506,6 +529,10 @@ async function bundle_game(project_folder, proj, asset_mode, out_path, minify) {
             outfile: out_path,
             format: 'esm',
             minify,
+            // Preserve class/function `.name` even when minifying — the engine reads
+            // `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() },
             inject: [globals_path],
         });
@@ -686,6 +713,48 @@ async function _path_exists(p) {
         return false;
     }
 }
+/**
+ * Orders object names so every object's `static parent` (when it's another project object)
+ * appears BEFORE it. esbuild lazy-initializes the object modules (the inject shim and each
+ * object form an import cycle), running them in declaration order inside one initializer; a
+ * child whose `static parent = par` is evaluated before `par`'s module would capture
+ * `undefined`. Initializing parents first makes the reference resolve to the real class.
+ * A parent cycle (user error) is broken gracefully so this never loops.
+ */
+async function _objects_parent_first(project_folder, names) {
+    const present = new Set(names);
+    const parent_of = new Map();
+    for (const name of names) {
+        const file = path.join(project_folder, 'objects', `${name}.ts`);
+        let parent;
+        if (await _path_exists(file)) {
+            try {
+                const p = (0, object_format_js_1.parse_object)(await fs.promises.readFile(file, 'utf8')).parent;
+                if (p && p !== name && present.has(p))
+                    parent = p;
+            }
+            catch { /* unparseable — treat as no parent */ }
+        }
+        parent_of.set(name, parent);
+    }
+    const out = [];
+    const done = new Set();
+    const onstack = new Set();
+    const visit = (n) => {
+        if (done.has(n) || onstack.has(n))
+            return; // onstack guard breaks any parent cycle
+        onstack.add(n);
+        const p = parent_of.get(n);
+        if (p)
+            visit(p);
+        onstack.delete(n);
+        done.add(n);
+        out.push(n);
+    };
+    for (const n of names)
+        visit(n);
+    return out;
+}
 /** Recursively copies a directory tree from src to dst. */
 async function _copy_dir(src, dst) {
     await fs.promises.mkdir(dst, { recursive: true });

package/dist/index.d.ts

@@ -7,7 +7,9 @@
  *   - export_executable  → a packaged desktop application
  *
  * Also re-exports the class-file object read/write layer (object_format) used by the
- * IDE's object editor. Pure Node — drives both the IDE (over IPC) and the CLI.
+ * IDE's object editor, and the starter-template materializer (templates). Pure Node —
+ * drives both the IDE (over IPC) and the CLI.
  */
 export * from './build.js';
 export * from './object_format.js';
+export * from './templates.js';

package/dist/index.js

@@ -8,7 +8,8 @@
  *   - export_executable  → a packaged desktop application
  *
  * Also re-exports the class-file object read/write layer (object_format) used by the
- * IDE's object editor. Pure Node — drives both the IDE (over IPC) and the CLI.
+ * IDE's object editor, and the starter-template materializer (templates). Pure Node —
+ * drives both the IDE (over IPC) and the CLI.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -27,3 +28,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./build.js"), exports);
 __exportStar(require("./object_format.js"), exports);
+__exportStar(require("./templates.js"), exports);

package/dist/object_format.d.ts

@@ -11,6 +11,8 @@
  */
 /** Known static-metadata field names an object class may declare. */
 export type meta_field = 'sprite' | 'solid' | 'visible' | 'persistent' | 'depth' | 'parent';
+/** Canonical GMS-style order of `on_*` event methods (used to keep events ordered in code). */
+export declare const EVENT_ORDER: string[];
 export interface object_model {
     class_name: string;
     sprite: string | null;
@@ -27,6 +29,14 @@ export interface object_model {
 }
 /** Extracts the object model from a class-file source. */
 export declare function parse_object(src: string): object_model;
+/**
+ * Collects every instance member reachable through `this.` in a class: declared instance fields
+ * *plus* members created/assigned at runtime inside any event (e.g. `this.velocity = 0` in on_create,
+ * read in on_step). This drives `this.` autocomplete, so a variable made in one event surfaces in all
+ * the others — matching the usual split of constants on the object, runtime state in Create. Static
+ * fields and method/event names are excluded (engine members are merged in separately).
+ */
+export declare function this_members(src: string): string[];
 /**
  * Sets (adds or updates) a static metadata field. `expr` is the raw initializer
  * text (e.g. `'spr_player'`, `true`, `-5`, `obj_base`).
@@ -38,9 +48,29 @@ export declare function remove_static(src: string, name: meta_field): string;
 export declare function set_field(src: string, name: string, expr: string): string;
 /** Removes an instance variable field. */
 export declare function remove_field(src: string, name: string): string;
-/** Adds an `on_*` event method stub if it is not already present. */
+/**
+ * Adds an `on_*` event method stub if it is not already present, inserted in canonical event
+ * order (before the first existing event method that comes later in EVENT_ORDER).
+ */
 export declare function add_method(src: string, method: string, params?: string, body?: string): string;
 /** Removes an event method by name. */
 export declare function remove_method(src: string, method: string): string;
+/**
+ * Returns one event method's body as an editable, de-indented buffer, or null if absent/bodyless.
+ * @param method - The on_* method to extract (e.g. 'on_step')
+ */
+export declare function get_event_body(src: string, method: string): string | null;
+/**
+ * Replaces an event method's body with `body` (an edited, de-indented buffer), re-indenting it to
+ * the method's level. Returns the full updated source; a no-op if the method is absent.
+ * @param method - The on_* method to update
+ * @param body   - The new body (column-0 / de-indented, as edited)
+ */
+export declare function set_event_body(src: string, method: string, body: string): string;
+/**
+ * Normalizes a class-per-object file for display in the full code view: variables hoisted above all
+ * events, canonical event order, then consistent indentation. Unchanged if there's no class.
+ */
+export declare function normalize_object(src: string): string;
 /** Generates a minimal class-file source for a new object. Imports are auto-managed (none needed). */
 export declare function scaffold_object(class_name: string): string;

package/dist/object_format.js

@@ -44,15 +44,33 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVENT_ORDER = void 0;
 exports.parse_object = parse_object;
+exports.this_members = this_members;
 exports.set_static = set_static;
 exports.remove_static = remove_static;
 exports.set_field = set_field;
 exports.remove_field = remove_field;
 exports.add_method = add_method;
 exports.remove_method = remove_method;
+exports.get_event_body = get_event_body;
+exports.set_event_body = set_event_body;
+exports.normalize_object = normalize_object;
 exports.scaffold_object = scaffold_object;
 const ts = __importStar(require("typescript"));
+/** Canonical GMS-style order of `on_*` event methods (used to keep events ordered in code). */
+exports.EVENT_ORDER = [
+    'on_create', 'on_destroy',
+    'on_step_begin', 'on_step', 'on_step_end',
+    'on_draw_begin', 'on_draw', 'on_draw_end', 'on_draw_gui',
+    'on_alarm',
+    'on_key_press', 'on_key_release', 'on_key_held',
+    'on_mouse_left_press', 'on_mouse_left_release', 'on_mouse_right_press',
+    'on_collision',
+    'on_room_start', 'on_room_end', 'on_game_start', 'on_game_end',
+    'on_animation_end', 'on_path_end', 'on_outside_room', 'on_intersect_boundary',
+    'on_no_more_lives', 'on_no_more_health', 'on_user',
+];
 // =========================================================================
 // Parsing
 // =========================================================================
@@ -126,6 +144,42 @@ function _string_literal(node) {
         return node.text;
     return null;
 }
+/**
+ * Collects every instance member reachable through `this.` in a class: declared instance fields
+ * *plus* members created/assigned at runtime inside any event (e.g. `this.velocity = 0` in on_create,
+ * read in on_step). This drives `this.` autocomplete, so a variable made in one event surfaces in all
+ * the others — matching the usual split of constants on the object, runtime state in Create. Static
+ * fields and method/event names are excluded (engine members are merged in separately).
+ */
+function this_members(src) {
+    const sf = _source(src);
+    const cls = _find_class(sf);
+    if (!cls)
+        return [];
+    const names = new Set();
+    for (const m of cls.members) {
+        if (ts.isPropertyDeclaration(m) && !_is_static(m)) {
+            const n = _name_of(m);
+            if (n)
+                names.add(n);
+        }
+    }
+    // Any `this.<name> = …` (or compound assignment) anywhere in the class body — including nested
+    // blocks/closures — counts as an instance member the user can reference elsewhere.
+    const visit = (node) => {
+        if (ts.isBinaryExpression(node)
+            && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment
+            && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment
+            && ts.isPropertyAccessExpression(node.left)
+            && node.left.expression.kind === ts.SyntaxKind.ThisKeyword
+            && ts.isIdentifier(node.left.name)) {
+            names.add(node.left.name.text);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(cls);
+    return [...names];
+}
 function _apply(src, e) {
     return src.slice(0, e.start) + e.text + src.slice(e.end);
 }
@@ -139,6 +193,20 @@ function _insert_member(src, text) {
     const prefix = pos > 0 && src[pos - 1] !== '\n' ? '\n' : ''; // guard against mashing onto the prior line
     return _apply(src, { start: pos, end: pos, text: prefix + text });
 }
+/** Inserts `text` (a full member incl. trailing newline) on its own line before the member at `pos`. */
+function _insert_before(src, pos, text) {
+    const line_start = src.lastIndexOf('\n', pos - 1) + 1;
+    return src.slice(0, line_start) + text + src.slice(line_start);
+}
+/** Inserts `text` (a full member incl. trailing newline) on its own line after the member ending at `end`. */
+function _insert_after(src, end, text) {
+    let i = end;
+    while (i < src.length && src[i] !== '\n')
+        i++; // to the end of the member's own line
+    if (i < src.length && src[i] === '\n')
+        i++; // past the line terminator
+    return src.slice(0, i) + text + src.slice(i);
+}
 function _find_member(cls, pred) {
     return cls.members.find(pred);
 }
@@ -178,13 +246,25 @@ function set_field(src, name, expr) {
     if (existing) {
         return _apply(src, { start: existing.getStart(sf), end: existing.getEnd(), text: `${name} = ${expr}` });
     }
-    return _insert_member(src, `    ${name} = ${expr}\n`);
+    // New variable: keep all instance variables grouped at the TOP of the class, in add-order, so
+    // every event below can reference them — and a later variable's initializer can safely read an
+    // earlier one. Insert after the last existing variable; if none, before the first member.
+    const stub = `    ${name} = ${expr}\n`;
+    const vars = cls.members.filter(m => ts.isPropertyDeclaration(m) && !_is_static(m));
+    if (vars.length)
+        return _insert_after(src, vars[vars.length - 1].getEnd(), stub);
+    if (cls.members.length)
+        return _insert_before(src, cls.members[0].getStart(sf), stub);
+    return _insert_member(src, stub);
 }
 /** Removes an instance variable field. */
 function remove_field(src, name) {
     return _remove_member(src, m => ts.isPropertyDeclaration(m) && !_is_static(m) && _name_of(m) === name);
 }
-/** Adds an `on_*` event method stub if it is not already present. */
+/**
+ * Adds an `on_*` event method stub if it is not already present, inserted in canonical event
+ * order (before the first existing event method that comes later in EVENT_ORDER).
+ */
 function add_method(src, method, params = '', body = '') {
     const sf = _source(src);
     const cls = _find_class(sf);
@@ -193,6 +273,17 @@ function add_method(src, method, params = '', body = '') {
     if (_find_member(cls, m => ts.isMethodDeclaration(m) && _name_of(m) === method))
         return src;
     const stub = `    ${method}(${params}): void {\n${body ? '        ' + body + '\n' : ''}    }\n`;
+    const order = exports.EVENT_ORDER.indexOf(method);
+    if (order >= 0) {
+        const after = cls.members.find(m => {
+            if (!ts.isMethodDeclaration(m))
+                return false;
+            const n = _name_of(m);
+            return !!n && exports.EVENT_ORDER.indexOf(n) > order;
+        });
+        if (after)
+            return _insert_before(src, after.getStart(sf), stub);
+    }
     return _insert_member(src, stub);
 }
 /** Removes an event method by name. */
@@ -222,6 +313,196 @@ function _remove_member(src, pred) {
     return _apply(src, { start, end, text: '' });
 }
 // =========================================================================
+// Event body extract / pack — per-event "virtual file" editing
+// =========================================================================
+//
+// An event is edited as its OWN buffer: get_event_body returns just the method's body,
+// de-indented to column 0, so the editor is a normal standalone file (Ctrl+A, auto-indent,
+// autocomplete — no hidden areas, no live brace-matching). set_event_body packs that buffer
+// back into the method, re-indented. Both are AST-based, so they're robust to braces/strings.
+/** Strips common leading indentation + surrounding blank lines (method body → editable buffer). */
+function _dedent(text) {
+    const lines = text.replace(/\r\n?/g, '\n').split('\n');
+    while (lines.length && lines[0].trim() === '')
+        lines.shift();
+    while (lines.length && lines[lines.length - 1].trim() === '')
+        lines.pop();
+    if (lines.length === 0)
+        return '';
+    let min = Infinity;
+    for (const l of lines) {
+        if (l.trim() === '')
+            continue;
+        const w = /^[ \t]*/.exec(l)[0].length;
+        if (w < min)
+            min = w;
+    }
+    if (!isFinite(min))
+        min = 0;
+    return lines.map(l => (l.trim() === '' ? '' : l.slice(min))).join('\n');
+}
+/** Re-applies an indent prefix to each non-blank line (editable buffer → method body). */
+function _indent(text, indent) {
+    return text.replace(/\r\n?/g, '\n').split('\n').map(l => (l.trim() === '' ? '' : indent + l)).join('\n');
+}
+/** Returns the leading whitespace of the line containing `pos`. */
+function _line_indent(src, pos) {
+    const line_start = src.lastIndexOf('\n', pos - 1) + 1;
+    return /^[ \t]*/.exec(src.slice(line_start, pos))?.[0] ?? '';
+}
+function _find_event_method(cls, method) {
+    return cls.members.find(m => ts.isMethodDeclaration(m) && _name_of(m) === method);
+}
+/**
+ * Returns one event method's body as an editable, de-indented buffer, or null if absent/bodyless.
+ * @param method - The on_* method to extract (e.g. 'on_step')
+ */
+function get_event_body(src, method) {
+    const sf = _source(src);
+    const cls = _find_class(sf);
+    if (!cls)
+        return null;
+    const m = _find_event_method(cls, method);
+    if (!m || !m.body)
+        return null;
+    const inner = src.slice(m.body.getStart(sf) + 1, m.body.getEnd() - 1); // between the braces
+    return _dedent(inner);
+}
+/**
+ * Replaces an event method's body with `body` (an edited, de-indented buffer), re-indenting it to
+ * the method's level. Returns the full updated source; a no-op if the method is absent.
+ * @param method - The on_* method to update
+ * @param body   - The new body (column-0 / de-indented, as edited)
+ */
+function set_event_body(src, method, body) {
+    const sf = _source(src);
+    const cls = _find_class(sf);
+    if (!cls)
+        return src;
+    const m = _find_event_method(cls, method);
+    if (!m || !m.body)
+        return src;
+    const open = m.body.getStart(sf); // position of '{'
+    const close = m.body.getEnd() - 1; // position of '}'
+    const method_indent = _line_indent(src, m.getStart(sf));
+    const dedented = _dedent(body);
+    const inner = dedented === '' ? '' : _indent(dedented, method_indent + '    ');
+    const block = '{\n' + (inner ? inner + '\n' : '') + method_indent + '}';
+    return src.slice(0, open) + block + src.slice(close + 1);
+}
+// =========================================================================
+// Normalize — variables-first + canonical event order + indentation (full class view)
+// =========================================================================
+/**
+ * Re-indents code by bracket/brace/paren depth (leading whitespace only — never touches content or
+ * spacing). Strings and comments are skipped. Good for typical game code; deeply nested `({`-style
+ * continuations may be off by a level (cosmetic, not corrupting).
+ */
+function _reindent(code, unit = '    ') {
+    const lines = code.replace(/\r\n?/g, '\n').split('\n');
+    const out = [];
+    let depth = 0;
+    let in_block = false; // inside a /* … */ comment spanning lines
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (line === '') {
+            out.push('');
+            continue;
+        }
+        let delta = 0, first_is_closer = false, started = false;
+        let i = 0;
+        let line_block = in_block;
+        while (i < line.length) {
+            if (line_block) {
+                if (line[i] === '*' && line[i + 1] === '/') {
+                    line_block = false;
+                    i += 2;
+                    continue;
+                }
+                i++;
+                continue;
+            }
+            const c = line[i], n = line[i + 1];
+            if (c === '/' && n === '/')
+                break;
+            if (c === '/' && n === '*') {
+                line_block = true;
+                i += 2;
+                continue;
+            }
+            if (c === '"' || c === "'" || c === '`') {
+                const q = c;
+                i++;
+                while (i < line.length && line[i] !== q) {
+                    if (line[i] === '\\')
+                        i++;
+                    i++;
+                }
+                i++;
+                continue;
+            }
+            const opener = c === '{' || c === '(' || c === '[';
+            const closer = c === '}' || c === ')' || c === ']';
+            if (opener)
+                delta++;
+            else if (closer)
+                delta--;
+            if (!started && (opener || closer || /\S/.test(c))) {
+                started = true;
+                if (closer)
+                    first_is_closer = true;
+            }
+            i++;
+        }
+        in_block = line_block;
+        const this_depth = Math.max(0, depth - (first_is_closer ? 1 : 0));
+        out.push(unit.repeat(this_depth) + line);
+        depth = Math.max(0, depth + delta);
+    }
+    return out.join('\n');
+}
+/**
+ * Reorders all class members into canonical groups, preserving each member's attached comments:
+ *   1. instance variables — in their existing relative order (field-init order can matter; one
+ *      field's initializer may read another), so they're grouped but never shuffled among themselves;
+ *   2. `on_*` event methods — in canonical EVENT_ORDER;
+ *   3. everything else (statics, helper methods) — in place.
+ * Variables-before-events is the whole point: every event can reference every variable. A no-op if
+ * the order is already canonical.
+ */
+function _reorder_members(src) {
+    const sf = _source(src);
+    const cls = _find_class(sf);
+    if (!cls || cls.members.length <= 1)
+        return src;
+    const members = cls.members;
+    const event_idx = (m) => {
+        const n = _name_of(m);
+        return n && ts.isMethodDeclaration(m) ? exports.EVENT_ORDER.indexOf(n) : -1;
+    };
+    const is_var = (m) => ts.isPropertyDeclaration(m) && !_is_static(m);
+    const vars = members.filter(is_var);
+    const events = members.filter(m => event_idx(m) >= 0).sort((a, b) => event_idx(a) - event_idx(b));
+    const others = members.filter(m => !is_var(m) && event_idx(m) < 0);
+    const ordered = [...vars, ...events, ...others];
+    if (ordered.every((m, i) => m === members[i]))
+        return src; // already canonical
+    // Rebuild the class body from each member's full text (getFullStart → getEnd includes the leading
+    // trivia — newlines/indent/comments — so comments travel with their member). The class header up
+    // to `{` and the closing `}` + trailing trivia are preserved verbatim.
+    const chunk = (m) => src.slice(m.getFullStart(), m.getEnd());
+    const prefix = src.slice(0, members[0].getFullStart());
+    const suffix = src.slice(members[members.length - 1].getEnd());
+    return prefix + ordered.map(chunk).join('') + suffix;
+}
+/**
+ * Normalizes a class-per-object file for display in the full code view: variables hoisted above all
+ * events, canonical event order, then consistent indentation. Unchanged if there's no class.
+ */
+function normalize_object(src) {
+    return _reindent(_reorder_members(src));
+}
+// =========================================================================
 // Scaffolding
 // =========================================================================
 /** Generates a minimal class-file source for a new object. Imports are auto-managed (none needed). */

package/dist/templates.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Starter templates for the New Project flow.
+ *
+ * Each template is a real, ready-to-build project folder bundled under `../templates/<id>/`
+ * (sprites and all). Creating a project from a template is just a recursive copy of that folder
+ * into the destination — no codegen — so the templates stay editable/diffable in the repo and a
+ * dogfooded example game *is* the template. Pure Node (fs/path), reusable from the IDE or CLI.
+ */
+export interface template_info {
+    id: string;
+    label: string;
+    description: string;
+    display_color: string;
+}
+/** Returns the available starter templates — only those whose folder is actually installed. */
+export declare function list_templates(): template_info[];
+/**
+ * Materializes a starter template into `dest_folder` by recursively copying its bundled project
+ * folder, then (optionally) setting the display name in project.json.
+ * @param template_id - 'empty' | 'platformer' | 'topdown'
+ * @param dest_folder - Absolute path of the new project folder (created if missing)
+ * @param name        - Optional display name to write into project.json
+ */
+export declare function create_from_template(template_id: string, dest_folder: string, name?: string): Promise<void>;