@cmpose/core 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmpose/core",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "cmpose project generator core (Compose Multiplatform)",
   "license": "MIT",
   "repository": {

package/src/game/guid.js

@@ -68,4 +68,4 @@ async function cloneWithNewGuids(srcDir, dstDir, { seed, rename = [] }) {
     return { map };
 }
 
-module.exports = { GUID_RE, newGuid, readMetaGuid, remapGuids, cloneWithNewGuids };
+module.exports = { GUID_RE, newGuid, readMetaGuid, remapGuids, renamer, cloneWithNewGuids };

package/src/game/identity.js

@@ -1,6 +1,7 @@
 const path = require('path');
 const fs = require('fs-extra');
-const { escapeRe, getMapKeys, setMapEntry } = require('./unityYaml');
+const { getMapKeys, setMapEntry } = require('./unityYaml');
+const { renamer } = require('./guid');
 const { PLAYER, applyIdentity } = require('./projectSettings');
 
 const TEXT_EXTENSIONS = new Set(['.cs', '.asmdef', '.asmref', '.prefab', '.unity', '.asset', '.mat', '.json', '.md', '.txt',
@@ -8,14 +9,6 @@ const TEXT_EXTENSIONS = new Set(['.cs', '.asmdef', '.asmref', '.prefab', '.unity
 const SKIPPED = new Set(['Library', 'Temp', 'Logs', 'UserSettings', '.git', '.cmpose']);
 const TEMPLATE_NAMESPACE = 'Kturker.UnityBase';
 
-// One pass, longest 'from' first, so a replacement is never replaced again
-function renamer(pairs) {
-    const sorted = [...pairs].sort((a, b) => b.from.length - a.from.length);
-    const lookup = new Map(sorted.map((p) => [p.from, p.to]));
-    const re = new RegExp(sorted.map((p) => escapeRe(p.from)).join('|'), 'g');
-    return (s) => s.replace(re, (m) => lookup.get(m));
-}
-
 // Every file and folder below dir outside the skipped top-level folders; folders are listed too
 async function walk(abs, rel, out) {
     for (const entry of await fs.readdir(abs, { withFileTypes: true })) {
@@ -36,6 +29,21 @@ async function applyGameIdentity(projectDir, { companyName, projectName, appName
     const entries = [];
     await walk(projectDir, '', entries);
 
+    // Names, deepest first; a .meta carries the template namespace in its name too, so it follows its asset.
+    // Every target is checked before anything changes, so a collision leaves the project as it was.
+    const namePart = renamer([{ from: TEMPLATE_NAMESPACE, to: `${companyName}.${projectName}` }]);
+    const moves = entries.filter((e) => path.posix.basename(e.rel).includes(TEMPLATE_NAMESPACE))
+        .sort((a, b) => b.rel.split('/').length - a.rel.split('/').length)
+        .map((e) => {
+            const from = path.join(projectDir, e.rel);
+            return { rel: e.rel, from, to: path.join(path.dirname(from), namePart(path.basename(from))) };
+        });
+    const targets = new Set();
+    for (const m of moves) {
+        if (targets.has(m.to) || (await fs.pathExists(m.to))) throw new Error(`cannot rename ${m.rel}: target exists`);
+        targets.add(m.to);
+    }
+
     // 1. content
     for (const e of entries) {
         if (e.dir || !TEXT_EXTENSIONS.has(path.extname(e.rel))) continue;
@@ -45,18 +53,9 @@ async function applyGameIdentity(projectDir, { companyName, projectName, appName
         if (next !== text) await fs.writeFile(file, next);
     }
 
-    // 2. names, deepest first; a .meta carries the template namespace in its name too, so it follows its asset
-    const namePart = renamer([{ from: TEMPLATE_NAMESPACE, to: `${companyName}.${projectName}` }]);
-    let renamedFiles = 0;
-    const named = entries.filter((e) => path.posix.basename(e.rel).includes(TEMPLATE_NAMESPACE))
-        .sort((a, b) => b.rel.split('/').length - a.rel.split('/').length);
-    for (const e of named) {
-        const from = path.join(projectDir, e.rel);
-        const to = path.join(path.dirname(from), namePart(path.basename(from)));
-        if (await fs.pathExists(to)) throw new Error(`cannot rename ${e.rel}: target exists`);
-        await fs.move(from, to);
-        renamedFiles += 1;
-    }
+    // 2. names, in the order checked above
+    for (const m of moves) await fs.move(m.from, m.to);
+    const renamedFiles = moves.length;
 
     // 3. PlayerSettings
     const settingsFile = path.join(projectDir, 'ProjectSettings', 'ProjectSettings.asset');

package/src/game/ids.js

@@ -1,5 +1,6 @@
 const path = require('path');
 const fs = require('fs-extra');
+const { idProblem } = require('./validate');
 
 // Where each id group lands in the Unity template. `keys` maps the line's key to the field of the group.
 // kind 'cs': `public const string <Key> = "<value>";`, 'yaml': `  <key>: <value>`, 'xml': the games_app_id string.
@@ -52,22 +53,38 @@ const PATTERNS = {
     xml: (key) => new RegExp(`(<string name="${key}"[^>]*>)[^<]*(</string>)`, 'g')
 };
 
+// One regex pass: the replacer counts the matches; a function replacer never interprets `$` sequences
 function replaceOnce(text, file, kind, key, value) {
-    const re = PATTERNS[kind](key);
-    const n = (text.match(re) || []).length;
+    let n = 0;
+    const next = text.replace(PATTERNS[kind](key), (_, before, after) => {
+        n += 1;
+        return `${before}${value}${after}`;
+    });
     if (n !== 1) throw new Error(`${file}: ${key} found ${n} times`);
-    // A function replacer, so `$` sequences in the value are never interpreted
-    return text.replace(re, (_, before, after) => `${before}${value}${after}`);
+    return next;
 }
 
-// Writes the given id groups into the project; every target line must be there exactly once. All files are checked
-// before any is written, so a failure leaves the project as it was. Returns the groups written.
+// The values land inside C#, YAML and XML lines: the same rules as validateGame, checked here too
+function checkValues(group, values) {
+    if (!values || typeof values !== 'object' || Array.isArray(values)) throw new Error(`ids.${group} must be an object`);
+    for (const { keys } of ID_TARGETS[group]) {
+        for (const field of Object.values(keys)) {
+            const problem = idProblem(group, field, values[field]);
+            if (problem) throw new Error(`ids.${group}.${field} ${problem}`);
+        }
+    }
+}
+
+// Writes the given id groups into the project; every value must pass validateGame's ID rules and every target line
+// must be there exactly once. All are checked before any file is written, so a failure leaves the project as it was.
+// Returns the groups written.
 async function writeGameIds(projectDir, ids) {
+    const groups = Object.keys(ID_TARGETS).filter((group) => ids && ids[group]);
+    for (const group of groups) checkValues(group, ids[group]);
     const written = [];
     const updates = [];
-    for (const group of Object.keys(ID_TARGETS)) {
-        const values = ids && ids[group];
-        if (!values) continue;
+    for (const group of groups) {
+        const values = ids[group];
         for (const { file, kind, keys } of ID_TARGETS[group]) {
             const abs = path.join(projectDir, file);
             let text;

package/src/game/modules.js

@@ -32,12 +32,23 @@ async function owningAsmdef(projectDir, rel) {
     return null;
 }
 
+// Writes value back as JSON in the original text's format: its indent (spaces or tab), line ending and final newline
+function sameFormatJson(original, value) {
+    const eol = original.includes('\r\n') ? '\r\n' : '\n';
+    // A one-line file (however it ends) stays on one line; otherwise the first indented line gives the indent
+    const multiline = original.trim().includes('\n');
+    const indent = /\n([ \t]+)\S/.exec(original);
+    const body = JSON.stringify(value, null, !multiline ? 0 : (indent ? indent[1] : 2));
+    return body.replace(/\n/g, eol) + (/\r?\n$/.test(original) ? eol : '');
+}
+
 // Reads every file the wiring edits and checks its anchors before anything is written
 async function readAnchors(projectDir, fail) {
     if (!(await fs.pathExists(path.join(projectDir, SAMPLE_DIR)))) throw fail(SAMPLE_DIR);
     const manifestFile = path.join(projectDir, MANIFEST);
     if (!(await fs.pathExists(manifestFile))) throw fail(MANIFEST);
-    const manifest = JSON.parse(await fs.readFile(manifestFile, 'utf8'));
+    const manifestText = await fs.readFile(manifestFile, 'utf8');
+    const manifest = JSON.parse(manifestText);
     if (!manifest || typeof manifest.flags !== 'object') throw fail(`${MANIFEST} "flags"`);
 
     const installerFile = path.join(projectDir, GAME_INSTALLER);
@@ -55,13 +66,14 @@ async function readAnchors(projectDir, fail) {
 
     const asmdefRel = await owningAsmdef(projectDir, GAME_DIR);
     if (!asmdefRel) throw fail(`the asmdef owning ${GAME_INSTALLER}`);
-    const asmdef = JSON.parse(await fs.readFile(path.join(projectDir, asmdefRel), 'utf8'));
+    const asmdefText = await fs.readFile(path.join(projectDir, asmdefRel), 'utf8');
+    const asmdef = JSON.parse(asmdefText);
     const refAt = Array.isArray(asmdef.references) ? asmdef.references.indexOf(SAMPLE_INSTALLER_ASSEMBLY) : -1;
     if (refAt < 0) throw fail(`the ${SAMPLE_INSTALLER_ASSEMBLY} reference in ${asmdefRel}`);
 
     return {
-        manifest, manifestFile, installerFile, lines, eol, end, usingAt,
-        indent: /^\s*/.exec(sampleLine)[0], asmdefRel, asmdef, refAt
+        manifest, manifestText, manifestFile, installerFile, lines, eol, end, usingAt,
+        indent: /^\s*/.exec(sampleLine)[0], asmdefRel, asmdef, asmdefText, refAt
     };
 }
 
@@ -95,11 +107,13 @@ async function cloneModules(projectDir, features, { seed }) {
             throw new Error(`module ${name}: ${FEATURES}/${pascal(name)} already exists`);
         }
     }
+    // Every module waits on the same anchors, so an anchor error names them all
+    const who = `${names.length > 1 ? 'modules' : 'module'} ${names.join(', ')}`;
     let anchors;
     try {
-        anchors = await readAnchors(projectDir, (what) => new Error(`module ${names[0]}: ${what} not found in the template`));
+        anchors = await readAnchors(projectDir, (what) => new Error(`${who}: ${what} not found in the template`));
     } catch (error) {
-        if (error instanceof SyntaxError) throw new Error(`module ${names[0]}: ${error.message}`);
+        if (error instanceof SyntaxError) throw new Error(`${who}: ${error.message}`);
         throw error;
     }
 
@@ -118,9 +132,9 @@ async function cloneModules(projectDir, features, { seed }) {
         created.push(`${FEATURES}/${p}`);
     }
 
-    const { manifest, manifestFile, lines, eol, end, usingAt, indent, asmdef, refAt } = anchors;
+    const { manifest, manifestText, manifestFile, lines, eol, end, usingAt, indent, asmdef, asmdefText, refAt } = anchors;
     addFlagTwins(manifest, names);
-    await fs.writeFile(manifestFile, `${JSON.stringify(manifest, null, 2)}\n`);
+    await fs.writeFile(manifestFile, sameFormatJson(manifestText, manifest));
 
     // Installer lines go before the end marker (in order), using lines right after the Sample one
     const installs = names.map((n) => `${indent}if (registerViews) new ${pascal(n)}Installer(registerViews).Install(builder);`);
@@ -131,7 +145,7 @@ async function cloneModules(projectDir, features, { seed }) {
     await fs.writeFile(anchors.installerFile, next.join(eol));
 
     asmdef.references.splice(refAt + 1, 0, ...names.map((n) => `Kturker.UnityBase.Features.${pascal(n)}.Installer`));
-    await fs.writeFile(path.join(projectDir, anchors.asmdefRel), `${JSON.stringify(asmdef, null, 4)}\n`);
+    await fs.writeFile(path.join(projectDir, anchors.asmdefRel), sameFormatJson(asmdefText, asmdef));
     return created;
 }
 

package/src/game/record.js

@@ -16,9 +16,13 @@ function idStatuses(flags, ids) {
     return out;
 }
 
+// The value is meant to come from validateGame, but the record never assumes it: odd entries are dropped
+const strings = (list) => (Array.isArray(list) ? list.filter((x) => typeof x === 'string') : []);
+
 /** The .cmpose/generation.json content of a generated Unity game (no personal data, no ID values);
  * generatorVersion names the caller (e.g. mcp@0.2.0), null when not given */
 function buildGameRecord({ template, coreVersion, generatorVersion = null, value, now = new Date() }) {
+    const flags = strings(value.flags);
     return {
         generator: '@cmpose/core',
         coreVersion,
@@ -27,12 +31,12 @@ function buildGameRecord({ template, coreVersion, generatorVersion = null, value
         unityVersion: GAME_SCHEMA.unityVersion,
         templateType: value.templateType,
         render: value.render,
-        flags: value.flags.slice(),
-        features: value.features.slice(),
+        flags,
+        features: strings(value.features),
         ci: value.ci === true,
         minSdk: value.minSdk,
         iosVersion: value.iosVersion,
-        ids: idStatuses(value.flags, value.ids),
+        ids: idStatuses(flags, value.ids),
         template: { repo: template.repo, ref: template.ref, commit: template.commit },
         generatedAt: now.toISOString()
     };

package/src/game/unityYaml.js

@@ -143,11 +143,29 @@ function getMapEntry(text, mapKey, subKey, { doc } = {}) {
     return value;
 }
 
-// The sub-keys of a block map, in file order ([] for an empty map)
+// The keys of an inline map of plain scalars ('{a: 1, b: 2}'); anything nested or quoted is refused
+function inlineMapKeys(inline, mapKey) {
+    const inner = inline.slice(1, -1).trim();
+    if (!inner) return [];
+    const refuse = () => new UnityYamlError(`${mapKey}: inline map '${inline}' is not supported`, { key: mapKey });
+    if (/[{}[\]"']/.test(inner)) throw refuse();
+    return inner.split(',').map((part) => {
+        const m = /^([^\s:][^:]*):(?:[ \t]|$)/.exec(part.trim());
+        if (!m) throw refuse();
+        return m[1].trim();
+    });
+}
+
+// The sub-keys of a map, block or inline, in file order ([] for an empty map)
 function getMapKeys(text, mapKey, { doc } = {}) {
     let keys = [];
     withScope(text, doc, (segment) => {
         const lines = splitLines(segment);
+        const inline = valueOf(lines[onlyOne(topLevelIndexes(lines, mapKey), mapKey)], mapKey);
+        if (inline.startsWith('{') && inline.endsWith('}')) {
+            keys = inlineMapKeys(inline, mapKey);
+            return segment;
+        }
         const { header, end } = locateMap(lines, mapKey);
         keys = [];
         for (let i = header + 1; i < end; i++) {

package/src/game/validate.js

@@ -9,22 +9,40 @@ const KOTLIN_KEYWORDS = PV.KOTLIN_HARD_KEYWORDS;
 const NAME_RE = /^[A-Za-z][A-Za-z0-9]{0,29}$/;
 const PACKAGE_RE = /^[a-z][a-z0-9]*(\.[a-z][a-z0-9]*){2,}$/;
 const MODULE_RE = /^[a-z][a-z0-9]{0,19}$/;
-const IOS_VERSION_RE = /^\d+(\.\d+){1,2}$/;
-
+// 'M', 'M.m' or 'M.m.0' (leading zeros allowed); normalized to 'M.m'
+const IOS_VERSION_RE = /^(\d+)(?:\.(\d+)(?:\.(0+))?)?$/;
+
+// Each ID's pattern and the shape an error message names
+const ADMOB_APP = { re: /^ca-app-pub-\d{16}~\d{10}$/, shape: 'ca-app-pub-<16 digits>~<10 digits>' };
+const ADMOB_UNIT = { re: /^ca-app-pub-\d{16}\/\d{10}$/, shape: 'ca-app-pub-<16 digits>/<10 digits>' };
+const GPGS_ID = { re: /^[A-Za-z0-9_-]{4,64}$/, shape: '4-64 letters, digits, _ or -' };
+const GC_ID = { re: /^[A-Za-z0-9._-]{1,100}$/, shape: '1-100 letters, digits, ., _ or -' };
 const ID_FORMATS = {
     admob: {
-        androidAppId: /^ca-app-pub-\d{16}~\d{10}$/, iosAppId: /^ca-app-pub-\d{16}~\d{10}$/,
-        androidBanner: /^ca-app-pub-\d{16}\/\d{10}$/, androidInterstitial: /^ca-app-pub-\d{16}\/\d{10}$/, androidRewarded: /^ca-app-pub-\d{16}\/\d{10}$/,
-        iosBanner: /^ca-app-pub-\d{16}\/\d{10}$/, iosInterstitial: /^ca-app-pub-\d{16}\/\d{10}$/, iosRewarded: /^ca-app-pub-\d{16}\/\d{10}$/
+        androidAppId: ADMOB_APP, iosAppId: ADMOB_APP,
+        androidBanner: ADMOB_UNIT, androidInterstitial: ADMOB_UNIT, androidRewarded: ADMOB_UNIT,
+        iosBanner: ADMOB_UNIT, iosInterstitial: ADMOB_UNIT, iosRewarded: ADMOB_UNIT
+    },
+    revenueCat: {
+        appleApiKey: { re: /^appl_[A-Za-z0-9]{20,}$/, shape: 'appl_ followed by at least 20 letters or digits' },
+        googleApiKey: { re: /^goog_[A-Za-z0-9]{20,}$/, shape: 'goog_ followed by at least 20 letters or digits' }
     },
-    revenueCat: { appleApiKey: /^appl_[A-Za-z0-9]{20,}$/, googleApiKey: /^goog_[A-Za-z0-9]{20,}$/ },
     gameServices: {
-        androidAppId: /^\d{6,20}$/,
-        leaderboardAndroid: /^[A-Za-z0-9_-]{4,64}$/, firstCompletionAndroid: /^[A-Za-z0-9_-]{4,64}$/, tenCompletionsAndroid: /^[A-Za-z0-9_-]{4,64}$/,
-        leaderboardIos: /^[A-Za-z0-9._-]{1,100}$/, firstCompletionIos: /^[A-Za-z0-9._-]{1,100}$/, tenCompletionsIos: /^[A-Za-z0-9._-]{1,100}$/
+        androidAppId: { re: /^\d{6,20}$/, shape: '6-20 digits' },
+        leaderboardAndroid: GPGS_ID, firstCompletionAndroid: GPGS_ID, tenCompletionsAndroid: GPGS_ID,
+        leaderboardIos: GC_ID, firstCompletionIos: GC_ID, tenCompletionsIos: GC_ID
     }
 };
 
+// Why an ID value is rejected (null = valid). The value is written into C#, XML and YAML lines.
+function idProblem(group, field, v) {
+    if (typeof v !== 'string') return 'must be a string';
+    if (/["\\$\r\n]/.test(v)) return 'must not contain ", \\, $ or a line break';
+    if (/replace_me/i.test(v)) return 'is a placeholder (REPLACE_ME): use your real ID';
+    const { re, shape } = ID_FORMATS[group][field];
+    return re.test(v) ? null : `must look like ${shape}`;
+}
+
 const fail = (error) => ({ ok: false, error });
 const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
 const inList = (list, word, ci) => list.includes(ci ? String(word).toLowerCase() : word);
@@ -39,6 +57,11 @@ function checkName(field, value) {
 function parseIosVersion(v) {
     return String(v).split('.').map(Number);
 }
+// '015.0' / '15.0.0' / '15' -> '15.0'; null when not a version this accepts
+function normalizeIosVersion(v) {
+    const m = typeof v === 'string' ? IOS_VERSION_RE.exec(v) : null;
+    return m ? `${Number(m[1])}.${Number(m[2] || 0)}` : null;
+}
 function cmpVersion(a, b) {
     for (let i = 0; i < Math.max(a.length, b.length); i++) {
         const d = (a[i] || 0) - (b[i] || 0);
@@ -55,16 +78,16 @@ function validateIds(ids, flags) {
         if (!def) return { error: `ids.${group} is not a known group (${Object.keys(S.idGroups).join(', ')})` };
         const g = ids[group];
         if (!isObject(g)) return { error: `ids.${group} must be an object` };
-        const missing = def.fields.filter((f) => !(f in g));
+        const missing = def.fields.filter((f) => !Object.hasOwn(g, f));
+        if (missing.length) return { error: `ids.${group} is missing: ${missing.join(', ')}` };
         const extra = Object.keys(g).filter((f) => !def.fields.includes(f));
-        if (missing.length || extra.length) return { error: `ids.${group} needs all of: ${def.fields.join(', ')}` };
+        if (extra.length) return { error: `ids.${group} has unknown fields: ${extra.join(', ')} (known: ${def.fields.join(', ')})` };
         if (!flags.includes(def.flag)) return { error: `ids.${group} needs the ${def.flag} flag` };
         out[group] = {};
         for (const f of def.fields) {
-            const v = g[f];
-            const path = `ids.${group}.${f}`;
-            if (typeof v !== 'string' || /["\\$\r\n]/.test(v) || /replace_me/i.test(v) || !ID_FORMATS[group][f].test(v)) return { error: `${path} has an invalid format` };
-            out[group][f] = v;
+            const problem = idProblem(group, f, g[f]);
+            if (problem) return { error: `ids.${group}.${f} ${problem}` };
+            out[group][f] = g[f];
         }
     }
     return { value: out };
@@ -86,9 +109,11 @@ function validateGame(input) {
     if (segments.some((s) => inList(CSHARP_KEYWORDS, s, true) || inList(KOTLIN_KEYWORDS, s, true))) return fail('packageName must not contain a keyword segment');
     if (packageName === S.reservedPackagePrefix || packageName.startsWith(S.reservedPackagePrefix + '.')) return fail('packageName must not use the reserved com.kturker prefix');
 
-    const companyName = input.companyName === undefined ? segments[1][0].toUpperCase() + segments[1].slice(1) : input.companyName;
+    // Without companyName it comes from packageName's second segment: an error then points at packageName
+    const derived = input.companyName === undefined;
+    const companyName = derived ? segments[1][0].toUpperCase() + segments[1].slice(1) : input.companyName;
     err = checkName('companyName', companyName);
-    if (err) return fail(err);
+    if (err) return fail(derived ? `${err} (companyName "${companyName}" is derived from packageName's second segment: shorten it there or set companyName)` : err);
 
     const templateType = input.templateType === undefined ? 'showcase' : input.templateType;
     if (!S.templateTypes.includes(templateType)) return fail(`templateType must be one of: ${S.templateTypes.join(', ')}`);
@@ -133,9 +158,10 @@ function validateGame(input) {
     let iosVersion = S.limits.iosVersionMin;
     if (input.iosVersion !== undefined) {
         let v = input.iosVersion;
-        if (typeof v === 'number' && Number.isFinite(v)) v = Number.isInteger(v) ? `${v}.0` : String(v);
-        if (typeof v !== 'string' || !IOS_VERSION_RE.test(v)
-            || cmpVersion(parseIosVersion(v), parseIosVersion(S.limits.iosVersionMin)) < 0
+        if (typeof v === 'number' && Number.isFinite(v)) v = String(v);
+        v = normalizeIosVersion(v);
+        if (v === null) return fail('iosVersion must look like 15.0 (major.minor; a third part must be 0)');
+        if (cmpVersion(parseIosVersion(v), parseIosVersion(S.limits.iosVersionMin)) < 0
             || cmpVersion(parseIosVersion(v), parseIosVersion(limits.iosVersionMax)) > 0) {
             return fail(`iosVersion must be from ${S.limits.iosVersionMin} to ${limits.iosVersionMax}`);
         }
@@ -157,4 +183,4 @@ function validateGame(input) {
     };
 }
 
-module.exports = { validateGame };
+module.exports = { validateGame, idProblem };

package/src/game/verifier.js

@@ -8,29 +8,38 @@ const { escapeRe } = require('./unityYaml');
 const IDENTITY_RULE = { name: 'old identity', tokens: ['Kturker.UnityBase', 'UnityBase', 'unitybase', 'com.kturker'] };
 const MARKER_RULE = { name: 'marker', tokens: ['// cmpose:', '// /cmpose:'], extensions: ['.cs'] };
 // Extension points stay as whole lines (// cmpose:features:start … // cmpose:features:end in the GameInstaller,
-// // cmpose:boot-steps:start … :end in the BootInstaller): users add their own lines between them
-const KEPT_MARKER_LINE = /^[ \t]*\/\/ cmpose:[a-z][a-z0-9-]*:(?:start|end)[ \t]*\r?$/gm;
+// // cmpose:boot-steps:start … :end in the BootInstaller): users add their own lines between them. A name may be
+// kebab-case or camelCase (// cmpose:myExt:start).
+const KEPT_MARKER_LINE = /^[ \t]*\/\/ cmpose:[a-z][A-Za-z0-9-]*:(?:start|end)[ \t]*\r?$/gm;
 const MARKER_PROBLEM = new RegExp(`^marker (${MARKER_RULE.tokens.map(escapeRe).join('|')}) in (.+)$`);
 const IGNORE = ['.cmpose/'];
 
 // A marker problem stands only when the token is still there once the kept extension-point lines are dropped.
-// The token is one of the rule's own, so a path holding ' in ' is read whole.
-async function stillMarked(projectDir, problem) {
-    const m = MARKER_PROBLEM.exec(problem);
-    const text = (await fs.readFile(path.join(projectDir, m[2]), 'utf8')).replace(KEPT_MARKER_LINE, '');
-    return text.includes(m[1]);
+// The token is one of the rule's own, so a path holding ' in ' is read whole. Each file is read (and stripped)
+// once, however many marker problems it has.
+function markerCheck(projectDir) {
+    const stripped = new Map();
+    return async (problem) => {
+        const m = MARKER_PROBLEM.exec(problem);
+        if (!stripped.has(m[2])) {
+            stripped.set(m[2], (await fs.readFile(path.join(projectDir, m[2]), 'utf8')).replace(KEPT_MARKER_LINE, ''));
+        }
+        return stripped.get(m[2]).includes(m[1]);
+    };
 }
 
-/** Problems of a generated Unity game (empty = clean): asset guids, the template's identity, leftover flag markers */
+/** Problems of a generated Unity game (empty = clean), as one sorted list: asset guids, the template's identity,
+ * leftover flag markers */
 async function verifyGameProject(projectDir) {
     const allowlist = await readGuidAllowlist(path.join(projectDir, '.cmpose', 'package-guids.txt'));
     const guidProblems = await checkGuidIntegrity(projectDir, { allowlist });
     const residue = await findResidue(projectDir, [IDENTITY_RULE, MARKER_RULE], { ignore: IGNORE });
-    const kept = [];
+    const stillMarked = markerCheck(projectDir);
+    const problems = [...guidProblems];
     for (const problem of residue) {
-        if (!problem.startsWith('marker ') || (await stillMarked(projectDir, problem))) kept.push(problem);
+        if (!problem.startsWith('marker ') || (await stillMarked(problem))) problems.push(problem);
     }
-    return [...guidProblems, ...kept];
+    return problems.sort();
 }
 
 module.exports = { verifyGameProject };

package/src/pins.js

@@ -3,5 +3,5 @@
 module.exports = Object.freeze({
     cmp: Object.freeze({ repo: 'Keremturker/cmpose-template', ref: 'template-2026.10.14' }),
     // The release step replaces the placeholder with the game template's tag
-    game: Object.freeze({ repo: 'Keremturker/cmpose-game-template', ref: 'game-template-2026.10.14.1' })
+    game: Object.freeze({ repo: 'Keremturker/cmpose-game-template', ref: 'game-template-2026.10.15' })
 });