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

package/assets/roblox-port/studio-runtime.luau

@@ -0,0 +1,347 @@
+-- Included by build-studio-update.mjs. The caller must explicitly select the Studio session.
+local Http = game:GetService("HttpService")
+local Run = game:GetService("RunService")
+local Editor = game:GetService("ScriptEditorService")
+local NULL = {}
+local project = request.project
+local function editOnly()
+    assert(not Run:IsRunning(), "PLAY_ACTIVE: return to Edit before this operation")
+end
+local function nullable(value)
+    if value == nil then return NULL end
+    return value
+end
+local function encode(value)
+    if value == NULL or value == nil then return "null" end
+    if type(value) ~= "table" then return Http:JSONEncode(value) end
+    local parts = {}
+    if #value > 0 or next(value) == nil then
+        for _, child in ipairs(value) do table.insert(parts, encode(child)) end
+        return "[" .. table.concat(parts, ",") .. "]"
+    end
+    for key, child in pairs(value) do table.insert(parts, Http:JSONEncode(key) .. ":" .. encode(child)) end
+    return "{" .. table.concat(parts, ",") .. "}"
+end
+local function samePath(a, b)
+    if #a ~= #b then return false end
+    for i, part in ipairs(a) do if b[i] ~= part then return false end end
+    return true
+end
+local function getPath(object)
+    local parts = {}
+    while object and object ~= game do
+        table.insert(parts, 1, object.Name)
+        object = object.Parent
+    end
+    assert(object == game, "Instance is outside the DataModel")
+    return parts
+end
+local function childNamed(parent, name)
+    local found = nil
+    for _, child in ipairs(parent:GetChildren()) do
+        if child.Name == name then
+            assert(found == nil, "Ambiguous instance name: " .. name)
+            found = child
+        end
+    end
+    return found
+end
+local function atPath(parts)
+    local current = game:GetService(parts[1])
+    for i = 2, #parts do
+        current = childNamed(current, parts[i])
+        if not current then return nil end
+    end
+    return current
+end
+local function editorSource(object)
+    -- This reads the open editor buffer too. Lack of permission is a blocker, not a reason to
+    -- fall back to potentially stale Source and overwrite unsaved user work.
+    local ok, source = pcall(function() return Editor:GetEditorSource(object) end)
+    assert(ok and type(source) == "string", "Editor-aware read unavailable: " .. object:GetFullName())
+    return source
+end
+local function enabled(object)
+    if object:IsA("BaseScript") then return object.Enabled end
+    return nil
+end
+local function target()
+    return {
+        projectId = nullable(game:GetAttribute("BitmagicProjectId")),
+        targetId = nullable(game:GetAttribute("BitmagicTargetId")),
+        placeId = tostring(game.PlaceId), universeId = tostring(game.GameId),
+        creatorId = tostring(game.CreatorId), creatorType = game.CreatorType.Name,
+    }
+end
+local function snapshot()
+    editOnly()
+    local scripts, selected = {}, {}
+    for _, parts in ipairs(request.paths) do
+        local object = atPath(parts)
+        if object then
+            assert(object:IsA("LuaSourceContainer"), "Requested script path occupied by " .. object.ClassName)
+            selected[object] = true
+        end
+    end
+    for _, object in ipairs(game:GetDescendants()) do
+        if object:GetAttribute("BitmagicTargetId") == project.targetId and object:IsA("LuaSourceContainer") then selected[object] = true end
+    end
+    for object in pairs(selected) do
+        table.insert(scripts, {
+            id = nullable(object:GetAttribute("BitmagicSourceId")),
+            owner = nullable(object:GetAttribute("BitmagicTargetId")),
+            runId = nullable(object:GetAttribute("BitmagicRunId")),
+            path = getPath(object), className = object.ClassName,
+            source = editorSource(object), enabled = nullable(enabled(object)),
+        })
+        assert(#scripts <= 256, "Managed snapshot exceeds 256 scripts")
+    end
+    return {
+        schemaVersion = 1, mode = "Edit", target = target(), scripts = scripts,
+        buildId = nullable(game:GetAttribute("BitmagicBuildId")),
+        pendingRun = nullable(game:GetAttribute("BitmagicPendingRun")),
+    }
+end
+local function findId(id)
+    local found = nil
+    for _, object in ipairs(game:GetDescendants()) do
+        if object:GetAttribute("BitmagicTargetId") == project.targetId and object:GetAttribute("BitmagicSourceId") == id then
+            assert(found == nil, "Duplicate managed ID: " .. id)
+            found = object
+        end
+    end
+    return found
+end
+local function matches(object, value, ownership)
+    if not object or object.ClassName ~= value.className then return false end
+    if not samePath(getPath(object), value.path) or editorSource(object) ~= value.source or enabled(object) ~= value.enabled then return false end
+    if ownership then return object:GetAttribute("BitmagicSourceId") == value.id and object:GetAttribute("BitmagicTargetId") == project.targetId end
+    return object:GetAttribute("BitmagicSourceId") == value.id and object:GetAttribute("BitmagicTargetId") == value.owner and object:GetAttribute("BitmagicRunId") == value.runId
+end
+editOnly()
+if request.action == "inspect" then return encode(snapshot()) end
+local plan = request.plan
+local rollbackPending = "rollback:" .. plan.runId
+local function checkIdentity()
+    editOnly()
+    local current = target()
+    for _, key in ipairs({"placeId", "universeId", "creatorId", "creatorType"}) do
+        assert(current[key] == plan.targetBefore[key], "TARGET_MISMATCH: " .. key)
+    end
+    local pending = game:GetAttribute("BitmagicPendingRun")
+    local ownRun = pending == plan.runId or pending == rollbackPending or game:GetAttribute("BitmagicBuildId") == plan.planHash
+    local expectedProject = plan.targetBefore.projectId
+    local expectedTarget = plan.targetBefore.targetId
+    if ownRun then expectedProject = project.projectId; expectedTarget = project.targetId end
+    local matchesBinding = game:GetAttribute("BitmagicProjectId") == expectedProject and game:GetAttribute("BitmagicTargetId") == expectedTarget
+    -- Recovery can also be interrupted before a first apply, or after restoring the old binding.
+    local restoredBinding = pending == rollbackPending and game:GetAttribute("BitmagicProjectId") == plan.targetBefore.projectId and game:GetAttribute("BitmagicTargetId") == plan.targetBefore.targetId
+    assert(matchesBinding or restoredBinding, "TARGET_MISMATCH: binding")
+    assert(pending == nil or pending == plan.runId or pending == rollbackPending, "Another run is incomplete")
+    local build = game:GetAttribute("BitmagicBuildId")
+    assert(build == plan.buildBefore or build == plan.planHash, "Build advanced since planning")
+end
+local function currentFor(operation)
+    return findId(operation.id) or atPath(operation.before and operation.before.path or operation.after.path)
+end
+local completedAtStart = game:GetAttribute("BitmagicBuildId") == plan.planHash
+local function ownedIntermediate(object, operation, restoring)
+    if not object or object:GetAttribute("BitmagicRunId") ~= plan.runId then return false end
+    if object:GetAttribute("BitmagicTargetId") ~= project.targetId or object:GetAttribute("BitmagicSourceId") ~= operation.id then return false end
+    -- Once committed, old/staged values are later edits, not evidence of an interrupted apply.
+    if completedAtStart and not restoring and object:GetAttribute("BitmagicRollbackRun") ~= plan.runId then return matches(object, operation.after, true) end
+    local before, after = operation.before, operation.after
+    if object.ClassName ~= after.className then return false end
+    local source = editorSource(object)
+    if source ~= after.source and source ~= (before and before.source or "") then return false end
+    if not samePath(getPath(object), after.path) and not (before and samePath(getPath(object), before.path)) then return false end
+    local state = enabled(object)
+    return state == after.enabled or state == false or (before and state == before.enabled)
+end
+local function setSource(object, source, expected)
+    editOnly()
+    Editor:UpdateSourceAsync(object, function(current)
+        -- The callback can be retried by Studio. It has no other side effects.
+        assert(current == expected, "EDIT_CONFLICT: buffer changed during write")
+        return source
+    end)
+    assert(editorSource(object) == source, "Source readback failed")
+end
+local function parentFor(parts)
+    local parent = game:GetService(parts[1])
+    for i = 2, #parts - 1 do
+        local child = childNamed(parent, parts[i])
+        if not child then
+            child = Instance.new("Folder")
+            child.Name = parts[i]
+            child:SetAttribute("BitmagicFolderRun", plan.runId)
+            local prefix = {}
+            for j = 1, i do table.insert(prefix, parts[j]) end
+            child:SetAttribute("BitmagicFolderPath", encode(prefix))
+            child.Parent = parent
+        end
+        assert(child:IsA("Folder") or child:IsA("Model") or child.ClassName == "StarterPlayerScripts" or child.ClassName == "StarterCharacterScripts", "Unsupported source container: " .. child.ClassName)
+        parent = child
+    end
+    return parent
+end
+local function assertPristineCreated(object, attributes)
+    assert(#object:GetChildren() == 0, "New instance has children; preserve and review")
+    for key, value in pairs(object:GetAttributes()) do
+        assert(attributes[key] == value, "Creator attribute preserved: " .. key)
+    end
+    for key, value in pairs(attributes) do assert(object:GetAttribute(key) == value, "Creation metadata changed: " .. key) end
+    assert(#object:GetTags() == 0, "Creator tags preserved")
+    -- Compare native properties that the source updater never owns to an unparented default.
+    -- If a property cannot be read, preserve the instance and report the error, never delete it.
+    local pristine = Instance.new(object.ClassName)
+    local ok, why = pcall(function()
+        assert(object.Archivable == pristine.Archivable, "Creator Archivable setting preserved")
+        if object:IsA("BaseScript") then assert(object.RunContext == pristine.RunContext, "Creator RunContext preserved") end
+        if object:IsA("LuaSourceContainer") then assert(object.LinkedSource == pristine.LinkedSource, "Creator LinkedSource preserved") end
+    end)
+    pristine:Destroy()
+    assert(ok, tostring(why))
+end
+checkIdentity()
+if request.action == "rollback" then
+    -- Set direction before any restoration. New plans and forward replay must not adopt a
+    -- partially reverted build, including after cancellation or a conflict on a later script.
+    game:SetAttribute("BitmagicPendingRun", rollbackPending)
+    local failures = {}
+    for i = #plan.operations, 1, -1 do
+        local operation = plan.operations[i]
+        local ok, why = pcall(function()
+            editOnly()
+            local object = currentFor(operation)
+            if operation.before and object and matches(object, operation.before, false) then
+                if object:GetAttribute("BitmagicRollbackRun") == plan.runId then object:SetAttribute("BitmagicRollbackRun", nil) end
+                return
+            end
+            if not object and not operation.before then return end
+            assert(ownedIntermediate(object, operation), "Later edit preserved: " .. operation.id)
+            local before = operation.before
+            if before then
+                local occupant = atPath(before.path)
+                assert(not occupant or occupant == object, "Rollback destination occupied")
+                local currentSource = editorSource(object)
+                assert(currentSource == before.source or currentSource == operation.after.source, "Later source edit preserved")
+                local recovering = object:GetAttribute("BitmagicRollbackRun")
+                assert(recovering == nil or recovering == plan.runId, "Another rollback owns this script")
+                -- Persist intent before the yielding source write so the same rollback can
+                -- resume a completed write without relaxing guards on untouched scripts.
+                object:SetAttribute("BitmagicRollbackRun", plan.runId)
+                setSource(object, before.source, currentSource)
+                assert(ownedIntermediate(object, operation, true), "Later instance edit preserved")
+                occupant = atPath(before.path)
+                assert(not occupant or occupant == object, "Rollback destination occupied during source write")
+                object.Parent = parentFor(before.path); object.Name = before.path[#before.path]
+                if object:IsA("BaseScript") then object.Enabled = before.enabled end
+                object:SetAttribute("BitmagicSourceId", before.id)
+                object:SetAttribute("BitmagicTargetId", before.owner)
+                object:SetAttribute("BitmagicRunId", before.runId)
+                object:SetAttribute("BitmagicRollbackRun", nil)
+            else
+                assertPristineCreated(object, { BitmagicSourceId = operation.id, BitmagicTargetId = project.targetId, BitmagicRunId = plan.runId })
+                object:Destroy()
+            end
+        end)
+        if not ok then table.insert(failures, tostring(why)) end
+    end
+    -- Only unchanged, empty folders created by this run can be removed, deepest first.
+    local descendants = game:GetDescendants()
+    table.sort(descendants, function(a, b) return #getPath(a) > #getPath(b) end)
+    for _, object in ipairs(descendants) do
+        if object:IsA("Folder") and object:GetAttribute("BitmagicFolderRun") == plan.runId and #object:GetChildren() == 0 then
+            local ok, why = pcall(function()
+                editOnly()
+                assertPristineCreated(object, { BitmagicFolderRun = plan.runId, BitmagicFolderPath = encode(getPath(object)) })
+                object:Destroy()
+            end)
+            if not ok then table.insert(failures, tostring(why)) end
+        end
+    end
+    if #failures == 0 then
+        game:SetAttribute("BitmagicProjectId", plan.targetBefore.projectId)
+        game:SetAttribute("BitmagicTargetId", plan.targetBefore.targetId)
+        game:SetAttribute("BitmagicBuildId", plan.buildBefore)
+        game:SetAttribute("BitmagicPendingRun", nil)
+    end
+    return encode({ schemaVersion = 1, planHash = plan.planHash, stage = #failures == 0 and "rolled-back" or "rollback-incomplete", failures = failures, snapshot = snapshot() })
+end
+assert(request.action == "apply", "Unknown action")
+assert(game:GetAttribute("BitmagicPendingRun") ~= rollbackPending, "ROLLBACK_PENDING: finish rollback before applying")
+-- All known preconditions are checked before binding or writing. The editor callback rechecks
+-- buffers during writes. Studio offers no whole-place transaction; the durable plan is recovery.
+for _, operation in ipairs(plan.operations) do
+    local object = currentFor(operation)
+    if operation.before then
+        assert((object and matches(object, operation.before, false)) or ownedIntermediate(object, operation), "EDIT_CONFLICT: " .. operation.id)
+    else
+        assert(not object or ownedIntermediate(object, operation), "New path occupied: " .. operation.id)
+    end
+    local occupant = atPath(operation.after.path)
+    assert(not occupant or occupant == object, "Destination occupied: " .. operation.id)
+end
+local changed = {}
+for _, operation in ipairs(plan.operations) do changed[operation.id] = true end
+local expectedIds = {}
+for _, expected in ipairs(plan.desired) do expectedIds[expected.id] = true end
+for _, object in ipairs(game:GetDescendants()) do
+    if object:IsA("LuaSourceContainer") and object:GetAttribute("BitmagicTargetId") == project.targetId then
+        assert(expectedIds[object:GetAttribute("BitmagicSourceId")], "Managed script set changed since planning")
+    end
+end
+for _, expected in ipairs(plan.desired) do
+    if not changed[expected.id] then assert(matches(findId(expected.id), expected, true), "Unchanged dependency edited: " .. expected.id) end
+end
+if completedAtStart then
+    for _, expected in ipairs(plan.desired) do assert(matches(findId(expected.id), expected, true), "Committed build was edited: " .. expected.id) end
+    -- A prior apply may have been interrupted after committing the build but before clearing
+    -- its pending marker. The rollback-direction guard above prevents clearing a rollback here.
+    game:SetAttribute("BitmagicPendingRun", nil)
+    return encode(snapshot())
+end
+game:SetAttribute("BitmagicProjectId", project.projectId)
+game:SetAttribute("BitmagicTargetId", project.targetId)
+game:SetAttribute("BitmagicPendingRun", plan.runId)
+for _, operation in ipairs(plan.operations) do
+    editOnly()
+    local after = operation.after
+    local object = currentFor(operation)
+    if not object then
+        local parent = parentFor(after.path)
+        object = Instance.new(after.className)
+        if object:IsA("BaseScript") then object.Enabled = false end
+        object.Name = after.path[#after.path]
+        object:SetAttribute("BitmagicSourceId", after.id)
+        object:SetAttribute("BitmagicTargetId", project.targetId)
+        object:SetAttribute("BitmagicRunId", plan.runId)
+        object.Parent = parent
+    else
+        assert((operation.before and matches(object, operation.before, false)) or ownedIntermediate(object, operation), "Edit changed before apply")
+        object:SetAttribute("BitmagicSourceId", after.id)
+        object:SetAttribute("BitmagicTargetId", project.targetId)
+        object:SetAttribute("BitmagicRunId", plan.runId)
+        if object:IsA("BaseScript") then object.Enabled = false end
+    end
+    local currentSource = editorSource(object)
+    assert(currentSource == after.source or currentSource == (operation.before and operation.before.source or ""), "EDIT_CONFLICT before source write")
+    setSource(object, after.source, currentSource)
+    assert(ownedIntermediate(object, operation), "EDIT_CONFLICT before moving script")
+    local occupant = atPath(after.path)
+    assert(not occupant or occupant == object, "Destination occupied before move")
+    object.Parent = parentFor(after.path); object.Name = after.path[#after.path]
+end
+-- Activate after the full source set exists. Fresh Play is still required for runtime verification.
+for _, operation in ipairs(plan.operations) do
+    editOnly()
+    local object = findId(operation.id)
+    assert(object and editorSource(object) == operation.after.source, "Source changed before activation")
+    if object:IsA("BaseScript") then object.Enabled = operation.after.enabled end
+end
+for _, expected in ipairs(plan.desired) do assert(matches(findId(expected.id), expected, true), "Final readback differs: " .. expected.id) end
+editOnly()
+game:SetAttribute("BitmagicBuildId", plan.planHash)
+game:SetAttribute("BitmagicPendingRun", nil)
+return encode(snapshot())

package/assets/roblox-port/tests/mesh.test.mjs

@@ -0,0 +1,81 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { exportKit } from '../export-packed-mesh.mjs';
+
+function pack(values, kind = 'f32') {
+  const widths = { f32: 4, i16: 2, u16: 2, i8: 1, u8: 1 };
+  const methods = { f32: 'writeFloatLE', i16: 'writeInt16LE', u16: 'writeUInt16LE', i8: 'writeInt8', u8: 'writeUInt8' };
+  const buffer = Buffer.alloc(values.length * widths[kind]);
+  values.forEach((v, i) => buffer[methods[kind]](v, i * widths[kind])); return buffer.toString('base64');
+}
+function fixture(version = 1) {
+  const mesh = version === 1 ? { position: pack([0,0,0, 1,0,0, 0,1,0]), normal: pack([0,0,1, 0,0,1, 0,0,1]), color: pack([1,0,0, 0,1,0, 0,0,1]), triangles: 1, height: 1, muzzleHeight: 0.5 } : { position: pack([0,0,0, 2,0,0, 0,2,0], 'i16'), normal: pack([0,0,127, 0,0,127, 0,0,127], 'i8'), color: pack([255,0,0, 0,255,0, 0,0,255], 'u8'), index: pack([0,1,2], 'u16'), quantum: 0.5, groups: [[0,3,0]], pivot: [1,2,3], triangles: 1 };
+  const kit = { version, meshes: { body: mesh } };
+  const recipe = { schemaVersion: 1, format: `bitmagic-packed-v${version}`, meshIds: ['body'], basis: [1,0,0, 0,1,0, 0,0,1], scale: 2, materials: [{ pbrMetallicRoughness: { baseColorFactor: [1,1,1,1], metallicFactor: 0, roughnessFactor: 0.8 } }] };
+  return { kit, recipe };
+}
+function parse(glb) {
+  assert.equal(glb.readUInt32LE(0), 0x46546c67); assert.equal(glb.readUInt32LE(4), 2); assert.equal(glb.readUInt32LE(8), glb.length);
+  const length = glb.readUInt32LE(12); assert.equal(glb.readUInt32LE(16), 0x4e4f534a);
+  const json = JSON.parse(glb.subarray(20, 20 + length).toString());
+  assert.equal(glb.readUInt32LE(24 + length), 0x004e4942);
+  const binary = glb.subarray(28 + length);
+  assert.equal(binary.length, json.buffers[0].byteLength);
+  function values(id) {
+    const a = json.accessors[id], view = json.bufferViews[a.bufferView];
+    const bytes = binary.subarray(view.byteOffset, view.byteOffset + view.byteLength), result = [];
+    for (let i = 0; i < bytes.length; i += 4) result.push(a.componentType === 5125 ? bytes.readUInt32LE(i) : bytes.readFloatLE(i));
+    return result;
+  }
+  return { json, values };
+}
+for (const version of [1, 2]) test(`layout v${version}: deterministic GLB preserves triangles, colors and pivots`, () => {
+  const { kit, recipe } = fixture(version), before = JSON.stringify(kit);
+  const a = exportKit(kit, recipe), b = exportKit(kit, recipe);
+  assert.deepEqual(a.glb, b.glb); assert.equal(JSON.stringify(kit), before);
+  const { json, values } = parse(a.glb), primitive = json.meshes[0].primitives[0];
+  assert.deepEqual(values(primitive.attributes.POSITION), [0,0,0, 2,0,0, 0,2,0]);
+  assert.deepEqual(values(primitive.attributes.COLOR_0), [1,0,0, 0,1,0, 0,0,1]);
+  assert.deepEqual(values(primitive.indices), [0,1,2]);
+  assert.deepEqual(json.nodes[0].translation, version === 2 ? [2,4,6] : [0,0,0]);
+  assert.equal(a.report.studioValidated, false);
+  if (version === 1) assert.equal(json.nodes[0].extras.muzzleHeight, 1);
+});
+test('reflected basis reverses winding and transforms normals', () => {
+  const { kit, recipe } = fixture(); recipe.basis = [-1,0,0, 0,1,0, 0,0,1];
+  const { json, values } = parse(exportKit(kit, recipe).glb), primitive = json.meshes[0].primitives[0];
+  assert.deepEqual(values(primitive.indices), [0,2,1]);
+  assert.equal(values(primitive.attributes.POSITION)[3], -2);
+  assert.equal(values(primitive.attributes.NORMAL)[2], 1);
+});
+test('zero-area faces require explicit cleanup and retain material groups and real geometry', () => {
+  const { kit, recipe } = fixture(2), mesh = kit.meshes.body;
+  mesh.position = pack([0,0,0, 2,0,0, 0,2,0, 0,0,0], 'i16');
+  mesh.normal = pack([0,0,127, 0,0,127, 0,0,127, 0,0,0], 'i8');
+  mesh.color = pack([255,0,0, 0,255,0, 0,0,255, 255,255,255], 'u8');
+  mesh.index = pack([3,3,3, 0,1,2], 'u16'); mesh.triangles = 2;
+  mesh.groups = [[0,3,0], [3,3,1]];
+  recipe.materials.push(structuredClone(recipe.materials[0]));
+  assert.throws(() => exportKit(kit, recipe), /Zero-area/);
+  recipe.degenerateTriangles = 'drop';
+  const { glb, report } = exportKit(kit, recipe), { json, values } = parse(glb);
+  assert.deepEqual(report.meshes.map(m => [m.sourceTriangles, m.triangles, m.droppedTriangles, m.vertices]), [[2,1,1,3]]);
+  assert.equal(json.meshes[0].primitives.length, 1);
+  assert.equal(json.meshes[0].primitives[0].material, 1);
+  assert.deepEqual(values(json.meshes[0].primitives[0].indices), [0,1,2]);
+  mesh.normal = pack([0,0,0, 0,0,127, 0,0,127, 0,0,0], 'i8');
+  assert.throws(() => exportKit(kit, recipe), /retained surface/);
+});
+test('malformed/unknown data and unmapped materials fail instead of losing content', () => {
+  for (const mutate of [
+    f => { f.kit.version = 3; },
+    f => { f.kit.meshes.body.uv = 'unsupported'; },
+    f => { f.kit.meshes.body.position = '???'; },
+    f => { f.kit.meshes.body.triangles = 99; },
+    f => { f.kit.meshes.body.groups = [[0,3,2]]; },
+    f => { f.kit.meshes.body.groups = [[3,3,0]]; },
+    f => { f.kit.meshes.body.index = pack([0,1,5], 'u16'); },
+    f => { f.recipe.basis[0] = 2; },
+    f => { f.recipe.meshIds = ['unknown']; },
+  ]) { const f = fixture(2); mutate(f); assert.throws(() => exportKit(f.kit, f.recipe)); }
+});

package/assets/roblox-port/tests/state.test.mjs

@@ -0,0 +1,148 @@
+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 { init, prepare, accept, acceptRollback, recordSave, status } from '../port-state.mjs';
+import { loadProject, readJson, writeJson, readBase, materialize, reconcile } from '../lib.mjs';
+import { build, longString } from '../build-studio-update.mjs';
+
+function fixture(t) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'roblox-state-'));
+  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: 'fixture', engineVersion: 'v-test', environment: 'dev' });
+  fs.writeFileSync(path.join(source, 'Game.ts'), 'export const damage = 10;\n');
+  init(source, root);
+  fs.writeFileSync(path.join(root, 'generated/shared/Rules.luau'), 'return { damage = 10 }\n');
+  writeJson(path.join(root, 'incoming.json'), { schemaVersion: 1, sourceFiles: ['bitmagic.json', 'Game.ts'], scripts: [{ id: 'rules', path: ['ReplicatedStorage', 'Port', 'Rules'], className: 'ModuleScript', file: 'generated/shared/Rules.luau' }] });
+  const project = loadProject(root);
+  const live = { schemaVersion: 1, mode: 'Edit', target: { projectId: null, targetId: null, placeId: '0', universeId: '0', creatorId: '42', creatorType: 'User' }, buildId: null, pendingRun: null, scripts: [] };
+  return { dir, root, source, project, live, run: path.join(root, '.bitmagic/roblox/runs/first') };
+}
+function applied(plan) {
+  return { schemaVersion: 1, mode: 'Edit', target: { ...plan.targetBefore, projectId: plan.project.projectId, targetId: plan.project.targetId }, buildId: plan.planHash, pendingRun: null, scripts: plan.desired.map(s => ({ ...s, owner: plan.project.targetId, runId: plan.runId })) };
+}
+test('separate workspace, source freshness, exact readback and unchanged rerun', t => {
+  const f = fixture(t), sourceBefore = fs.readFileSync(path.join(f.source, 'Game.ts'));
+  assert.throws(() => init(f.source, path.join(f.source, 'port')), /outside/);
+  assert.throws(() => init(f.source, f.root), /exists/);
+  assert.throws(() => prepare(f.root, f.live, f.run), /TARGET_UNBOUND/);
+  const plan = prepare(f.root, f.live, f.run, { bind: true });
+  assert.equal(plan.operations.length, 1); assert.equal(plan.conflicts.length, 0);
+  const live = applied(plan);
+  const bad = structuredClone(live); bad.scripts[0].source = 'wrong';
+  assert.throws(() => accept(f.root, f.run, bad), /READBACK_MISMATCH/);
+  assert.equal(readBase(f.root), null);
+  assert.equal(accept(f.root, f.run, live).verified, false);
+  const next = prepare(f.root, live, path.join(f.dir, 'second'));
+  assert.deepEqual(next.operations, []);
+  assert.deepEqual(next.conflicts, []);
+  assert.deepEqual(fs.readFileSync(path.join(f.source, 'Game.ts')), sourceBefore);
+});
+test('kept live edits stay overrides on subsequent exports; divergent edits conflict', t => {
+  const f = fixture(t), first = prepare(f.root, f.live, f.run, { bind: true });
+  const live = applied(first); accept(f.root, f.run, live);
+  live.scripts[0].source = 'return { damage = 15 }\n';
+  const secondDir = path.join(f.dir, 'second'), second = prepare(f.root, live, secondDir);
+  assert.equal(second.desired[0].source, live.scripts[0].source);
+  accept(f.root, secondDir, applied(second));
+  assert.equal(readBase(f.root).generated[0].source, first.generated[0].source);
+  assert.equal(readBase(f.root).applied[0].source, live.scripts[0].source);
+  const unchanged = prepare(f.root, applied(second), path.join(f.dir, 'third'));
+  assert.equal(unchanged.operations.length, 0);
+  fs.writeFileSync(path.join(f.root, 'generated/shared/Rules.luau'), 'return { damage = 12 }\n');
+  const changed = prepare(f.root, applied(second), path.join(f.dir, 'fourth'));
+  assert.match(changed.conflicts[0].reason, /EDIT_CONFLICT: source/);
+  assert.throws(() => build('apply', { root: f.root, run: path.join(f.dir, 'fourth') }), /EDIT_CONFLICT/);
+});
+test('independent rename and source changes merge per field', t => {
+  const f = fixture(t), first = prepare(f.root, f.live, f.run, { bind: true });
+  const live = applied(first); accept(f.root, f.run, live);
+  live.scripts[0].path = ['ReplicatedStorage', "Creator's Folder", 'Combat Rules — sääntö'];
+  fs.writeFileSync(path.join(f.root, 'generated/shared/Rules.luau'), 'return { damage = 12 }\n');
+  const next = prepare(f.root, live, path.join(f.dir, 'second'));
+  assert.equal(next.conflicts.length, 0);
+  assert.deepEqual(next.desired[0].path, live.scripts[0].path);
+  assert.match(next.desired[0].source, /12/);
+});
+test('unowned scripts require deliberate exact adoption', t => {
+  const f = fixture(t), incoming = materialize(f.root, f.project).scripts;
+  f.live.scripts.push({ ...incoming[0], id: null, owner: null, runId: null });
+  assert.match(reconcile(f.project, incoming, null, f.live).conflicts[0].reason, /Unowned/);
+  assert.equal(reconcile(f.project, incoming, null, f.live, true).conflicts.length, 0);
+  f.live.scripts[0].source = 'creator code';
+  assert.match(reconcile(f.project, incoming, null, f.live, true).conflicts[0].reason, /exact matching/);
+});
+test('wrong target, pending run, source drift and changed plans cannot be applied', t => {
+  const f = fixture(t);
+  const wrong = structuredClone(f.live); wrong.target.targetId = 'other';
+  assert.throws(() => prepare(f.root, wrong, f.run, { bind: true }), /TARGET_MISMATCH/);
+  const pending = structuredClone(f.live); pending.pendingRun = 'interrupted';
+  assert.throws(() => prepare(f.root, pending, f.run, { bind: true }), /PARTIAL_APPLY/);
+  const plan = prepare(f.root, f.live, f.run, { bind: true });
+  fs.writeFileSync(path.join(f.source, 'Game.ts'), 'export const damage = 12;');
+  assert.throws(() => build('apply', { root: f.root, run: f.run }), /SOURCE_CHANGED/);
+  assert.ok(build('rollback', { root: f.root, run: f.run }).includes('rollback'));
+  plan.desired[0].source = 'tampered'; writeJson(path.join(f.run, 'plan.json'), plan);
+  assert.throws(() => build('rollback', { root: f.root, run: f.run }), /hash/);
+});
+test('deletions, duplicate IDs and escaping paths are refused', t => {
+  const f = fixture(t), first = prepare(f.root, f.live, f.run, { bind: true });
+  const live = applied(first); accept(f.root, f.run, live);
+  live.scripts = [];
+  assert.match(prepare(f.root, live, path.join(f.dir, 'missing')).conflicts[0].reason, /missing/);
+  const base = readBase(f.root);
+  assert.match(reconcile(f.project, [], base, applied(first)).conflicts[0].reason, /retirement/);
+  const file = path.join(f.root, 'incoming.json'), incoming = readJson(file);
+  incoming.scripts.push(incoming.scripts[0]); writeJson(file, incoming);
+  assert.throws(() => materialize(f.root, f.project), /Duplicate/);
+  incoming.scripts.pop(); incoming.scripts[0].file = '../source/Game.ts'; writeJson(file, incoming);
+  assert.throws(() => materialize(f.root, f.project), /traversal/);
+  fs.symlinkSync(path.join(f.source, 'Game.ts'), path.join(f.root, 'escape.luau'));
+  incoming.scripts[0].file = 'escape.luau'; writeJson(file, incoming);
+  assert.throws(() => materialize(f.root, f.project), /escapes/);
+});
+test('recovery inspection uses the durable plan after conversion inputs disappear', t => {
+  const f = fixture(t), plan = prepare(f.root, f.live, f.run, { bind: true });
+  fs.unlinkSync(path.join(f.root, 'generated/shared/Rules.luau'));
+  fs.writeFileSync(path.join(f.root, 'incoming.json'), 'incomplete manifest');
+  fs.rmSync(f.source, { recursive: true });
+  const code = build('inspect', { root: f.root, run: f.run });
+  const json = code.match(/JSONDecode\(\[=\[([^]*?)\]=\]\)/)[1];
+  const request = JSON.parse(json);
+  assert.equal(request.action, 'inspect');
+  assert.deepEqual(request.project, plan.project);
+  assert.ok(request.paths.some(p => JSON.stringify(p) === JSON.stringify(plan.generated[0].path)));
+  plan.generated[0].source = 'tampered'; writeJson(path.join(f.run, 'plan.json'), plan);
+  assert.throws(() => build('inspect', { root: f.root, run: f.run }), /hash/);
+});
+test('rollback acceptance restores the exact durable baseline and preserves later builds', t => {
+  const f = fixture(t), plan = prepare(f.root, f.live, f.run, { bind: true });
+  accept(f.root, f.run, applied(plan));
+  const receipt = { stage: 'rolled-back', planHash: plan.planHash, failures: [], snapshot: f.live };
+  assert.equal(acceptRollback(f.root, f.run, receipt).buildId, null);
+  assert.equal(readBase(f.root), null);
+  const partial = { ...receipt, failures: ['human edit'], stage: 'rollback-incomplete' };
+  assert.throws(() => acceptRollback(f.root, f.run, partial), /incomplete/);
+  writeJson(path.join(f.root, 'state/base.json'), { planHash: 'newer' });
+  assert.throws(() => acceptRollback(f.root, f.run, receipt), /later baseline/);
+});
+test('save evidence is separate from apply and becomes stale after local changes', t => {
+  const f = fixture(t), plan = prepare(f.root, f.live, f.run, { bind: true });
+  accept(f.root, f.run, applied(plan));
+  assert.equal(status(f.root).saveStatus, 'pending');
+  assert.throws(() => recordSave(f.root, { buildId: plan.planHash, status: 'saved' }), /destination/);
+  const receipt = { buildId: plan.planHash, status: 'saved', destination: '/test/port.rbxl', evidence: 'test fixture receipt', published: false };
+  recordSave(f.root, receipt); assert.equal(status(f.root).saveStatus, 'saved');
+  assert.throws(() => recordSave(f.root, { ...receipt, published: true }), /non-publishing/);
+  fs.writeFileSync(path.join(f.source, 'Game.ts'), 'changed');
+  assert.equal(status(f.root).saveStatus, 'pending');
+});
+test('Luau long-string delimiter cannot be escaped by source content', () => {
+  const value = 'return "]]=] ]=] ]==]"\n-- arbitrary source';
+  const literal = longString(value), match = /^\[(=+)\[/.exec(literal);
+  assert.ok(match); const closing = `]${match[1]}]`;
+  assert.ok(!value.includes(closing));
+  assert.equal(literal.slice(match[0].length, -closing.length), value);
+});