@bitmagic/cli 0.1.71-dev.0 → 0.1.71-dev.1

package/assets/roblox-port/tests/studio-mock.luau

@@ -0,0 +1,109 @@
+-- Local behavioral model only: this does not replace a native Studio integration test.
+local function newStudio()
+    local methods = {}
+    local objects = {}
+    local model = { running = false, writes = 0, failWrite = nil, beforeWrite = nil }
+    local function newObject(className)
+        local object = { _props = { ClassName = className, Name = className, Source = "", Enabled = true, Archivable = true, RunContext = "Legacy", LinkedSource = "" }, _attributes = {}, _tags = {} }
+        setmetatable(object, {
+            __index = function(self, key) return methods[key] or self._props[key] end,
+            __newindex = function(self, key, value) self._props[key] = value end,
+        })
+        table.insert(objects, object)
+        return object
+    end
+    function methods:IsA(className)
+        if className == self.ClassName then return true end
+        local script = self.ClassName == "Script" or self.ClassName == "LocalScript"
+        return (className == "BaseScript" and script) or (className == "LuaSourceContainer" and (script or self.ClassName == "ModuleScript"))
+    end
+    function methods:GetChildren()
+        local children = {}
+        for _, object in ipairs(objects) do if object.Parent == self then table.insert(children, object) end end
+        return children
+    end
+    function methods:GetDescendants()
+        local result = {}
+        local function visit(parent)
+            for _, child in ipairs(parent:GetChildren()) do table.insert(result, child); visit(child) end
+        end
+        visit(self)
+        return result
+    end
+    function methods:SetAttribute(key, value) self._attributes[key] = value end
+    function methods:GetAttribute(key) return self._attributes[key] end
+    function methods:GetAttributes() return table.clone(self._attributes) end
+    function methods:AddTag(tag) self._tags[tag] = true end
+    function methods:RemoveTag(tag) self._tags[tag] = nil end
+    function methods:GetTags()
+        local tags = {}
+        for tag in pairs(self._tags) do table.insert(tags, tag) end
+        return tags
+    end
+    function methods:GetFullName()
+        return self.Parent and self.Parent:GetFullName() .. "." .. self.Name or self.Name
+    end
+    function methods:Destroy()
+        for _, child in ipairs(self:GetChildren()) do child:Destroy() end
+        self.Parent = nil
+    end
+    local root = newObject("DataModel")
+    root.PlaceId = 0; root.GameId = 0; root.CreatorId = 42; root.CreatorType = { Name = "User" }
+    local services = {}
+    local function encodePrimitive(value)
+        if type(value) ~= "string" then return tostring(value) end
+        local escaped = value:gsub('[%z\1-\31\\"]', function(character)
+            if character == '"' then return '\\"' end
+            if character == "\\" then return "\\\\" end
+            return string.format("\\u%04x", string.byte(character))
+        end)
+        return '"' .. escaped .. '"'
+    end
+    services.HttpService = { JSONEncode = function(_, value) return encodePrimitive(value) end }
+    services.RunService = { IsRunning = function() return model.running end }
+    services.ScriptEditorService = {
+        GetEditorSource = function(_, object) return object.Buffer or object.Source end,
+        UpdateSourceAsync = function(_, object, callback)
+            model.writes += 1
+            if model.writes == model.failWrite then error("Injected source failure") end
+            if model.beforeWrite then model.beforeWrite(object) end
+            local output = callback(object.Buffer or object.Source)
+            object.Source = output
+            if object.Buffer then object.Buffer = output end
+            if model.afterWrite then model.afterWrite(object) end
+        end,
+    }
+    function methods:GetService(name)
+        if not services[name] then
+            local object = newObject(name)
+            object.Parent = root
+            services[name] = object
+        end
+        return services[name]
+    end
+    function model:at(parts)
+        local object = root:GetService(parts[1])
+        for i = 2, #parts do
+            local nextObject = nil
+            for _, child in ipairs(object:GetChildren()) do if child.Name == parts[i] then nextObject = child end end
+            if not nextObject then return nil end
+            object = nextObject
+        end
+        return object
+    end
+    function model:add(className, parts, source)
+        local parent = root:GetService(parts[1])
+        for i = 2, #parts - 1 do
+            local prefix = {}; for j = 1, i do table.insert(prefix, parts[j]) end
+            local child = self:at(prefix)
+            if not child then child = newObject("Folder"); child.Name = parts[i]; child.Parent = parent end
+            parent = child
+        end
+        local object = newObject(className)
+        object.Name = parts[#parts]; object.Source = source or ""; object.Parent = parent
+        return object
+    end
+    model.game = root
+    model.Instance = { new = newObject }
+    return model
+end

package/assets/roblox-port/tests/studio-runtime.test.mjs

@@ -0,0 +1,309 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { init, prepare, accept, acceptRollback } from '../port-state.mjs';
+import { loadProject, writeJson, validateSnapshot, verifyReadback } from '../lib.mjs';
+import { longString } from '../build-studio-update.mjs';
+
+// Opt in with an installed official interpreter. Tests never download or install tools.
+const luau = process.env.LUAU_BIN;
+const runtime = fs.readFileSync(new URL('../studio-runtime.luau', import.meta.url), 'utf8');
+const mock = fs.readFileSync(new URL('./studio-mock.luau', import.meta.url), 'utf8');
+function literal(value) {
+  if (value === null) return 'nil';
+  if (typeof value === 'string') return longString(value);
+  if (Array.isArray(value)) return `{${value.map(literal).join(',')}}`;
+  if (typeof value === 'object') return `{${Object.entries(value).map(([k, v]) => `[ ${literal(k)} ]=${literal(v)}`).join(',')}}`;
+  return String(value);
+}
+function fixture(t) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'roblox-luau-'));
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+  const source = path.join(dir, 'source'), root = path.join(dir, 'port');
+  fs.mkdirSync(source);
+  writeJson(path.join(source, 'bitmagic.json'), { gameId: 'local-test', engineVersion: 'test', environment: 'dev' });
+  init(source, root);
+  fs.writeFileSync(path.join(root, 'generated/shared/Rules.luau'), 'return { damage = 10 }\n');
+  fs.writeFileSync(path.join(root, 'generated/server/Main.luau'), 'print("fixture")\n');
+  writeJson(path.join(root, 'incoming.json'), { schemaVersion: 1, sourceFiles: ['bitmagic.json'], scripts: [
+    { id: 'rules', className: 'ModuleScript', path: ['ReplicatedStorage', 'Port', 'Rules'], file: 'generated/shared/Rules.luau' },
+    { id: 'main', className: 'Script', path: ['ServerScriptService', 'Port', 'Main'], file: 'generated/server/Main.luau', enabled: true },
+  ] });
+  const live = { schemaVersion: 1, mode: 'Edit', target: { projectId: null, targetId: null, placeId: '0', universeId: '0', creatorId: '42', creatorType: 'User' }, buildId: null, pendingRun: null, scripts: [] };
+  const run = path.join(dir, 'run'), plan = prepare(root, live, run, { bind: true });
+  return { dir, root, run, plan, live, project: loadProject(root) };
+}
+function execute(f, body) {
+  const file = path.join(f.dir, 'execution.luau');
+  const source = `${mock}\nlocal model = newStudio()\nlocal game, Instance = model.game, model.Instance\nlocal plan = ${literal(f.plan)}\nlocal project = plan.project\nlocal function operation(action, selectedPlan)\nlocal request = {action=action, project=project, plan=selectedPlan or plan, paths={}}\nfor _, s in ipairs(request.plan.generated) do table.insert(request.paths, s.path) end\nfor _, s in ipairs(request.plan.desired) do table.insert(request.paths, s.path) end\n${runtime}\nend\n${body}`;
+  fs.writeFileSync(file, source);
+  const result = spawnSync(luau, [file], { encoding: 'utf8', timeout: 15000 });
+  assert.equal(result.error, undefined);
+  assert.equal(result.status, 0, result.stderr);
+  return result.stdout.trim().split('\n').filter(Boolean).map(line => JSON.parse(line));
+}
+test('Luau applies exact sources, replays, preserves native content and rolls back', { skip: !luau }, t => {
+  const f = fixture(t);
+  const [before, applied, replayed, rolledBack] = execute(f, `
+local native = model:add("Part", {"Workspace", "CreatorArt"}); native.Color = "purple"
+print(operation("inspect"))
+print(operation("apply"))
+assert(model:at({"ServerScriptService", "Port", "Main"}).Enabled == true)
+local writes = model.writes
+print(operation("apply"))
+assert(model.writes == writes)
+print(operation("rollback"))
+assert(native.Parent == game:GetService("Workspace") and native.Color == "purple")
+assert(model:at({"ReplicatedStorage", "Port"}) == nil)
+`);
+  assert.deepEqual(before, f.live);
+  validateSnapshot(applied); verifyReadback(f.plan, applied); verifyReadback(f.plan, replayed);
+  accept(f.root, f.run, applied);
+  acceptRollback(f.root, f.run, rolledBack);
+});
+test('Luau refuses Play, wrong targets and unowned collisions before mutation', { skip: !luau }, t => {
+  const f = fixture(t);
+  const [snapshot] = execute(f, `
+model.running = true
+local ok, err = pcall(function() operation("apply") end); assert(not ok and string.find(err, "PLAY_ACTIVE"))
+model.running = false; game.PlaceId = 123
+ok, err = pcall(function() operation("apply") end); assert(not ok and string.find(err, "TARGET_MISMATCH"))
+game.PlaceId = 0
+local other = model:add("ModuleScript", {"ReplicatedStorage", "Port", "Rules"}, "creator source")
+ok = pcall(function() operation("apply") end); assert(not ok and other.Source == "creator source")
+assert(game:GetAttribute("BitmagicPendingRun") == nil and model.writes == 0)
+other:Destroy()
+local extra = model:add("ModuleScript", {"ReplicatedStorage", "CreatorExtra"}, "new managed code")
+extra:SetAttribute("BitmagicTargetId", project.targetId); extra:SetAttribute("BitmagicSourceId", "extra")
+ok, err = pcall(function() operation("apply") end); assert(not ok and string.find(err, "script set changed"))
+assert(model.writes == 0 and game:GetAttribute("BitmagicPendingRun") == nil)
+extra:Destroy()
+print(operation("inspect"))
+`);
+  assert.deepEqual(snapshot, f.live);
+});
+test('forward replay finishes an interrupted build commit without rewriting sources', { skip: !luau }, t => {
+  const f = fixture(t);
+  const [replayed] = execute(f, `
+operation("apply")
+game:SetAttribute("BitmagicPendingRun", plan.runId)
+local writes = model.writes
+print(operation("apply"))
+assert(model.writes == writes)
+`);
+  verifyReadback(f.plan, replayed);
+});
+test('Luau resumes an interrupted source batch and can restore the original snapshot', { skip: !luau }, t => {
+  const f = fixture(t);
+  const [applied, rolledBack] = execute(f, `
+model.failWrite = 2
+local ok = pcall(function() operation("apply") end); assert(not ok)
+assert(game:GetAttribute("BitmagicPendingRun") == plan.runId)
+assert(model:at({"ServerScriptService", "Port", "Main"}).Enabled == false)
+model.failWrite = nil
+print(operation("apply"))
+print(operation("rollback"))
+`);
+  verifyReadback(f.plan, applied); acceptRollback(f.root, f.run, rolledBack);
+});
+test('Luau protects concurrent editor buffer changes and later rollback edits', { skip: !luau }, t => {
+  const f = fixture(t);
+  const [receipt] = execute(f, `
+model.beforeWrite = function(object) object.Buffer = "human unsaved edit" end
+local ok, err = pcall(function() operation("apply") end)
+assert(not ok and string.find(err, "EDIT_CONFLICT"))
+model.beforeWrite = nil
+local object = model:at({"ReplicatedStorage", "Port", "Rules"})
+assert(object.Buffer == "human unsaved edit")
+print(operation("rollback"))
+assert(object.Buffer == "human unsaved edit" and object.Parent ~= nil)
+`);
+  assert.equal(receipt.stage, 'rollback-incomplete');
+  assert.ok(receipt.failures.length > 0);
+  assert.equal(receipt.snapshot.pendingRun, `rollback:${f.plan.runId}`);
+  assert.throws(() => acceptRollback(f.root, f.run, receipt), /incomplete/);
+});
+test('committed builds treat a later disable or source revert as a human edit', { skip: !luau }, t => {
+  const f = fixture(t);
+  const [receipt, retry] = execute(f, `
+operation("apply")
+local script = model:at({"ServerScriptService", "Port", "Main"})
+script.Enabled = false
+local module = model:at({"ReplicatedStorage", "Port", "Rules"})
+module.Buffer = ""
+local writes = model.writes
+local ok = pcall(function() operation("apply") end)
+assert(not ok and model.writes == writes)
+print(operation("rollback"))
+print(operation("rollback"))
+assert(script.Parent ~= nil and script.Enabled == false and module.Buffer == "")
+`);
+  assert.equal(receipt.stage, 'rollback-incomplete');
+  assert.equal(receipt.failures.length, 2);
+  assert.equal(retry.stage, 'rollback-incomplete');
+  assert.equal(retry.failures.length, 2);
+});
+test('Luau adoption uses editor buffers and restores original ownership', { skip: !luau }, t => {
+  const f = fixture(t);
+  const generated = f.plan.generated;
+  f.live.scripts = generated.map(s => ({ ...s, id: null, owner: null, runId: null }));
+  f.run = path.join(f.dir, 'adopt'); f.plan = prepare(f.root, f.live, f.run, { bind: true, adopt: true });
+  const [applied, rollback] = execute(f, `
+for _, before in ipairs(plan.snapshot.scripts) do
+    local object = model:add(before.className, before.path, "stale persisted source")
+    object.Buffer = before.source
+    if object:IsA("BaseScript") then object.Enabled = before.enabled end
+end
+print(operation("apply"))
+print(operation("rollback"))
+`);
+  verifyReadback(f.plan, applied); acceptRollback(f.root, f.run, rollback);
+});
+test('Luau updates and renames managed code while retaining children and unchanged scripts', { skip: !luau }, t => {
+  const f = fixture(t);
+  const [first] = execute(f, 'print(operation("apply"))');
+  accept(f.root, f.run, first);
+  fs.writeFileSync(path.join(f.root, 'generated/shared/Rules.luau'), 'return { damage = 12 }\n');
+  const manifestFile = path.join(f.root, 'incoming.json');
+  const manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
+  manifest.scripts[0].path = ['ReplicatedStorage', 'Port', 'NewRules'];
+  writeJson(manifestFile, manifest);
+  f.run = path.join(f.dir, 'update'); f.plan = prepare(f.root, first, f.run);
+  const [applied, rollback] = execute(f, `
+for key, value in pairs({BitmagicProjectId=plan.targetBefore.projectId, BitmagicTargetId=plan.targetBefore.targetId, BitmagicBuildId=plan.buildBefore}) do game:SetAttribute(key, value) end
+for _, before in ipairs(plan.snapshot.scripts) do
+    local object = model:add(before.className, before.path, before.source)
+    object:SetAttribute("BitmagicSourceId", before.id); object:SetAttribute("BitmagicTargetId", before.owner); object:SetAttribute("BitmagicRunId", before.runId)
+    if object:IsA("BaseScript") then object.Enabled = before.enabled end
+end
+local native = model:add("StringValue", {"ReplicatedStorage", "Port", "Rules", "CreatorNote"})
+print(operation("apply"))
+assert(model.writes == 1 and native.Parent == model:at({"ReplicatedStorage", "Port", "NewRules"}))
+print(operation("rollback"))
+assert(native.Parent == model:at({"ReplicatedStorage", "Port", "Rules"}))
+`);
+  verifyReadback(f.plan, applied); accept(f.root, f.run, applied); acceptRollback(f.root, f.run, rollback);
+});
+
+for (const [name, change, preserved] of [
+  ['attribute', 'script:SetAttribute("CreatorRewardId", "keep-me")', 'script:GetAttribute("CreatorRewardId") == "keep-me"'],
+  ['tag', 'script:AddTag("CreatorFeature")', '#script:GetTags() == 1'],
+  ['Archivable', 'script.Archivable = false', 'script.Archivable == false'],
+  ['RunContext', 'script.RunContext = "Client"', 'script.RunContext == "Client"'],
+  ['LinkedSource', 'script.LinkedSource = "rbxassetid://42"', 'script.LinkedSource == "rbxassetid://42"'],
+]) test(`rollback preserves a new script's creator ${name}`, { skip: !luau }, t => {
+  const f = fixture(t);
+  const [receipt, retry] = execute(f, `
+operation("apply")
+local script = model:at({"ServerScriptService", "Port", "Main"})
+${change}
+print(operation("rollback"))
+print(operation("rollback"))
+assert(script.Parent ~= nil and ${preserved})
+`);
+  for (const result of [receipt, retry]) {
+    assert.equal(result.stage, 'rollback-incomplete');
+    assert.equal(result.snapshot.pendingRun, `rollback:${f.plan.runId}`);
+    assert.equal(result.failures.length, 1);
+  }
+});
+
+for (const [name, change, preserved] of [
+  ['attribute', 'folder:SetAttribute("CreatorFolder", true)', 'folder:GetAttribute("CreatorFolder") == true'],
+  ['tag', 'folder:AddTag("KeepFolder")', '#folder:GetTags() == 1'],
+  ['Archivable', 'folder.Archivable = false', 'folder.Archivable == false'],
+  ['rename', 'model:at({"ServerScriptService", "Port", "Main"}):Destroy(); folder.Name = "CreatorFolder"', 'folder.Name == "CreatorFolder"'],
+]) test(`rollback preserves an empty created folder's creator ${name}`, { skip: !luau }, t => {
+  const f = fixture(t);
+  const [receipt] = execute(f, `
+operation("apply")
+local folder = model:at({"ServerScriptService", "Port"})
+${change}
+print(operation("rollback"))
+assert(folder.Parent ~= nil and #folder:GetChildren() == 0 and ${preserved})
+`);
+  assert.equal(receipt.stage, 'rollback-incomplete');
+  assert.equal(receipt.failures.length, 1);
+  assert.equal(receipt.snapshot.pendingRun, `rollback:${f.plan.runId}`);
+});
+
+const seedBefore = `
+for key, value in pairs({BitmagicProjectId=plan.targetBefore.projectId, BitmagicTargetId=plan.targetBefore.targetId, BitmagicBuildId=plan.buildBefore}) do game:SetAttribute(key, value) end
+for _, before in ipairs(plan.snapshot.scripts) do
+    local object = model:add(before.className, before.path, before.source)
+    object:SetAttribute("BitmagicSourceId", before.id); object:SetAttribute("BitmagicTargetId", before.owner); object:SetAttribute("BitmagicRunId", before.runId)
+    if object:IsA("BaseScript") then object.Enabled = before.enabled end
+end
+`;
+test('source updates and rollback preserve creator names with spaces and Unicode', { skip: !luau }, t => {
+  const f = fixture(t);
+  const [first] = execute(f, 'print(operation("apply"))');
+  accept(f.root, f.run, first);
+  first.scripts.find(s => s.id === 'rules').path = ['ReplicatedStorage', "Creator's Folder", 'Combat Rules — sääntö'];
+  fs.writeFileSync(path.join(f.root, 'generated/shared/Rules.luau'), 'return { damage = 12 }\n');
+  f.run = path.join(f.dir, 'renamed-update'); f.plan = prepare(f.root, first, f.run);
+  assert.equal(f.plan.conflicts.length, 0);
+  const [applied, restored] = execute(f, `${seedBefore}\nprint(operation("apply"))\nprint(operation("rollback"))`);
+  verifyReadback(f.plan, applied);
+  assert.deepEqual(applied.scripts.find(s => s.id === 'rules').path, first.scripts.find(s => s.id === 'rules').path);
+  accept(f.root, f.run, applied); acceptRollback(f.root, f.run, restored);
+});
+function updateFixture(t) {
+  const f = fixture(t);
+  const [first] = execute(f, 'print(operation("apply"))');
+  accept(f.root, f.run, first);
+  fs.writeFileSync(path.join(f.root, 'generated/shared/Rules.luau'), 'return { damage = 12 }\n');
+  fs.writeFileSync(path.join(f.root, 'generated/server/Main.luau'), 'print("new main")\n');
+  f.run = path.join(f.dir, 'update'); f.plan = prepare(f.root, first, f.run);
+  return f;
+}
+test('partial rollback blocks new plans and forward replay until recovery completes', { skip: !luau }, t => {
+  const f = updateFixture(t);
+  const [applied, partial, retry, restored] = execute(f, `${seedBefore}
+print(operation("apply"))
+local rules = model:at({"ReplicatedStorage", "Port", "Rules"})
+rules.Buffer = "human customization"
+print(operation("rollback"))
+local oldMain
+for _, before in ipairs(plan.snapshot.scripts) do if before.id == "main" then oldMain = before.source end end
+assert(model:at({"ServerScriptService", "Port", "Main"}).Source == oldMain)
+local writes = model.writes
+local ok, err = pcall(function() operation("apply") end)
+assert(not ok and string.find(err, "ROLLBACK_PENDING") and model.writes == writes)
+print(operation("rollback"))
+assert(rules.Buffer == "human customization")
+-- Simulate explicit resolution by putting the conflicted buffer back to the applied source.
+rules.Buffer = plan.generated[1].source
+print(operation("rollback"))
+`);
+  accept(f.root, f.run, applied);
+  for (const result of [partial, retry]) {
+    assert.equal(result.stage, 'rollback-incomplete');
+    assert.equal(result.snapshot.buildId, applied.buildId);
+    assert.equal(result.snapshot.pendingRun, `rollback:${f.plan.runId}`);
+    assert.throws(() => prepare(f.root, result.snapshot, path.join(f.dir, 'blocked-plan')), /PARTIAL_APPLY/);
+    assert.throws(() => acceptRollback(f.root, f.run, result), /incomplete/);
+  }
+  acceptRollback(f.root, f.run, restored);
+});
+test('rollback resumes a source write interrupted before ownership restoration', { skip: !luau }, t => {
+  const f = updateFixture(t);
+  const [applied, partial, restored] = execute(f, `${seedBefore}
+print(operation("apply"))
+model.afterWrite = function()
+    model.afterWrite = nil
+    error("Injected interruption after source restoration")
+end
+print(operation("rollback"))
+assert(model:at({"ServerScriptService", "Port", "Main"}):GetAttribute("BitmagicRollbackRun") == plan.runId)
+print(operation("rollback"))
+assert(model:at({"ServerScriptService", "Port", "Main"}):GetAttribute("BitmagicRollbackRun") == nil)
+`);
+  assert.equal(partial.stage, 'rollback-incomplete');
+  assert.equal(partial.snapshot.pendingRun, `rollback:${f.plan.runId}`);
+  accept(f.root, f.run, applied);
+  acceptRollback(f.root, f.run, restored);
+});

package/dist/commands/generate.js

@@ -896,6 +896,14 @@ function resolveKeepGlb(root, options, log) {
     log('Keeping the mesh: game.json artStyle is low-poly (pass --voxelize to bake it instead).');
     return true;
 }
+/**
+ * A kept mesh in a low-poly project is forged low-poly (Rodin Gen-2), whether the style or
+ * `--keep-glb` kept it. `--keep-glb` in a voxel project keeps the default mesh. Quiet, because
+ * `resolveKeepGlb` has already said anything worth saying about the style.
+ */
+function keptMeshArtStyle(root, keepGlb) {
+    return keepGlb && resolveArtStyle(root) === 'low-poly' ? 'low-poly' : undefined;
+}
 /** The voxel path's `--glb-url`: a paid-for master to bake, instead of buying another. */
 const MASTER_URL_FLAG = {
     type: 'string',
@@ -923,6 +931,7 @@ export async function runPropGeneration(options) {
     assertOneRetrySource(options.glbUrl, options.masterUrl);
     const { output, runDeps, context, environment, token } = await resolveRun(options.json, options.deps);
     const keepGlb = resolveKeepGlb(context.root, options, runDeps.log);
+    const meshArtStyle = keptMeshArtStyle(context.root, keepGlb);
     const result = await withJobRecord({
         root: context.root,
         kind: 'prop',
@@ -947,6 +956,7 @@ export async function runPropGeneration(options) {
                 ...(options.smart !== undefined ? { smart: options.smart } : {}),
                 ...(options.smartSpec !== undefined ? { smartSpec: options.smartSpec } : {}),
                 ...(keepGlb ? { keepGlb: true } : {}),
+                ...(meshArtStyle !== undefined ? { meshArtStyle } : {}),
                 ...(runDeps.keepGlbUpload !== undefined ? { keepGlbUpload: runDeps.keepGlbUpload } : {}),
                 fetchImpl: runDeps.fetch,
                 log,
@@ -1054,6 +1064,7 @@ export async function runModelGeneration(options) {
     assertSmartAllowed(options.smart, options.mesh === true);
     const { output, runDeps, context, environment, token } = await resolveRun(options.json, options.deps);
     const keepGlb = resolveKeepGlb(context.root, options, runDeps.log);
+    const meshArtStyle = keptMeshArtStyle(context.root, keepGlb);
     if (keepGlb && options.smart !== undefined) {
         throw new CliError('--smart has no meaning for a kept mesh: the analysis reads the voxel master, and this project '
             + 'keeps meshes (game.json artStyle is low-poly, or --keep-glb). Pass --voxelize. world.json is unchanged.');
@@ -1089,6 +1100,7 @@ export async function runModelGeneration(options) {
                 fetchImpl: runDeps.fetch,
                 ...(runDeps.voxelize !== undefined ? { voxelize: runDeps.voxelize } : {}),
                 ...(keepGlb ? { keepGlb: true } : {}),
+                ...(meshArtStyle !== undefined ? { meshArtStyle } : {}),
                 ...(runDeps.keepGlbUpload !== undefined ? { keepGlbUpload: runDeps.keepGlbUpload } : {}),
                 log,
             });