windows-development-sandbox 1.25.1 → 1.27.0

package/dist/shared/unity/editors.js

@@ -0,0 +1,89 @@
+// The Unity editors a sandbox has (this PC's, read-only, and the data disk's) and which one a project opens with. An
+// editor is never swapped for another version: opening a project in another Unity upgrades its files. Pure apart from
+// the file reads it is given.
+import path from 'node:path';
+import { UNITY_VERSION } from './version.js';
+const win = path.win32;
+export const ORIGIN_LABELS = {
+    pc: 'this PC, read-only',
+    data: 'the data disk, kept between sandboxes',
+};
+/** Folders under Editor\Data\PlaybackEngines that show a module is installed (windows-il2cpp: verify on an editor). */
+const MODULE_FOLDERS = {
+    android: ['AndroidPlayer'],
+    webgl: ['WebGLSupport'],
+    ios: ['iOSSupport'],
+    'windows-il2cpp': [
+        'windowsstandalonesupport\\Variations\\win64_player_development_il2cpp',
+        'windowsstandalonesupport\\Variations\\win64_development_il2cpp',
+    ],
+};
+/** The modules installed in an editor folder. */
+export function editorModules(root, fs) {
+    const engines = win.join(root, 'Editor', 'Data', 'PlaybackEngines');
+    return Object.entries(MODULE_FOLDERS)
+        .filter(([, folders]) => folders.some((f) => fs.exists(win.join(engines, f))))
+        .map(([id]) => id);
+}
+/** A data editor counts once its install finished: .complete.json (ours) or a Hub/CLI modules.json. */
+function isComplete(root, fs) {
+    return fs.exists(win.join(root, '.complete.json')) || fs.exists(win.join(root, 'modules.json'));
+}
+export function findEditors(search, fs) {
+    const found = [];
+    for (const m of search.mapped) {
+        const exe = win.join(m.guest, 'Editor', 'Unity.exe');
+        if (UNITY_VERSION.test(m.id) && fs.exists(exe))
+            found.push({
+                version: m.id,
+                root: m.guest,
+                exe,
+                origin: 'pc',
+                writable: false,
+                modules: editorModules(m.guest, fs),
+            });
+    }
+    for (const name of fs.list(search.dataRoot)) {
+        if (name.startsWith('.staging-') || !UNITY_VERSION.test(name))
+            continue;
+        const root = win.join(search.dataRoot, name);
+        const exe = win.join(root, 'Editor', 'Unity.exe');
+        if (isComplete(root, fs) && fs.exists(exe))
+            found.push({ version: name, root, exe, origin: 'data', writable: true, modules: editorModules(root, fs) });
+    }
+    return found;
+}
+/**
+ * The editor for a project: exactly the version it asks for. This PC's (read-only) when it has every module, then the
+ * data disk's, else install it when the licence is accepted. A PC editor that lacks modules is still used when nothing
+ * can be installed.
+ */
+export function chooseEditor(editors, wanted, modules, canInstall) {
+    if (!wanted)
+        return { editor: null, install: null, reason: 'no ProjectSettings/ProjectVersion.txt' };
+    const v = wanted.version;
+    const same = editors.filter((e) => e.version === v);
+    const pc = same.find((e) => e.origin === 'pc');
+    const data = same.find((e) => e.origin === 'data');
+    const missing = (e) => modules.find((m) => !e?.modules.includes(m));
+    const asks = 'the project asks for ' + v;
+    if (pc && missing(pc) === undefined)
+        return { editor: pc, install: null, reason: asks };
+    if (data) {
+        const lack = pc ? missing(pc) : undefined;
+        return {
+            editor: data,
+            install: null,
+            reason: lack === undefined ? asks : v + ' from this PC lacks ' + lack + '; using the data disk copy',
+        };
+    }
+    if (canInstall)
+        return { editor: null, install: wanted, reason: v + ' is not here yet; installing it on the data disk' };
+    if (pc)
+        return { editor: pc, install: null, reason: asks };
+    return {
+        editor: null,
+        install: null,
+        reason: v + ' is not on this PC or the data disk; accept the Unity licence (Unity set-up settings) to install it',
+    };
+}

package/dist/shared/unity/guide.d.ts

@@ -0,0 +1,9 @@
+import type { UnityStatus } from './status.js';
+export interface UnityGuideProject {
+    /** The project's folder in the sandbox. */
+    readonly workspace: string;
+}
+/** The guide's Unity lines for these projects (none when Unity is not set up). */
+export declare function unityGuideLines(status: UnityStatus, projects: readonly UnityGuideProject[]): string[];
+/** One line about a project's editor, for the status the agent and the page show. */
+export declare function unitySummaryLine(status: UnityStatus, workspace: string): string;

package/dist/shared/unity/guide.js

@@ -0,0 +1,84 @@
+// The Unity lines of the sandbox guide (the managed CLAUDE.md and AGENTS.md): which editor each project opens with and
+// the plain commands an agent builds, tests and imports with. Pure, from the status the sandbox wrote (status.ts).
+import path from 'node:path';
+import { ORIGIN_LABELS } from './editors.js';
+const win = path.win32;
+function sameDir(a, b) {
+    return a.toLowerCase() === b.toLowerCase();
+}
+function exeOf(root) {
+    return win.join(root, 'Editor', 'Unity.exe');
+}
+/** The guide's Unity lines for these projects (none when Unity is not set up). */
+export function unityGuideLines(status, projects) {
+    const lines = [];
+    const several = projects.length > 1;
+    let first = null;
+    const bridges = new Set();
+    let withoutBridge = false;
+    for (const p of projects) {
+        const choice = status.projects.find((s) => sameDir(s.workspace, p.workspace));
+        const editor = choice?.editor ? status.editors.find((e) => sameDir(e.root, choice.editor)) : undefined;
+        if (!choice || !editor)
+            continue;
+        const exe = exeOf(editor.root);
+        const name = several ? ' (' + win.basename(p.workspace) + ')' : '';
+        first ??= { exe, workspace: p.workspace };
+        lines.push('- Unity' +
+            name +
+            ': editor ' +
+            editor.version +
+            ' at `' +
+            exe +
+            '` (' +
+            ORIGIN_LABELS[editor.origin] +
+            '; ' +
+            choice.reason +
+            '). Build or run code without opening it: `"' +
+            exe +
+            '" -batchmode -nographics -quit -projectPath "' +
+            p.workspace +
+            '" -executeMethod <Class.Method> -logFile -`; tests: `-runTests -testPlatform EditMode -testResults <file>` (without -quit). Opening the project in another Unity version upgrades its files: never do that without asking the user.' +
+            (editor.writable ? '' : " It is the user's PC copy, read-only: never add modules to it."));
+        if (choice.bridge)
+            bridges.add(choice.bridge);
+        else
+            withoutBridge = true;
+    }
+    if (!lines.length)
+        return lines;
+    if (status.cli)
+        lines.push('- `unity` (Unity CLI ' +
+            status.cli.version +
+            ') is on PATH: `unity editors -i`, `unity build`, `unity test`, `unity open <project>` (opens it signed in).');
+    if (bridges.has('pipeline'))
+        lines.push('- The open editor can be driven with `unity command` and `unity eval` (Unity Pipeline package); MCP clients use sbx-unity.');
+    if (bridges.has('coplay'))
+        lines.push('- The open editor can be driven with MCP for Unity (sbx-unity-mcp in Apps).');
+    if (withoutBridge)
+        lines.push("- To drive a running editor (scenes, GameObjects, play mode) the project needs an editor bridge package: ask the user to add it on the sandbox tool's Unity page. Never change Packages/manifest.json yourself unless asked.");
+    if (status.pcAssets.length && first)
+        lines.push("- The user's Unity Asset Store downloads (read-only): `" +
+            status.pcAssets[0] +
+            '`; import one with the editor closed: `"' +
+            first.exe +
+            '" -batchmode -nographics -quit -projectPath "' +
+            first.workspace +
+            '" -importPackage "<file>"`.' +
+            (status.assetCache.dir ? ' Downloads made here go to `' + status.assetCache.dir + '` (kept).' : ''));
+    if (status.licence.state !== 'active')
+        lines.push('- Unity licence: ' +
+            status.licence.detail +
+            ". Batch mode fails without one: ask the user to sign in to Unity on the sandbox tool's Unity page.");
+    return lines;
+}
+/** One line about a project's editor, for the status the agent and the page show. */
+export function unitySummaryLine(status, workspace) {
+    const choice = status.projects.find((s) => sameDir(s.workspace, workspace));
+    if (!choice)
+        return 'Unity: not set up for this project';
+    const editor = choice.editor ? status.editors.find((e) => sameDir(e.root, choice.editor)) : undefined;
+    return editor
+        ? 'Unity ' + editor.version + ' (' + ORIGIN_LABELS[editor.origin] + '; ' + choice.reason + ')'
+        : 'Unity: no editor (' + choice.reason + ')';
+}

package/dist/shared/unity/index.d.ts

@@ -0,0 +1,9 @@
+export * from './version.js';
+export * from './editors.js';
+export * from './release.js';
+export * from './cli.js';
+export * from './mcp.js';
+export * from './manifest.js';
+export * from './asset-cache.js';
+export * from './status.js';
+export * from './guide.js';

package/dist/shared/unity/index.js

@@ -0,0 +1,11 @@
+// Unity editors, the release API, the Unity CLI, the editor bridge and the Unity status, shared by the sandbox and this
+// PC (pure).
+export * from './version.js';
+export * from './editors.js';
+export * from './release.js';
+export * from './cli.js';
+export * from './mcp.js';
+export * from './manifest.js';
+export * from './asset-cache.js';
+export * from './status.js';
+export * from './guide.js';

package/dist/shared/unity/manifest.d.ts

@@ -0,0 +1,10 @@
+export declare const PIPELINE_PACKAGE = "com.unity.pipeline";
+export declare const COPLAY_PACKAGE = "com.coplaydev.unity-mcp";
+export declare const COPLAY_PACKAGE_URL = "https://github.com/CoplayDev/unity-mcp.git?path=/MCPForUnity#v10.3.0";
+/** The Pipeline version added when none is given (0.10 is the one the plan was written against). */
+export declare const DEFAULT_PIPELINE_VERSION = "0.10.0";
+export type Bridge = 'pipeline' | 'coplay';
+/** Which bridge the project has, or null (also for a file that is not a manifest). */
+export declare function bridgeOf(text: string): Bridge | null;
+/** The manifest with the bridge added or removed: key order, 2-space indent, trailing newline and CRLF kept. */
+export declare function withBridge(text: string, bridge: Bridge, on: boolean, pipelineVersion?: string): string;

package/dist/shared/unity/manifest.js

@@ -0,0 +1,53 @@
+// Packages/manifest.json and the editor bridge: the package that lets `unity command` / `unity eval` (Unity Pipeline,
+// Unity 6 and later) or MCP for Unity (Coplay) drive a running editor. Edited only when the user asks. Pure text.
+export const PIPELINE_PACKAGE = 'com.unity.pipeline';
+export const COPLAY_PACKAGE = 'com.coplaydev.unity-mcp';
+export const COPLAY_PACKAGE_URL = 'https://github.com/CoplayDev/unity-mcp.git?path=/MCPForUnity#v10.3.0';
+/** The Pipeline version added when none is given (0.10 is the one the plan was written against). */
+export const DEFAULT_PIPELINE_VERSION = '0.10.0';
+const MAX_MANIFEST_BYTES = 1024 * 1024;
+const SEMVER = /^\d{1,6}\.\d{1,6}\.\d{1,6}(-[0-9A-Za-z.-]{1,50})?(\+[0-9A-Za-z.-]{1,50})?$/;
+function parseManifest(text) {
+    if (Buffer.byteLength(text) > MAX_MANIFEST_BYTES)
+        throw new Error('Packages/manifest.json is over 1 MB');
+    const json = JSON.parse(text.replace(/^\uFEFF/, ''));
+    if (typeof json !== 'object' || json === null || Array.isArray(json))
+        throw new Error('Packages/manifest.json is not an object');
+    const m = json;
+    if (m.dependencies !== undefined &&
+        (typeof m.dependencies !== 'object' || m.dependencies === null || Array.isArray(m.dependencies)))
+        throw new Error('Packages/manifest.json: dependencies is not an object');
+    return m;
+}
+/** Which bridge the project has, or null (also for a file that is not a manifest). */
+export function bridgeOf(text) {
+    try {
+        const deps = parseManifest(text).dependencies ?? {};
+        if (PIPELINE_PACKAGE in deps)
+            return 'pipeline';
+        if (COPLAY_PACKAGE in deps)
+            return 'coplay';
+        return null;
+    }
+    catch {
+        // Not JSON or not a manifest: no bridge to report.
+        return null;
+    }
+}
+/** The manifest with the bridge added or removed: key order, 2-space indent, trailing newline and CRLF kept. */
+export function withBridge(text, bridge, on, pipelineVersion) {
+    const m = parseManifest(text);
+    const name = bridge === 'pipeline' ? PIPELINE_PACKAGE : COPLAY_PACKAGE;
+    if (on) {
+        const version = pipelineVersion ?? DEFAULT_PIPELINE_VERSION;
+        if (bridge === 'pipeline' && !SEMVER.test(version))
+            throw new Error('not a package version: ' + version);
+        const deps = (m.dependencies ??= {});
+        deps[name] = bridge === 'pipeline' ? version : COPLAY_PACKAGE_URL;
+    }
+    else if (m.dependencies) {
+        delete m.dependencies[name];
+    }
+    const out = JSON.stringify(m, null, 2) + '\n';
+    return text.includes('\r\n') ? out.replace(/\n/g, '\r\n') : out;
+}

package/dist/shared/unity/mcp.d.ts

@@ -0,0 +1,8 @@
+export declare const UNITY_MCP_NAME = "sbx-unity";
+export interface UnityMcpServer {
+    readonly type: 'stdio';
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly env: Readonly<Record<string, string>>;
+}
+export declare function unityCliMcpServer(unityExe: string, projectPath: string | null): UnityMcpServer;

package/dist/shared/unity/mcp.js

@@ -0,0 +1,12 @@
+// The Unity CLI as an MCP server (`unity mcp --cli-tools`, stdio) for Claude Code and Codex. Read-only tools always;
+// the open editor's tools when the project has the Unity Pipeline package.
+import { UNITY_CLI_ENV } from './cli.js';
+export const UNITY_MCP_NAME = 'sbx-unity';
+export function unityCliMcpServer(unityExe, projectPath) {
+    return {
+        type: 'stdio',
+        command: unityExe,
+        args: ['mcp', '--cli-tools'],
+        env: { ...UNITY_CLI_ENV, ...(projectPath ? { UNITY_PROJECT_PATH: projectPath } : {}) },
+    };
+}

package/dist/shared/unity/release.d.ts

@@ -0,0 +1,28 @@
+/** The request for one editor version (Windows, x86_64, one result). */
+export declare function releaseUrl(version: string): string;
+export interface UnityRelease {
+    readonly version: string;
+    readonly changeset: string;
+    readonly editor: {
+        readonly url: string;
+        /** As Unity writes it: "md5-<base64>". */
+        readonly integrity: string | null;
+        readonly downloadBytes: number;
+        readonly installedBytes: number;
+    };
+    readonly modules: readonly {
+        readonly id: string;
+        readonly downloadBytes: number;
+        readonly installedBytes: number;
+        readonly integrity: string | null;
+        /** The ids of its sub-modules (android: the SDK, NDK and OpenJDK parts). */
+        readonly children: readonly string[];
+        /** The sub-modules' sizes together. */
+        readonly childDownloadBytes: number;
+        readonly childInstalledBytes: number;
+    }[];
+}
+/** The first release an API answer holds (the EXE installer), or null when it holds none or has another shape. */
+export declare function pickRelease(json: unknown): UnityRelease | null;
+/** Room an install needs: (editor download + installed + the chosen modules with their children) plus 10%. */
+export declare function installNeedBytes(r: UnityRelease, modules: readonly string[]): number;

package/dist/shared/unity/release.js

@@ -0,0 +1,83 @@
+// Unity's release API (services.api.unity.com): the editor installer, its changeset and its modules for one version.
+// The answer is untrusted JSON: it is parsed with zod, every list and text bounded.
+import { z } from 'zod';
+import { UNITY_CHANGESET } from './version.js';
+const API = 'https://services.api.unity.com/unity/editor/release/v1/releases';
+const MARGIN = 1.1;
+/** The request for one editor version (Windows, x86_64, one result). */
+export function releaseUrl(version) {
+    return API + '?version=' + encodeURIComponent(version) + '&platform=WINDOWS&architecture=X86_64&limit=1';
+}
+const Size = z.object({ value: z.number().min(0) });
+const Text = (max) => z.string().max(max);
+const SubModule = z.lazy(() => z.object({
+    id: z.string().regex(/^[A-Za-z0-9._-]{1,80}$/),
+    downloadSize: Size.optional(),
+    installedSize: Size.optional(),
+    integrity: Text(200).optional(),
+    subModules: z.array(SubModule).max(50).optional(),
+}));
+const ReleaseResponseSchema = z.object({
+    results: z
+        .array(z.object({
+        version: Text(40),
+        shortRevision: z.string().regex(UNITY_CHANGESET),
+        downloads: z
+            .array(z.object({
+            url: z.string().url().max(2000).startsWith('https://'),
+            type: Text(20),
+            integrity: Text(200).optional(),
+            downloadSize: Size,
+            installedSize: Size,
+            modules: z.array(SubModule).max(200).default([]),
+        }))
+            .min(1)
+            .max(10),
+    }))
+        .max(10),
+});
+function flatten(m, depth = 0) {
+    if (depth > 3)
+        return [];
+    return (m.subModules ?? []).flatMap((s) => [s, ...flatten(s, depth + 1)]);
+}
+/** The first release an API answer holds (the EXE installer), or null when it holds none or has another shape. */
+export function pickRelease(json) {
+    const parsed = ReleaseResponseSchema.safeParse(json);
+    if (!parsed.success)
+        return null;
+    const r = parsed.data.results[0];
+    const d = r?.downloads.find((x) => x.type.toUpperCase() === 'EXE') ?? r?.downloads[0];
+    if (!r || !d)
+        return null;
+    return {
+        version: r.version,
+        changeset: r.shortRevision,
+        editor: {
+            url: d.url,
+            integrity: d.integrity ?? null,
+            downloadBytes: d.downloadSize.value,
+            installedBytes: d.installedSize.value,
+        },
+        modules: d.modules.map((m) => {
+            const kids = flatten(m);
+            return {
+                id: m.id,
+                downloadBytes: m.downloadSize?.value ?? 0,
+                installedBytes: m.installedSize?.value ?? 0,
+                integrity: m.integrity ?? null,
+                children: kids.map((k) => k.id),
+                childDownloadBytes: kids.reduce((n, k) => n + (k.downloadSize?.value ?? 0), 0),
+                childInstalledBytes: kids.reduce((n, k) => n + (k.installedSize?.value ?? 0), 0),
+            };
+        }),
+    };
+}
+/** Room an install needs: (editor download + installed + the chosen modules with their children) plus 10%. */
+export function installNeedBytes(r, modules) {
+    let bytes = r.editor.downloadBytes + r.editor.installedBytes;
+    for (const m of r.modules)
+        if (modules.includes(m.id))
+            bytes += m.downloadBytes + m.installedBytes + m.childDownloadBytes + m.childInstalledBytes;
+    return Math.ceil(bytes * MARGIN);
+}

package/dist/shared/unity/status.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+/** The file in tools\unity. */
+export declare const UNITY_STATUS_FILE = "status.json";
+export declare const UnityStatusSchema: z.ZodObject<{
+    updatedAt: z.ZodString;
+    cli: z.ZodNullable<z.ZodObject<{
+        version: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strip>>;
+    editors: z.ZodArray<z.ZodObject<{
+        version: z.ZodString;
+        root: z.ZodString;
+        origin: z.ZodEnum<{
+            pc: "pc";
+            data: "data";
+        }>;
+        writable: z.ZodBoolean;
+        modules: z.ZodArray<z.ZodString>;
+        sizeBytes: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    projects: z.ZodArray<z.ZodObject<{
+        workspace: z.ZodString;
+        version: z.ZodNullable<z.ZodString>;
+        editor: z.ZodNullable<z.ZodString>;
+        reason: z.ZodString;
+        bridge: z.ZodNullable<z.ZodEnum<{
+            pipeline: "pipeline";
+            coplay: "coplay";
+        }>>;
+    }, z.core.$strip>>;
+    licence: z.ZodObject<{
+        state: z.ZodEnum<{
+            unknown: "unknown";
+            none: "none";
+            active: "active";
+            invalid: "invalid";
+        }>;
+        kind: z.ZodString;
+        detail: z.ZodString;
+        user: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    assetCache: z.ZodObject<{
+        mode: z.ZodEnum<{
+            pc: "pc";
+            persisted: "persisted";
+            local: "local";
+        }>;
+        dir: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    pcAssets: z.ZodArray<z.ZodString>;
+    hub: z.ZodObject<{
+        installed: z.ZodBoolean;
+        path: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    mcp: z.ZodNullable<z.ZodString>;
+    skills: z.ZodBoolean;
+    problem: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type UnityStatus = z.infer<typeof UnityStatusSchema>;

package/dist/shared/unity/status.js

@@ -0,0 +1,45 @@
+// What the sandbox last found for Unity (tools\unity\status.json): the CLI, the editors, which editor each project
+// opens with, the licence, the Asset Store cache. The sandbox writes it; the Unity page on this PC reads it with this
+// schema (bounded strings and lists) and prints its text through safeText.
+import { z } from 'zod';
+/** The file in tools\unity. */
+export const UNITY_STATUS_FILE = 'status.json';
+const Text = (max = 400) => z.string().max(max);
+export const UnityStatusSchema = z.object({
+    updatedAt: Text(40),
+    cli: z.object({ version: Text(40), path: Text() }).nullable(),
+    editors: z
+        .array(z.object({
+        version: Text(40),
+        root: Text(),
+        origin: z.enum(['pc', 'data']),
+        writable: z.boolean(),
+        modules: z.array(Text(60)).max(20),
+        sizeBytes: z.number().int().min(0).nullable(),
+    }))
+        .max(32),
+    projects: z
+        .array(z.object({
+        workspace: Text(),
+        /** The version its ProjectVersion.txt asks for. */
+        version: Text(40).nullable(),
+        /** The root of the editor it opens with, null when there is none for it. */
+        editor: Text().nullable(),
+        reason: Text(),
+        bridge: z.enum(['pipeline', 'coplay']).nullable(),
+    }))
+        .max(64),
+    licence: z.object({
+        state: z.enum(['active', 'none', 'invalid', 'unknown']),
+        kind: Text(60),
+        detail: Text(),
+        user: Text(256).nullable(),
+    }),
+    assetCache: z.object({ mode: z.enum(['persisted', 'pc', 'local']), dir: Text().nullable() }),
+    pcAssets: z.array(Text()).max(4),
+    hub: z.object({ installed: z.boolean(), path: Text().nullable() }),
+    /** The MCP server's name when it was registered. */
+    mcp: Text(100).nullable(),
+    skills: z.boolean(),
+    problem: Text(600).nullable(),
+});

package/dist/shared/unity/version.d.ts

@@ -0,0 +1,27 @@
+export declare const UNITY_VERSION: RegExp;
+/** A changeset (short revision) as Unity prints it. */
+export declare const UNITY_CHANGESET: RegExp;
+export interface UnityVersion {
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+    /** a (alpha), b (beta), f (final), p (patch). */
+    readonly stage: 'a' | 'b' | 'f' | 'p';
+    readonly build: number;
+}
+export declare function parseUnityVersion(text: string): UnityVersion | null;
+/** Negative when a is older than b, 0 when equal; an unreadable version sorts first. */
+export declare function compareUnityVersions(a: string, b: string): number;
+export interface ProjectVersion {
+    readonly version: string;
+    readonly changeset: string | null;
+}
+/** The editor a ProjectVersion.txt asks for: m_EditorVersion, and the changeset of m_EditorVersionWithRevision. */
+export declare function parseProjectVersion(text: string): ProjectVersion | null;
+/**
+ * The editor to open a project with: its own ProjectVersion.txt always wins (another version upgrades its files); the
+ * setting's version ("project" or e.g. "6000.0.32f1") is only for folders without one.
+ */
+export declare function wantedVersion(projectFile: string | null, setting: string): ProjectVersion | null;
+/** The Unity Pipeline package (and so `unity command` / `unity eval`) needs Unity 6 or later. */
+export declare function supportsPipeline(version: string): boolean;

package/dist/shared/unity/version.js

@@ -0,0 +1,75 @@
+// Unity editor versions ("6000.0.58f2") and the ProjectSettings/ProjectVersion.txt that names one. Pure; the text read
+// from a project is bounded (the first 50 lines of at most 64 KB).
+export const UNITY_VERSION = /^(\d{1,4})\.(\d{1,3})\.(\d{1,3})([abfp])(\d{1,3})$/;
+/** A changeset (short revision) as Unity prints it. */
+export const UNITY_CHANGESET = /^[0-9a-f]{12}$/;
+const MAX_PROJECT_VERSION_BYTES = 64 * 1024;
+const MAX_PROJECT_VERSION_LINES = 50;
+const STAGES = 'abfp';
+export function parseUnityVersion(text) {
+    const m = UNITY_VERSION.exec(text);
+    if (!m)
+        return null;
+    return {
+        major: Number(m[1]),
+        minor: Number(m[2]),
+        patch: Number(m[3]),
+        stage: m[4],
+        build: Number(m[5]),
+    };
+}
+/** Negative when a is older than b, 0 when equal; an unreadable version sorts first. */
+export function compareUnityVersions(a, b) {
+    const x = parseUnityVersion(a);
+    const y = parseUnityVersion(b);
+    if (!x || !y)
+        return x ? 1 : y ? -1 : a.localeCompare(b);
+    return (x.major - y.major ||
+        x.minor - y.minor ||
+        x.patch - y.patch ||
+        STAGES.indexOf(x.stage) - STAGES.indexOf(y.stage) ||
+        x.build - y.build);
+}
+/** The editor a ProjectVersion.txt asks for: m_EditorVersion, and the changeset of m_EditorVersionWithRevision. */
+export function parseProjectVersion(text) {
+    let version = null;
+    let changeset = null;
+    const lines = text.slice(0, MAX_PROJECT_VERSION_BYTES).split('\n', MAX_PROJECT_VERSION_LINES);
+    for (const raw of lines) {
+        const line = raw.replace(/^\uFEFF/, '').trim();
+        if (line.startsWith('m_EditorVersionWithRevision:')) {
+            const rest = line.slice('m_EditorVersionWithRevision:'.length).trim();
+            const open = rest.indexOf('(');
+            const close = rest.indexOf(')', open);
+            const v = (open < 0 ? rest : rest.slice(0, open)).trim();
+            if (UNITY_VERSION.test(v))
+                version ??= v;
+            if (open >= 0 && close > open) {
+                const cs = rest.slice(open + 1, close).trim();
+                if (UNITY_CHANGESET.test(cs))
+                    changeset = cs;
+            }
+        }
+        else if (line.startsWith('m_EditorVersion:')) {
+            const v = line.slice('m_EditorVersion:'.length).trim();
+            if (UNITY_VERSION.test(v))
+                version = v;
+        }
+    }
+    return version ? { version, changeset } : null;
+}
+/**
+ * The editor to open a project with: its own ProjectVersion.txt always wins (another version upgrades its files); the
+ * setting's version ("project" or e.g. "6000.0.32f1") is only for folders without one.
+ */
+export function wantedVersion(projectFile, setting) {
+    const own = projectFile === null ? null : parseProjectVersion(projectFile);
+    if (own)
+        return own;
+    return setting !== 'project' && UNITY_VERSION.test(setting) ? { version: setting, changeset: null } : null;
+}
+/** The Unity Pipeline package (and so `unity command` / `unity eval`) needs Unity 6 or later. */
+export function supportsPipeline(version) {
+    const v = parseUnityVersion(version);
+    return v !== null && v.major >= 6000;
+}

package/dist/web/index.html

@@ -6,7 +6,7 @@
     <title>Sandbox</title>
     <link rel="icon" href="data:," />
     <link rel="stylesheet" href="/main-XT7T6ODM.css" />
-    <script type="module" src="/main-FNE6XEHA.js"></script>
+    <script type="module" src="/main-VPMYTSUL.js"></script>
   </head>
   <body>
     <div id="root"></div>