@cmpose/core 0.1.1 → 0.2.0

package/src/game/unityYaml.js

@@ -0,0 +1,193 @@
+// cmpose.dev/game: Unity's serialized YAML (ProjectSettings.asset, EditorBuildSettings.asset) is edited
+// line by line, never through a YAML library: Unity's tags (--- !u!129 &1) and layout must survive.
+// Every editor works inside one document and refuses to guess: no match or more than one throws.
+
+class UnityYamlError extends Error {
+    constructor(message, { key, matches } = {}) {
+        super(message);
+        this.name = 'UnityYamlError';
+        this.key = key;
+        this.matches = matches;
+    }
+}
+
+function escapeRe(s) {
+    return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function eolOf(text) {
+    return text.includes('\r\n') ? '\r\n' : '\n';
+}
+
+function findDocument(text, classId, fileId = 1) {
+    const header = new RegExp(`^--- !u!${classId} &${fileId}(?![0-9])[^\\r\\n]*`, 'm').exec(text);
+    if (!header) throw new UnityYamlError(`document !u!${classId} &${fileId} not found`);
+    const bodyStart = header.index + header[0].length;
+    const next = /^--- /m.exec(text.slice(bodyStart));
+    return { start: header.index, end: next ? bodyStart + next.index : text.length };
+}
+
+function withScope(text, doc, edit) {
+    const { start, end } = doc ? findDocument(text, doc.classId, doc.fileId === undefined ? 1 : doc.fileId) : { start: 0, end: text.length };
+    const segment = text.slice(start, end);
+    const result = edit(segment);
+    return result === undefined ? undefined : { text: text.slice(0, start) + result + text.slice(end), segment };
+}
+
+// Lines keep their own line ending; the last one may have none
+function splitLines(segment) {
+    return segment.split(/(?<=\n)/);
+}
+
+function body(line) {
+    return line.replace(/\r?\n$/, '');
+}
+
+function ending(line) {
+    const m = /\r?\n$/.exec(line);
+    return m ? m[0] : '';
+}
+
+function topLevelIndexes(lines, key) {
+    const re = new RegExp(`^  ${escapeRe(key)}:(?:[ \\t]|$)`);
+    const found = [];
+    lines.forEach((line, i) => { if (re.test(body(line))) found.push(i); });
+    return found;
+}
+
+function onlyOne(found, key) {
+    if (found.length !== 1) {
+        throw new UnityYamlError(`${key}: expected 1 match, found ${found.length}`, { key, matches: found.length });
+    }
+    return found[0];
+}
+
+function valueOf(line, key) {
+    return body(line).slice(`  ${key}:`.length).trim();
+}
+
+function setScalar(text, key, value, { doc } = {}) {
+    return withScope(text, doc, (segment) => {
+        const lines = splitLines(segment);
+        const i = onlyOne(topLevelIndexes(lines, key), key);
+        lines[i] = `  ${key}: ${value}${ending(lines[i])}`;
+        return lines.join('');
+    }).text;
+}
+
+function getScalar(text, key, { doc } = {}) {
+    let value;
+    withScope(text, doc, (segment) => {
+        const lines = splitLines(segment);
+        const found = topLevelIndexes(lines, key);
+        if (found.length > 1) onlyOne(found, key);
+        value = found.length === 1 ? valueOf(lines[found[0]], key) : undefined;
+        return segment;
+    });
+    return value;
+}
+
+// A block map: '  key:' followed by deeper-indented lines; an empty one is written '  key: {}'
+function locateMap(lines, mapKey) {
+    const header = onlyOne(topLevelIndexes(lines, mapKey), mapKey);
+    const inline = valueOf(lines[header], mapKey);
+    let end = header + 1;
+    if (!inline) while (end < lines.length && /^ {4,}\S/.test(body(lines[end]))) end++;
+    if (inline && !/^\{\s*\}$/.test(inline)) {
+        throw new UnityYamlError(`${mapKey}: inline map '${inline}' is not supported`, { key: mapKey });
+    }
+    return { header, end, empty: Boolean(inline) || end === header + 1 };
+}
+
+function entryIndexes(lines, header, end, subKey) {
+    const re = new RegExp(`^    ${escapeRe(subKey)}:(?:[ \\t]|$)`);
+    const found = [];
+    for (let i = header + 1; i < end; i++) if (re.test(body(lines[i]))) found.push(i);
+    if (found.length > 1) onlyOne(found, subKey);
+    return found;
+}
+
+function setMapEntry(text, mapKey, subKey, value, { doc } = {}) {
+    const eol = eolOf(text);
+    return withScope(text, doc, (segment) => {
+        const lines = splitLines(segment);
+        const { header, end } = locateMap(lines, mapKey);
+        const entry = `    ${subKey}: ${value}`;
+        if (end === header + 1) {
+            lines[header] = `  ${mapKey}:${eol}${entry}${ending(lines[header])}`;
+            return lines.join('');
+        }
+        const found = entryIndexes(lines, header, end, subKey);
+        if (found.length === 1) {
+            lines[found[0]] = entry + ending(lines[found[0]]);
+        } else {
+            // The new entry takes the last entry's line ending; at the very end of the file it has none
+            const last = end - 1;
+            const lastEnding = ending(lines[last]);
+            if (!lastEnding) lines[last] += eol;
+            lines.splice(end, 0, entry + lastEnding);
+        }
+        return lines.join('');
+    }).text;
+}
+
+function getMapEntry(text, mapKey, subKey, { doc } = {}) {
+    let value;
+    withScope(text, doc, (segment) => {
+        const lines = splitLines(segment);
+        const { header, end } = locateMap(lines, mapKey);
+        const found = entryIndexes(lines, header, end, subKey);
+        value = found.length === 1 ? body(lines[found[0]]).slice(`    ${subKey}:`.length).trim() : undefined;
+        return segment;
+    });
+    return value;
+}
+
+// The sub-keys of a block map, in file order ([] for an empty map)
+function getMapKeys(text, mapKey, { doc } = {}) {
+    let keys = [];
+    withScope(text, doc, (segment) => {
+        const lines = splitLines(segment);
+        const { header, end } = locateMap(lines, mapKey);
+        keys = [];
+        for (let i = header + 1; i < end; i++) {
+            const m = /^ {4}([^\s:][^:]*):(?:[ \t]|$)/.exec(body(lines[i]));
+            if (m) keys.push(m[1]);
+        }
+        return segment;
+    });
+    return keys;
+}
+
+function removeMapEntry(text, mapKey, subKey, { doc } = {}) {
+    return withScope(text, doc, (segment) => {
+        const lines = splitLines(segment);
+        const { header, end } = locateMap(lines, mapKey);
+        const found = entryIndexes(lines, header, end, subKey);
+        if (found.length === 0) return segment;
+        lines.splice(found[0], 1);
+        if (end - 1 === header + 1) lines[header] = `  ${mapKey}: {}${ending(lines[header])}`;
+        return lines.join('');
+    }).text;
+}
+
+// A list under a top-level key: Unity writes its items at the key's own indent ('  - item')
+function setList(text, key, items, { doc } = {}) {
+    const eol = eolOf(text);
+    return withScope(text, doc, (segment) => {
+        const lines = splitLines(segment);
+        const header = onlyOne(topLevelIndexes(lines, key), key);
+        let end = header + 1;
+        while (end < lines.length && /^  - /.test(body(lines[end]))) end++;
+        const after = ending(lines[end - 1]);
+        const block = items.length === 0
+            ? `  ${key}: []${after}`
+            : [`  ${key}:`, ...items.map((item) => `  - ${item}`)].join(eol) + after;
+        lines.splice(header, end - header, block);
+        return lines.join('');
+    }).text;
+}
+
+module.exports = {
+    UnityYamlError, escapeRe, findDocument, setScalar, getScalar, setMapEntry, getMapEntry, getMapKeys, removeMapEntry, setList
+};

package/src/game/validate.js

@@ -0,0 +1,160 @@
+'use strict';
+const PV = require('../ProjectValidator');
+const limits = require('../limits');
+const { GAME_SCHEMA: S } = require('./contract');
+
+const CSHARP_KEYWORDS = ('abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while').split(' ');
+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}$/;
+
+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}$/
+    },
+    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}$/
+    }
+};
+
+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);
+
+function checkName(field, value) {
+    if (typeof value !== 'string' || !NAME_RE.test(value)) return `${field} must be 1-${S.limits.nameMax} letters or digits, starting with a letter`;
+    if (inList(CSHARP_KEYWORDS, value, false)) return `${field} must not be a C# keyword`;
+    if (S.reservedNames.includes(value)) return `${field} is reserved`;
+    return null;
+}
+
+function parseIosVersion(v) {
+    return String(v).split('.').map(Number);
+}
+function cmpVersion(a, b) {
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const d = (a[i] || 0) - (b[i] || 0);
+        if (d) return d;
+    }
+    return 0;
+}
+
+function validateIds(ids, flags) {
+    if (!isObject(ids)) return { error: 'ids must be an object' };
+    const out = {};
+    for (const group of Object.keys(ids)) {
+        const def = Object.hasOwn(S.idGroups, group) ? S.idGroups[group] : null;
+        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 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 (!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;
+        }
+    }
+    return { value: out };
+}
+
+function validateGame(input) {
+    if (!isObject(input)) return fail('input must be an object');
+    const { projectName, appName, packageName } = input;
+
+    let err = checkName('projectName', projectName);
+    if (err) return fail(err);
+
+    if (typeof appName !== 'string' || !PV.validateAppName(appName) || appName.length > S.limits.appNameMax) return fail(PV.messages.appNameInvalid.replace('App Name', 'appName'));
+
+    if (typeof packageName !== 'string' || !PACKAGE_RE.test(packageName) || packageName.length > S.limits.packageNameMax) {
+        return fail(`packageName must look like com.company.app (lowercase, at least 3 segments, up to ${S.limits.packageNameMax} characters)`);
+    }
+    const segments = packageName.split('.');
+    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;
+    err = checkName('companyName', companyName);
+    if (err) return fail(err);
+
+    const templateType = input.templateType === undefined ? 'showcase' : input.templateType;
+    if (!S.templateTypes.includes(templateType)) return fail(`templateType must be one of: ${S.templateTypes.join(', ')}`);
+    const render = input.render === undefined ? '2d' : input.render;
+    if (!S.renders.includes(render)) return fail(`render must be one of: ${S.renders.join(', ')}`);
+
+    const blank = templateType === 'blank';
+    if (!blank && input.flags !== undefined) return fail('flags apply to blank only');
+    if (!blank && input.features !== undefined) return fail('features apply to blank only');
+
+    let flags = S.flags.slice();
+    if (blank) {
+        const wanted = input.flags === undefined ? [] : input.flags;
+        if (!Array.isArray(wanted) || wanted.some((f) => !S.flags.includes(f))) return fail(`flags must be an array of: ${S.flags.join(', ')}`);
+        const set = new Set(wanted);
+        for (const f of wanted) for (const r of (Object.hasOwn(S.flagRequires, f) ? S.flagRequires[f] : [])) set.add(r);
+        flags = S.flags.filter((f) => set.has(f));
+    }
+
+    let features = [];
+    if (blank && input.features !== undefined) {
+        const list = input.features;
+        if (!Array.isArray(list)) return fail('features must be an array');
+        if (list.length > S.limits.maxModules) return fail(`features allows at most ${S.limits.maxModules} entries`);
+        for (const f of list) {
+            if (typeof f !== 'string' || !MODULE_RE.test(f)) return fail(`features entry "${f}" must be 1-${S.limits.moduleNameMax} lowercase letters or digits, starting with a letter`);
+            if (inList(CSHARP_KEYWORDS, f, true) || inList(KOTLIN_KEYWORDS, f, true)) return fail(`features entry "${f}" is a keyword`);
+            if (S.reservedModuleNames.includes(f)) return fail(`features entry "${f}" is reserved`);
+        }
+        if (new Set(list).size !== list.length) return fail('features must not contain duplicates');
+        features = list.slice();
+    }
+
+    let minSdk = S.limits.minSdkMin;
+    if (input.minSdk !== undefined) {
+        const raw = input.minSdk;
+        const n = typeof raw === 'number' ? raw : (typeof raw === 'string' && /^\d+$/.test(raw) ? Number(raw) : NaN);
+        if (!Number.isInteger(n) || n < S.limits.minSdkMin || n > S.limits.minSdkMax) return fail(`minSdk must be an integer from ${S.limits.minSdkMin} to ${S.limits.minSdkMax}`);
+        minSdk = n;
+    }
+
+    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
+            || cmpVersion(parseIosVersion(v), parseIosVersion(limits.iosVersionMax)) > 0) {
+            return fail(`iosVersion must be from ${S.limits.iosVersionMin} to ${limits.iosVersionMax}`);
+        }
+        iosVersion = v;
+    }
+
+    if (input.ci !== undefined && typeof input.ci !== 'boolean') return fail('ci must be a boolean');
+
+    let ids = {};
+    if (input.ids !== undefined) {
+        const r = validateIds(input.ids, flags);
+        if (r.error) return fail(r.error);
+        ids = r.value;
+    }
+
+    return {
+        ok: true,
+        value: { projectName, appName, packageName, companyName, templateType, render, flags, features, minSdk, iosVersion, ci: input.ci === true, ids }
+    };
+}
+
+module.exports = { validateGame };

package/src/game/verifier.js

@@ -0,0 +1,36 @@
+'use strict';
+const path = require('path');
+const fs = require('fs-extra');
+const { checkGuidIntegrity, readGuidAllowlist } = require('./guidIntegrity');
+const { findResidue } = require('./residue');
+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;
+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]);
+}
+
+/** Problems of a generated Unity game (empty = clean): 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 = [];
+    for (const problem of residue) {
+        if (!problem.startsWith('marker ') || (await stillMarked(projectDir, problem))) kept.push(problem);
+    }
+    return [...guidProblems, ...kept];
+}
+
+module.exports = { verifyGameProject };

package/src/index.js

@@ -33,5 +33,6 @@ module.exports = {
     generationWarnings: require('./warnings').generationWarnings,
     generateCmpProject: require('./generate').generateCmpProject,
     templateCache: require('./templateCache'),
+    game: require('./game'),
     TemplateFetchError: require('./templateCache').TemplateFetchError
 };

package/src/pins.js

@@ -1,5 +1,7 @@
 'use strict';
 // The template tags this core version was tested with (immutable tags)
 module.exports = Object.freeze({
-    cmp: Object.freeze({ repo: 'Keremturker/cmpose-template', ref: 'template-2026.10.14' })
+    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' })
 });