@crowdedkingdoms/crowdyjs 17.13.0-dev.1 → 18.0.0-dev.1

package/dist/crowdy-studio/controller.js

@@ -1,15 +1,17 @@
 import { PlayerCodeBroker, } from '../player-runtime/player-code-broker.js';
+import { CrowdyError, CrowdyGraphQLError } from '../errors.js';
 import { digestCanonicalJson, sha256Digest, } from '../player-host/json-schema.js';
 import { parseRustcDiagnostics } from './diagnostics.js';
 import { githubNewRepositoryUrl, githubRepositorySlug } from './github/new-repo.js';
 import { cloneCrowdyStudioProject, crowdyStudioFileKey, normalizeCrowdyStudioPath, projectTargets, CrowdyStudioOfflineError, CrowdyStudioRevisionConflictError, } from './models.js';
-import { parseClientTickIntervalMs } from './client-tick-interval.js';
 import { createCrowdyStudioStarterProject, } from './starter-projects.js';
 /** As ck-exec's mod names. */
 const MOD_NAME = /^[a-z0-9_-]{1,48}$/;
 /** As a ck-exec build's crate names. */
 const CRATE_NAME = /^[a-z][a-z0-9_-]{0,63}$/;
+/** ck-exec's server log levels (`ExecLogLine.level`); a CLIENT half's are crowdy-client-sdk's. */
 const LOG_LEVELS = ['error', 'warn', 'info', 'debug'];
+const PREVIEW_LOG_LINES_KEPT = 100;
 class OperationCancelledError extends Error {
 }
 /**
@@ -21,7 +23,6 @@ export class CrowdyStudioController {
     constructor(options) {
         this.options = options;
         this.state = {
-            serverEngine: 'player-compute',
             projects: [],
             project: null,
             personalLibraryFiles: [],
@@ -38,9 +39,7 @@ export class CrowdyStudioController {
             buildOutput: '',
             authoritativeDiagnostics: [],
             localDiagnostics: [],
-            runs: [],
             logs: [],
-            usage: null,
             wallet: null,
             invokeResult: null,
         };
@@ -60,14 +59,15 @@ export class CrowdyStudioController {
         this.pageVisible = true;
         this.destroyed = false;
         this.modConnection = null;
+        this.modLogLines = [];
+        this.previewLogLines = [];
+        this.previewLogSeq = 0;
         // ----- GitHub repository card ------------------------------------------
         this.githubStatusGeneration = 0;
-        const serverEngine = options.serverEngine ?? (options.mods ? 'ck-exec' : 'player-compute');
-        if (serverEngine === 'ck-exec' && !options.mods) {
-            throw new Error("serverEngine 'ck-exec' needs the mods option (client.exec)");
+        if (!options.mods) {
+            throw new Error('Crowdy Studio needs mods (client.exec): the SERVER target runs as a ck-exec mod');
         }
-        this.mods = serverEngine === 'ck-exec' ? options.mods : null;
-        this.state = { ...this.state, serverEngine };
+        this.mods = options.mods;
         if (options.onStateChange)
             this.listeners.add(options.onStateChange);
     }
@@ -197,7 +197,7 @@ export class CrowdyStudioController {
         if (this.state.project && !(await this.saveNow())) {
             throw new Error('Resolve or retry the current project save before creating another');
         }
-        const modStarter = this.mods && projectTargets(options.kind).includes('SERVER')
+        const modStarter = projectTargets(options.kind).includes('SERVER')
             ? await this.mods.modStarter(this.options.appId)
             : undefined;
         const input = createCrowdyStudioStarterProject({
@@ -293,8 +293,7 @@ export class CrowdyStudioController {
             buildOutput: '',
             authoritativeDiagnostics: [],
             localDiagnostics: [],
-            runs: [],
-            logs: [],
+            logs: this.clearLogLines(),
             invokeResult: null,
             github: null,
             githubMessage: undefined,
@@ -431,13 +430,10 @@ export class CrowdyStudioController {
         project.metadata = {
             ...project.metadata,
             ...patch,
-            pairingPreference: patch.pairingPreference ?? project.metadata.pairingPreference,
+            pairingPreference: project.metadata.pairingPreference,
         };
         this.markEdited();
     }
-    setPairingPreference(preference) {
-        this.updateSettings({ pairingPreference: preference });
-    }
     setLocalDiagnostics(diagnostics) {
         this.update({ localDiagnostics: [...diagnostics] });
     }
@@ -864,7 +860,7 @@ export class CrowdyStudioController {
         try {
             if (targets.length === 1) {
                 const target = targets[0];
-                const compiled = await this.compileTarget(project, target, draft, operation);
+                const compiled = await this.compileTarget(project, target, operation);
                 if (!compiled) {
                     return {
                         deployment: draft ? 'DRAFT' : 'LIVE',
@@ -883,8 +879,8 @@ export class CrowdyStudioController {
             }
             else {
                 // Compile the client first so a client failure never publishes a new
-                // server version or alters the currently live pairing requirement.
-                const client = await this.compileTarget(project, 'CLIENT', draft, operation);
+                // server version.
+                const client = await this.compileTarget(project, 'CLIENT', operation);
                 if (!client) {
                     return {
                         deployment: draft ? 'DRAFT' : 'LIVE',
@@ -894,7 +890,7 @@ export class CrowdyStudioController {
                         message: this.state.runtime.message ?? 'Client compilation failed',
                     };
                 }
-                const server = await this.compileTarget(project, 'SERVER', draft, operation);
+                const server = await this.compileTarget(project, 'SERVER', operation);
                 if (!server) {
                     return {
                         deployment: draft ? 'DRAFT' : 'LIVE',
@@ -906,17 +902,6 @@ export class CrowdyStudioController {
                 }
                 this.checkOperation(operation);
                 // A mod has no client pairing: its players call it by name.
-                if (!this.mods) {
-                    const requiredClientName = project.metadata.pairingPreference === 'REQUIRED'
-                        ? client.name
-                        : null;
-                    await this.options.playerCompute.setRequires({
-                        ...this.scope(),
-                        serverName: server.name,
-                        requiredClientName,
-                    });
-                    this.checkOperation(operation);
-                }
                 await this.enableServer(server.name, operation);
                 await this.runClient(client, operation);
             }
@@ -967,7 +952,7 @@ export class CrowdyStudioController {
             }
         }
     }
-    async compileTarget(project, target, draft, operation) {
+    async compileTarget(project, target, operation) {
         if (!this.canTarget(target, 'write')) {
             throw new Error(`${target} authoring is unavailable on this grid`);
         }
@@ -982,39 +967,76 @@ export class CrowdyStudioController {
                 message: `Submitting ${name}`,
             },
         });
-        if (target === 'SERVER' && this.mods) {
-            return this.buildMod(name, files, operation);
+        return target === 'SERVER'
+            ? this.buildMod(name, files, operation)
+            : this.buildClientHalf(name, files, operation);
+    }
+    /**
+     * The SERVER target as a ck-exec mod: the project's server crate files, built on the
+     * platform, then deployed to this grid (switched off until {@link enableServer}). Other
+     * project files, such as grid program assets, are not part of the crate.
+     */
+    async buildMod(name, files, operation) {
+        const mods = this.mods;
+        const problem = modNameProblem(this.requireProject());
+        if (problem)
+            throw new Error(problem);
+        const { appId, gridId } = this.scope();
+        const queued = await mods.modBuild(appId, {
+            name: crateName(name),
+            files: crateFiles(files),
+        });
+        this.checkOperation(operation);
+        const built = await this.awaitModBuild('SERVER', name, queued.buildId, operation);
+        if (!built)
+            return null;
+        const mod = await mods.modDeploy(appId, gridId, name, built.buildId);
+        this.checkOperation(operation);
+        return { target: 'SERVER', name, versionId: String(mod.version) };
+    }
+    /**
+     * The CLIENT target as a ck-exec mod's CLIENT half: the project's `crowdy-client-sdk` crate,
+     * built on the platform (`modClientBuild`, a build of `kind` `client`). It is attached to the
+     * project's mod when the project runs ({@link attachClientHalf}).
+     */
+    async buildClientHalf(name, files, operation) {
+        const problem = modNameProblem(this.requireProject());
+        if (problem)
+            throw new Error(problem);
+        const cargo = files.find((file) => file.path === 'Cargo.toml')?.content ?? '';
+        if (/^\s*crowdy-compute-sdk\s*=/m.test(cargo)) {
+            this.recordBuild('CLIENT', LEGACY_CLIENT_CRATE);
+            this.update({
+                runtime: {
+                    phase: 'COMPILE_FAILED',
+                    target: 'CLIENT',
+                    message: `${name} is a legacy player compute crate; a CLIENT half builds on crowdy-client-sdk`,
+                },
+            });
+            return null;
         }
-        // The server resolves the source from the project itself: the saved
-        // files at the project revision, or — for a GITHUB project — the rust at
-        // the commit the mirror is at. No file bodies travel with a deploy.
-        const deployed = await this.options.playerCompute.deploy({
-            ...this.scope(),
-            projectId: project.projectId,
-            name,
-            target: target,
-            ...(project.github?.sha ? { commitSha: project.github.sha } : {}),
-            tickHz: target === 'SERVER' ? 1 : undefined,
-            draft,
+        const queued = await this.mods.modClientBuild(this.options.appId, {
+            name: crateName(name),
+            files: crateFiles(files),
         });
         this.checkOperation(operation);
+        const built = await this.awaitModBuild('CLIENT', name, queued.buildId, operation);
+        return built ? { target: 'CLIENT', name, versionId: built.buildId } : null;
+    }
+    /** Polls a mod build, a mod's or a CLIENT half's, recording its log; null when it did not succeed. */
+    async awaitModBuild(target, name, buildId, operation) {
+        const mods = this.mods;
         const limit = this.options.compilePollLimit ?? 60;
         const pollMs = this.options.compilePollMs ?? 1500;
         for (let attempt = 0; attempt < limit; attempt++) {
-            const versions = await this.options.playerCompute.versions({
-                ...this.scope(),
-                name,
-            });
+            const b = await mods.modBuildStatus(this.options.appId, buildId);
             this.checkOperation(operation);
-            const version = versions.find((candidate) => candidate.versionId === deployed.versionId);
-            const status = version?.compileStatus.toLowerCase();
-            if (status === 'succeeded' || status === 'success') {
-                this.recordBuild(target, version?.compileLog ?? '');
-                return { target, name, versionId: deployed.versionId };
+            if (b.status === 'succeeded') {
+                this.recordBuild(target, b.log ?? '');
+                return b;
             }
-            if (status === 'failed' || status === 'error') {
-                const log = version?.compileLog ?? 'Compilation failed without output';
-                this.recordBuild(target, log);
+            if (b.status === 'failed') {
+                this.recordBuild(target, b.log ?? 'Compilation failed without output');
                 this.update({
                     runtime: {
                         phase: 'COMPILE_FAILED',
@@ -1035,54 +1057,98 @@ export class CrowdyStudioController {
         return null;
     }
     /**
-     * The SERVER target as a ck-exec mod: the project's server crate files, built on the
-     * platform, then deployed to this grid (switched off until {@link enableServer}). Other
-     * project files, such as grid program assets, are not part of the crate.
+     * Attaches a built CLIENT half to the project's mod, consents to it as its author (the API
+     * serves a CLIENT half only to a player who consented or trusts its author, the author too) and
+     * fetches the served module for this browser's preview. A CLIENT-only project first makes sure
+     * the mod it rides is the player's and switched on.
      */
-    async buildMod(name, files, operation) {
+    async attachClientHalf(compiled, operation) {
         const mods = this.mods;
-        if (!MOD_NAME.test(name)) {
-            throw new Error(`The server module name '${name}' must be 1-48 lowercase letters, digits, - or _ to run as a mod`);
-        }
         const { appId, gridId } = this.scope();
-        const queued = await mods.modBuild(appId, {
-            name: CRATE_NAME.test(name) ? name : `mod-${name}`,
-            files: files
-                .filter((file) => isModCrateFile(file.path))
-                .map((file) => ({ path: file.path, content: file.content })),
+        const project = this.requireProject();
+        const modName = projectModName(project);
+        if (!projectTargets(project.kind).includes('SERVER')) {
+            await this.ensureClientOnlyMod(modName, operation);
+        }
+        this.update({
+            runtime: { phase: 'ENABLING', target: 'CLIENT', message: `Attaching ${compiled.name} to ${modName}` },
         });
+        const attached = await mods.modClientDeploy(appId, gridId, modName, compiled.versionId);
         this.checkOperation(operation);
-        const limit = this.options.compilePollLimit ?? 60;
-        const pollMs = this.options.compilePollMs ?? 1500;
-        for (let attempt = 0; attempt < limit; attempt++) {
-            const b = await mods.modBuildStatus(appId, queued.buildId);
-            this.checkOperation(operation);
-            if (b.status === 'succeeded') {
-                this.recordBuild('SERVER', b.log ?? '');
-                const mod = await mods.modDeploy(appId, gridId, name, b.buildId);
-                this.checkOperation(operation);
-                return { target: 'SERVER', name, versionId: String(mod.version) };
+        await mods.consentClientMod(appId, attached.modId, attached.capabilityHash);
+        this.checkOperation(operation);
+        this.recordNote('CLIENT', `Attached to mod '${modName}' as CLIENT version ${attached.clientVersion} (capabilities ` +
+            `${attached.capabilityHash}; ticks every ${attached.tickIntervalMs} ms). Visitors of grid ` +
+            `${gridId} run it once they consent to it or trust you; you consented to it as its author.`);
+        let artifact;
+        try {
+            artifact = await mods.modClientArtifactBytes(appId, attached.modId);
+        }
+        catch (error) {
+            if (error instanceof CrowdyGraphQLError && error.code === 'NOT_FOUND') {
+                throw new CrowdyError({
+                    message: `${compiled.name} is attached to mod '${modName}', but its preview did not load: the ` +
+                        'API serves a CLIENT half only while its mod is switched on and not held, to a player ' +
+                        `with run_client_code who stands in grid ${gridId}`,
+                    cause: error,
+                });
             }
-            if (b.status === 'failed') {
-                this.recordBuild('SERVER', b.log ?? 'Compilation failed without output');
-                this.update({
-                    runtime: {
-                        phase: 'COMPILE_FAILED',
-                        target: 'SERVER',
-                        message: `${name} failed to compile`,
-                    },
+            if (error instanceof CrowdyGraphQLError && error.code === 'RATE_LIMITED') {
+                throw new CrowdyError({
+                    message: `${compiled.name} is attached to mod '${modName}', but its preview was fetched too ` +
+                        'often (12 a minute); deploy again in a minute',
+                    cause: error,
                 });
-                return null;
             }
-            await this.sleep(pollMs);
+            throw error;
+        }
+        this.checkOperation(operation);
+        if (artifact.digest !== attached.digest || artifact.clientVersion !== attached.clientVersion) {
+            throw new Error('The served CLIENT half is not the one just attached; deploy again');
+        }
+        return artifact;
+    }
+    /**
+     * A CLIENT half rides a mod: without a mod of this name running as the player on the grid,
+     * the mod starter's server half is deployed under it first, and the log says so. The mod is
+     * switched on, since only a running mod's CLIENT half is served.
+     */
+    async ensureClientOnlyMod(name, operation) {
+        const mods = this.mods;
+        const { appId, gridId } = this.scope();
+        const mine = (await mods.myMods(appId)).find((mod) => String(mod.gridId) === gridId && mod.name === name);
+        this.checkOperation(operation);
+        if (!mine) {
+            if (!this.canTarget('SERVER', 'write') || !this.canTarget('SERVER', 'run')) {
+                throw new Error(`A CLIENT half rides a mod, and grid ${gridId} has no mod '${name}' of yours; deploying one needs SERVER write and run permissions here`);
+            }
+            this.update({
+                runtime: { phase: 'COMPILING', target: 'SERVER', message: `Deploying the mod starter as ${name}` },
+            });
+            const starter = await mods.modStarter(appId);
             this.checkOperation(operation);
+            const queued = await mods.modBuild(appId, { name: crateName(name), files: starter.files });
+            this.checkOperation(operation);
+            const built = await this.awaitModBuild('SERVER', name, queued.buildId, operation);
+            if (!built) {
+                throw new Error(`The mod starter did not build, so the CLIENT half has no mod '${name}' to ride`);
+            }
+            await mods.modDeploy(appId, gridId, name, built.buildId);
+            this.checkOperation(operation);
+            this.recordNote('SERVER', `Grid ${gridId} had no mod '${name}' of yours, and a CLIENT half rides a mod: deployed the ` +
+                `ck-exec mod starter (${starter.crate}) as '${name}', its server half.`);
         }
-        const timeout = `Compilation timed out after ${limit} polls`;
-        this.recordBuild('SERVER', timeout);
+        if (!mine?.enabled) {
+            await mods.modSetEnabled(appId, gridId, name, true);
+            this.checkOperation(operation);
+            if (mine)
+                this.recordNote('SERVER', `Switched mod '${name}' on, so its CLIENT half is served.`);
+        }
+    }
+    recordNote(target, note) {
         this.update({
-            runtime: { phase: 'COMPILE_FAILED', target: 'SERVER', message: timeout },
+            buildOutput: [this.state.buildOutput, `## ${target}\n${note}`].filter(Boolean).join('\n\n'),
         });
-        return null;
     }
     recordBuild(target, log) {
         const section = `## ${target}\n${log || 'Compiled successfully.'}`;
@@ -1106,44 +1172,35 @@ export class CrowdyStudioController {
         this.checkOperation(operation);
     }
     async setServerEnabled(name, enabled) {
-        if (this.mods) {
-            const { appId, gridId } = this.scope();
-            await this.mods.modSetEnabled(appId, gridId, name, enabled);
-            return;
-        }
-        await this.options.playerCompute.setEnabled({
-            ...this.scope(),
-            name,
-            enabled,
-        });
+        const { appId, gridId } = this.scope();
+        await this.mods.modSetEnabled(appId, gridId, name, enabled);
     }
     async runClient(compiled, operation) {
         if (!this.canTarget('CLIENT', 'run')) {
             throw new Error(`${compiled.name} compiled successfully, but run_client_code is unavailable on this grid`);
         }
         const runtime = this.clientRuntimeOptions();
-        const artifact = await this.options.playerCompute.artifactBytes({
-            ...this.scope(),
-            name: compiled.name,
-            versionId: compiled.versionId,
-        });
-        this.checkOperation(operation);
-        if (artifact.versionId !== compiled.versionId ||
-            !artifact.artifactHash ||
-            artifact.bytes.byteLength === 0) {
-            throw new Error('Client artifact did not match the compiled project version');
-        }
+        const half = await this.attachClientHalf(compiled, operation);
+        let broker = null;
         const brokerOptions = {
             ...runtime,
-            artifactHash: artifact.artifactHash,
-            fuelPerDispatch: artifact.fuelPerDispatch,
+            engine: 'ck-exec',
+            moduleName: half.name,
+            artifactHash: half.digest,
+            fuelPerDispatch: half.fuelPerDispatch,
+            consentedHostCalls: half.capabilitySummary.hostFunctions,
             onPresentation: this.options.onPresentation,
-            tickIntervalMs: this.options.clientTickIntervalMs ??
-                parseClientTickIntervalMs(this.requireProject().files.find((file) => file.target === 'CLIENT' && file.path === 'Cargo.toml')?.content),
+            // Only the preview running now logs into the project's Logs.
+            onLog: (line) => {
+                if (broker && this.broker === broker)
+                    this.recordPreviewLog(compiled.name, line);
+            },
+            tickIntervalMs: this.options.clientTickIntervalMs ?? half.tickIntervalMs,
         };
-        const broker = this.options.brokerFactory?.(brokerOptions) ??
-            new PlayerCodeBroker(brokerOptions);
-        await broker.start(artifact.bytes);
+        broker =
+            this.options.brokerFactory?.(brokerOptions) ??
+                new PlayerCodeBroker(brokerOptions);
+        await broker.start(half.bytes);
         this.checkOperation(operation);
         const previous = this.broker;
         this.broker = broker;
@@ -1170,15 +1227,15 @@ export class CrowdyStudioController {
                 this.broker = null;
             }
         }
-        if (projectTargets(project.kind).includes('SERVER')) {
-            serverStopped = false;
-            try {
-                await this.setServerEnabled(moduleNameFor(project, 'SERVER'), false);
-                serverStopped = true;
-            }
-            catch (error) {
-                failures.push(`Server: ${errorMessage(error)}`);
-            }
+        // A CLIENT-only project's CLIENT half rides a mod too: switched off, it is no longer served
+        // to visitors.
+        serverStopped = false;
+        try {
+            await this.setServerEnabled(projectModName(project), false);
+            serverStopped = true;
+        }
+        catch (error) {
+            failures.push(`Server: ${errorMessage(error)}`);
         }
         const result = { serverStopped, clientStopped, failures };
         this.update({
@@ -1201,18 +1258,7 @@ export class CrowdyStudioController {
         if (!projectTargets(project.kind).includes('SERVER')) {
             throw new Error('Invoke requires a SERVER target');
         }
-        if (this.mods) {
-            const result = await this.callMod(moduleNameFor(project, 'SERVER'), exportName.trim() || 'state', paramsJson);
-            this.checkAgentOperation(agentOperation);
-            this.update({ invokeResult: result });
-            return result;
-        }
-        const result = await this.options.playerCompute.invoke({
-            ...this.scope(),
-            moduleName: moduleNameFor(project, 'SERVER'),
-            exportName: exportName.trim() || 'invoke',
-            paramsJson: paramsJson?.trim() || null,
-        });
+        const result = await this.callMod(moduleNameFor(project, 'SERVER'), exportName.trim() || 'state', paramsJson);
         this.checkAgentOperation(agentOperation);
         this.update({ invokeResult: result });
         return result;
@@ -1279,54 +1325,47 @@ export class CrowdyStudioController {
         this.modConnection = null;
         void open?.connection.then((connection) => connection.close(), () => { });
     }
+    clearLogLines() {
+        this.modLogLines = [];
+        this.previewLogLines = [];
+        return [];
+    }
+    /** The mod's lines and the preview's, newest first. */
+    mergedLogLines() {
+        return [...this.previewLogLines, ...this.modLogLines].sort((a, b) => (Date.parse(b.at) || 0) - (Date.parse(a.at) || 0));
+    }
+    /** A `crowdy::log` line of the CLIENT half this browser previews; the last 100 are kept. */
+    recordPreviewLog(moduleName, line) {
+        if (this.destroyed)
+            return;
+        this.previewLogSeq += 1;
+        this.previewLogLines = [
+            {
+                id: `preview-${this.previewLogSeq}`,
+                source: 'preview',
+                moduleName,
+                level: line.level,
+                at: new Date().toISOString(),
+                text: line.message,
+            },
+            ...this.previewLogLines,
+        ].slice(0, PREVIEW_LOG_LINES_KEPT);
+        this.update({ logs: this.mergedLogLines() });
+    }
     async refreshSurface(surface) {
         if (!this.state.project)
             return;
-        const serverName = this.state.project.metadata.serverModuleName;
-        if (this.mods && surface !== 'usage') {
-            // ck-exec records no runs; a mod's log is its own `ctx.log` lines.
-            if (surface === 'runs') {
-                this.update({ runs: [] });
-                return;
-            }
-            const lines = serverName?.trim()
-                ? await this.mods.modLogs(this.options.appId, this.options.gridId, serverName.trim(), {
-                    limit: 50,
-                })
-                : [];
-            this.update({ logs: lines.map((line) => modLogRow(serverName.trim(), line)) });
-            return;
-        }
-        if (surface === 'runs') {
-            this.update({
-                runs: await this.options.playerCompute.runs({
-                    ...this.scope(),
-                    ...(serverName ? { moduleName: serverName } : {}),
-                    limit: 50,
-                    offset: 0,
-                }),
-            });
-            return;
-        }
         if (surface === 'logs') {
-            this.update({
-                logs: await this.options.playerCompute.logs({
-                    ...this.scope(),
-                    ...(serverName ? { moduleName: serverName } : {}),
-                    limit: 50,
-                }),
-            });
+            // The `ctx.log` lines of the project's mod, which a CLIENT-only project's CLIENT half rides.
+            const name = projectModNameOrNull(this.state.project);
+            const lines = name
+                ? await this.mods.modLogs(this.options.appId, this.options.gridId, name, { limit: 50 })
+                : [];
+            this.modLogLines = lines.map((line) => modLogLine(name, line));
+            this.update({ logs: this.mergedLogLines() });
             return;
         }
-        // Player compute's units and compile quota: with a mod, only a CLIENT target spends them.
-        const legacyUsage = !this.mods || projectTargets(this.state.project.kind).includes('CLIENT');
-        const [usage, wallet] = await Promise.all([
-            legacyUsage
-                ? this.options.playerCompute.usage({ appId: this.options.appId })
-                : Promise.resolve(null),
-            this.options.playerWallet?.balance() ?? Promise.resolve(null),
-        ]);
-        this.update({ usage: usage ? normalizeUsage(usage) : null, wallet });
+        this.update({ wallet: (await this.options.playerWallet?.balance()) ?? null });
     }
     destroy() {
         if (this.destroyed)
@@ -1593,18 +1632,53 @@ function isModCrateFile(path) {
         path === 'README.md' ||
         (path.startsWith('src/') && path.endsWith('.rs')));
 }
-function modLogRow(moduleName, line) {
-    const level = LOG_LEVELS[line.level] ?? 'debug';
+function crateFiles(files) {
+    return files
+        .filter((file) => isModCrateFile(file.path))
+        .map((file) => ({ path: file.path, content: file.content }));
+}
+/** A build's crate name for a module: its own when it is one, else `mod-<name>`. */
+function crateName(name) {
+    return CRATE_NAME.test(name) ? name : `mod-${name}`;
+}
+/**
+ * The mod a ck-exec project runs as: its SERVER module's name, or for a CLIENT-only project the
+ * CLIENT module's, which names the mod its CLIENT half rides.
+ */
+function projectModName(project) {
+    return moduleNameFor(project, projectTargets(project.kind).includes('SERVER') ? 'SERVER' : 'CLIENT');
+}
+function projectModNameOrNull(project) {
+    try {
+        return projectModName(project);
+    }
+    catch {
+        return null;
+    }
+}
+/** Why a ck-exec project's mod name cannot be a mod's, or null. */
+function modNameProblem(project) {
+    const name = projectModName(project);
+    if (MOD_NAME.test(name))
+        return null;
+    return projectTargets(project.kind).includes('SERVER')
+        ? `The server module name '${name}' must be 1-48 lowercase letters, digits, - or _ to run as a mod`
+        : `The CLIENT module name '${name}' names the mod its CLIENT half rides, so it must be 1-48 lowercase letters, digits, - or _`;
+}
+const LEGACY_CLIENT_CRATE = 'This CLIENT crate depends on crowdy-compute-sdk, legacy player compute. On ck-exec a CLIENT ' +
+    'target is a mod\u2019s CLIENT half, one crowdy-client-sdk crate: in Cargo.toml replace the ' +
+    'crowdy-compute-sdk line with crowdy-client-sdk = "0.1.0", and in src/ use crowdy_client_sdk ' +
+    'in place of crowdy_compute_sdk. Its host calls are the same less the Game Model, sessions and ' +
+    'grid state (grid_state_get / grid_state_set): the mod\u2019s server half, a hub keyed by the ' +
+    'grid, holds grid state now.';
+function modLogLine(moduleName, line) {
     return {
-        runId: line.id,
+        id: line.id,
+        source: 'mod',
         moduleName,
-        triggerSource: level,
-        startedAt: line.at,
-        durationUs: 0,
-        fuelUsed: '0',
-        success: level !== 'error',
-        errorMessage: line.text,
-        level,
+        level: LOG_LEVELS[line.level] ?? 'debug',
+        at: line.at,
+        text: line.text,
     };
 }
 function moduleNameFor(project, target) {
@@ -1647,18 +1721,6 @@ function upsertReference(files, next) {
         ...files.filter((file) => file.source !== next.source || file.id !== next.id),
     ];
 }
-function normalizeUsage(value) {
-    return {
-        hourUnitsUsed: String(value.hourUnitsUsed),
-        dayUnitsUsed: String(value.dayUnitsUsed),
-        unitsPerHour: value.unitsPerHour == null ? null : String(value.unitsPerHour),
-        unitsPerDay: value.unitsPerDay == null ? null : String(value.unitsPerDay),
-        compilesThisHour: value.compilesThisHour,
-        maxCompilesPerHour: value.maxCompilesPerHour,
-        gateStatus: value.gateStatus,
-        gateReason: value.gateReason ?? null,
-    };
-}
 function applyValidatedPatch(baseline, input) {
     if (input.changes.length < 1 || input.changes.length > 16) {
         throw new Error('Atomic patch must contain 1 to 16 file changes');