@crowdedkingdoms/construct 0.2.3-dev.1 → 0.3.0-dev.1

package/README.md

@@ -15,10 +15,9 @@ and the games built on it share.
 | `sandbox/boot` | The grid program sandbox bootstrap |
 
 It ships **TypeScript source** for Vite (it uses `?worker&url` and
-`import.meta.env`). Peer dependencies: `@crowdedkingdoms/crowdyjs` 17.7+ (17.12
-for `ModelService`, `GridService` and the Studio's SERVER target on ck-exec,
-17.14 for its CLIENT target and `GridClientHalves`) and, for the Studio agent
-pane, `@crowdedkingdoms/crowdy-dsh` 0.4+. On a
+`import.meta.env`). Peer dependencies: `@crowdedkingdoms/crowdyjs` 18 (0.3.0
+and later; the 0.2 line peers on 17) and, for the Studio agent pane,
+`@crowdedkingdoms/crowdy-dsh` 0.4+. On a
 prerelease tier the ranges name each `X.Y.Z` line they admit, because npm
 matches a prerelease only against a comparator on the same `X.Y.Z`. A game can
 take a new CrowdyJS line only once a construct release names it (until then
@@ -78,7 +77,6 @@ plugins: constructHeaderPlugins({
 
 `@crowdedkingdoms/construct/platform/onboarding/steps` provisions an app
 (org, app, access tier, redirect URIs, grid claim policy, your ck-exec code
-(`deployExec`: `execBuild` + `execDeploy`), a Game Model if you keep one, Studio
-Common Files, agent policy). Pass your own `exec` (manifest, crates, and a
-client holding your session on the app's datacenter), `blueprints` and
-`commonFiles`.
+(`deployExec`: `execBuild` + `execDeploy`), Studio Common Files, agent policy).
+Pass your own `exec` (manifest, crates, and a client holding your session on
+the app's datacenter) and `commonFiles`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowdedkingdoms/construct",
-  "version": "0.2.3-dev.1",
+  "version": "0.3.0-dev.1",
   "description": "The Construct framework: the Crowded Kingdoms game platform layer (hosted sign-in, World Stores, voice/webcam/chat, Crowdy Studio dock, app and grid mods, grid programs) and engine loop, shared by the-construct starter and the games built on it. Ships TypeScript source for Vite.",
   "license": "MIT",
   "type": "module",
@@ -45,8 +45,8 @@
     "./grid/*": "./src/grid/*.ts"
   },
   "peerDependencies": {
-    "@crowdedkingdoms/crowdyjs": ">=17.7.0-dev.0 <18 || >=17.8.0-dev.0 <18 || >=17.9.0-dev.0 <18 || >=17.12.0-dev.0 <18 || >=17.13.0-dev.0 <18 || >=17.14.0-dev.0 <18",
-    "@crowdedkingdoms/crowdy-dsh": ">=0.4.0-dev.0 <1 || >=0.4.1-dev.0 <1"
+    "@crowdedkingdoms/crowdyjs": ">=18.0.0-dev.0 <19",
+    "@crowdedkingdoms/crowdy-dsh": ">=0.4.0-dev.0 <1 || >=0.4.1-dev.0 <1 || >=0.4.2-dev.0 <1"
   },
   "peerDependenciesMeta": {
     "@crowdedkingdoms/crowdy-dsh": {

package/src/grid/GridProgramRunner.ts

@@ -56,10 +56,7 @@ export class GridProgramRunner implements CrowdyStudioDshGridHost {
     const scope = this.options.client().grid(this.options.appId(), gridId);
     const token = await scope.mintToken(60).catch(() => null);
     if (!token) return null;
-    const [channels, sessions] = await Promise.all([
-      scope.channels.list().catch(() => []),
-      scope.sessions.list({ status: 'active' }).catch(() => []),
-    ]);
+    const channels = await scope.channels.list().catch(() => []);
     return {
       appId: this.options.appId(),
       gridId,
@@ -67,11 +64,8 @@ export class GridProgramRunner implements CrowdyStudioDshGridHost {
       high: token.highChunk,
       owned: this.options.owns?.(gridId) ?? false,
       channels: channels.map((c) => ({ groupId: String(c.groupId), name: c.name })),
-      sessions: sessions.map((s) => ({
-        sessionId: s.sessionId,
-        name: s.name ?? null,
-        status: s.status,
-      })),
+      // Grid sessions were the legacy game model's; the bridge's field stays until its protocol moves.
+      sessions: [],
     };
   }
 

package/src/index.ts

@@ -81,7 +81,6 @@ export {
 export {
   routeClientHostCall,
   routeWithFallback,
-  runConsentedGridMod,
   type ClientModHostReads,
   type ClientModHostWrites,
 } from './platform/studio/clientModHost';

package/src/platform/onboarding/steps.d.mts

@@ -75,8 +75,6 @@ export interface OnboardingExec {
 export interface RunOnboardingOptions {
   /** Origins to register as the app's redirect URIs (hosted sign-in + CORS). */
   redirectOrigins?: string[];
-  /** A Game Model's Game Kit blueprints, for a game that keeps one. */
-  blueprints?: unknown[];
   /** The game's ck-exec code, built and deployed as a step (the starter's world hub). */
   exec?: OnboardingExec;
   /** Studio Common Files to publish (starter templates); none by default. */
@@ -131,11 +129,6 @@ export function deployExec(
   input: DeployExecInput,
   log?: Logger,
 ): Promise<{ buildId: string; version: number; restarted: string[] }>;
-export function deployModel(
-  game: CrowdyClient,
-  input: { appId: string; blueprints: unknown[] },
-  log?: Logger,
-): Promise<unknown>;
 export function publishStarterFiles(
   game: CrowdyClient,
   input: { appId: string; commonFiles?: OnboardingCommonFile[] },

package/src/platform/onboarding/steps.mjs

@@ -198,8 +198,8 @@ export async function ensureConstructorTier(identity, { appId, userId }, log = n
   // 2026-09-07 the replay path of grantAppAccess answered a DateTime
   // serialization error on dev, and "already on this tier" is the honest
   // idempotent answer anyway.
-  const mine = await identity.appAccess.myAccess(appId).catch(() => null);
-  if (mine && String(mine.tierId) === String(tier.tierId) && mine.status !== 'revoked') {
+  const held = await accessOf(identity, appId, userId);
+  if (held && String(held.tierId) === String(tier.tierId) && held.status !== 'revoked') {
     log(`User ${userId} already holds "${CONSTRUCTOR_TIER_NAME}"`);
     return { tier, created, updated, granted: false };
   }
@@ -208,6 +208,27 @@ export async function ensureConstructorTier(identity, { appId, userId }, log = n
   return { tier, created, updated, granted: true };
 }
 
+/** `userId`'s access to the app: the caller's own grant, or theirs among the app's grants. */
+async function accessOf(identity, appId, userId) {
+  let me = null;
+  try {
+    me = await identity.users.me();
+  } catch {
+    // Unknown caller: look the user up among the app's grants.
+  }
+  if (me && String(me.userId) === String(userId)) {
+    return identity.appAccess.myAccess(appId).catch(() => null);
+  }
+  const page = 100;
+  for (let offset = 0; ; offset += page) {
+    const rows = await identity.appAccess
+      .usersByApp(appId, { limit: page, offset })
+      .catch(() => []);
+    const row = rows.find((r) => String(r.userId) === String(userId));
+    if (row || rows.length < page) return row ?? null;
+  }
+}
+
 /** 4. Players may claim an unowned chunk for themselves (the Claim pad). */
 export async function ensureSelfClaimPolicy(client, { appId }, log = noop) {
   const current = await client.marketplace.gridClaimPolicy({ appId }).catch(() => null);
@@ -286,54 +307,6 @@ export async function deployExec(
   return { buildId: build.buildId, version, restarted: restart };
 }
 
-/**
- * Deploy a Game Model (kit blueprints), for a game that keeps one. The Construct
- * starter keeps its state in its ck-exec world hub instead (`deployExec`).
- *
- * `gameModelSeed` upserts DEFINITIONS (types, properties, functions) by name,
- * but seed CONTAINERS are instances and are created every time they are sent.
- * Re-running a seed that lists containers therefore duplicates them — measured
- * on 2026-09-07: two runs, two `WorldState`s. So before deploying, drop every
- * seed container whose type already has an instance with the same display
- * name. Definitions still refresh; existing data is left alone.
- */
-export async function deployModel(game, { appId, blueprints }, log = noop) {
-  if (!Array.isArray(blueprints)) {
-    throw new Error("deployModel needs the game's blueprints (e.g. constructBlueprints())");
-  }
-  for (const blueprint of blueprints) {
-    if (!blueprint.containers?.length) continue;
-    const keep = [];
-    const seenTypes = new Map();
-    for (const container of blueprint.containers) {
-      let existing = seenTypes.get(container.typeName);
-      if (!existing) {
-        existing = await game.gameModel
-          .containers({ appId, typeName: container.typeName })
-          .catch(() => []);
-        seenTypes.set(container.typeName, existing);
-      }
-      if (existing.some((row) => row.displayName === container.displayName)) {
-        log(
-          `Container "${container.displayName}" (${container.typeName}) already exists; not re-seeding`,
-        );
-      } else {
-        keep.push(container);
-      }
-    }
-    blueprint.containers = keep;
-  }
-  const result = await game.kit(appId).deploy(blueprints);
-  const seed = result.seed ?? {};
-  log(
-    `Model deployed: ${seed.containerTypesCreated ?? 0} new types, ` +
-      `${seed.functionsCreated ?? 0} new functions, ${seed.containersCreated ?? 0} new containers, ` +
-      `${result.automations?.length ?? 0} automations upserted`,
-  );
-  for (const warning of result.warnings ?? seed.warnings ?? []) log(`  seed warning: ${warning}`);
-  return result;
-}
-
 const PUBLISH_COMMON = `mutation PublishCommon($input: PublishCrowdyStudioCommonFileInput!) {
   crowdyStudioCommonPublish(input: $input) { commonFileId slug versionId versionNo }
 }`;
@@ -516,8 +489,8 @@ function messageOf(error) {
 /**
  * The whole sequence. `enterApp(appId)` must return a client holding an
  * app-scoped token for `appId` (browser: NetworkManager.enterApp; Node: mint
- * and build a client). `exec` (the game's ck-exec code) and `blueprints` (a
- * Game Model) are each deployed when given. Returns a report the UI renders.
+ * and build a client). `exec` (the game's ck-exec code) is built and deployed
+ * when given. Returns a report the UI renders.
  */
 export async function runOnboarding(options) {
   const {
@@ -529,7 +502,6 @@ export async function runOnboarding(options) {
     appSlug,
     datacenter,
     redirectOrigins = [],
-    blueprints,
     exec,
     commonFiles = [],
     log = noop,
@@ -577,9 +549,6 @@ export async function runOnboarding(options) {
   }
   const game = await step('enter', 'App token', () => enterApp(appId));
   await step('claims', 'Grid claim policy', () => ensureSelfClaimPolicy(identity, { appId }, log));
-  if (blueprints) {
-    await step('model', 'Game model', () => deployModel(game, { appId, blueprints }, log));
-  }
   if (exec) {
     await step('exec', 'ck-exec code', async () => {
       const client = await exec.client(appId);

package/src/platform/onboarding/steps.test.ts

@@ -35,6 +35,9 @@ function identityStub(overrides: Any = {}): Any {
         return { appId: '77', name: input.name, slug: input.slug };
       }),
     },
+    users: {
+      me: vi.fn(async () => ({ userId: overrides.callerId ?? '42' })),
+    },
     appAccess: {
       tiers: vi.fn(async () => overrides.tiers ?? []),
       createTier: vi.fn(async (input: Any) => {
@@ -46,6 +49,7 @@ function identityStub(overrides: Any = {}): Any {
         return { tierId: id, name: 'Constructor', permissionKeys: input.permissionKeys };
       }),
       myAccess: vi.fn(async () => overrides.myAccess ?? null),
+      usersByApp: vi.fn(async () => overrides.usersByApp ?? []),
       grant: vi.fn(async (input: Any) => {
         created.push(['grant', input]);
         return { tierId: input.tierId };
@@ -160,6 +164,43 @@ describe('onboarding steps', () => {
     expect(already.appAccess.updateTier).not.toHaveBeenCalled();
   });
 
+  it("grants another user by that user's access, not the caller's", async () => {
+    const tiers = [
+      {
+        tierId: 'd',
+        name: 'Default',
+        isDefault: true,
+        status: 'active',
+        permissionKeys: ['access', ...steps.VISITOR_RUN_KEYS],
+      },
+      {
+        tierId: 't1',
+        name: 'Constructor',
+        status: 'active',
+        permissionKeys: [...steps.CONSTRUCTOR_TIER_KEYS],
+      },
+    ];
+    // The caller (an org admin) holds Constructor; user 42 holds the default tier.
+    const admin = identityStub({
+      callerId: '1',
+      tiers,
+      myAccess: { tierId: 't1', status: 'active' },
+      usersByApp: [{ userId: '42', tierId: 'd', status: 'active' }],
+    });
+    const a = await steps.ensureConstructorTier(admin as never, { appId: '77', userId: '42' });
+    expect(a.granted).toBe(true);
+    expect(admin.appAccess.grant).toHaveBeenCalledWith({ appId: '77', userId: '42', tierId: 't1' });
+
+    const holds = identityStub({
+      callerId: '1',
+      tiers,
+      usersByApp: [{ userId: '42', tierId: 't1', status: 'active' }],
+    });
+    const b = await steps.ensureConstructorTier(holds as never, { appId: '77', userId: '42' });
+    expect(b.granted).toBe(false);
+    expect(holds.appAccess.grant).not.toHaveBeenCalled();
+  });
+
   it('only sets the claim policy when it differs', async () => {
     const game = {
       marketplace: {
@@ -179,37 +220,6 @@ describe('onboarding steps', () => {
     });
   });
 
-  it('does not re-seed containers that already exist', async () => {
-    const deploy = vi.fn(async () => ({
-      seed: { containersCreated: 0 },
-      automations: [],
-      warnings: [],
-    }));
-    const game = {
-      kit: () => ({ deploy }),
-      gameModel: {
-        containers: vi.fn(async ({ typeName }: Any) =>
-          typeName === 'WorldState' ? [{ displayName: 'The Construct' }] : [],
-        ),
-      },
-    };
-    await steps.deployModel(game as never, {
-      appId: '77',
-      blueprints: [
-        {
-          name: 'construct-world',
-          containers: [
-            { typeName: 'WorldState', displayName: 'The Construct' },
-            { typeName: 'Program', displayName: 'Paint' },
-          ],
-        },
-      ],
-    });
-    const blueprints = (deploy.mock.calls as Any[][])[0]![0] as Any[];
-    const world = blueprints.find((b) => b.name === 'construct-world')!;
-    expect(world.containers.map((c: Any) => c.typeName)).toEqual(['Program']);
-  });
-
   const execManifest = {
     root: 'construct',
     types: {

package/src/platform/studio/StudioService.ts

@@ -1,9 +1,8 @@
 /**
  * Crowdy Studio, embedded — the in-game IDE where players write SERVER and
- * CLIENT Rust mods for the grid they stand on. A project runs as a ck-exec mod
- * (`serverEngine: 'ck-exec'`): its SERVER target is a `ckx-sdk` crate the
- * platform builds, deploys to the grid and switches on, which players in the
- * grid call as `mod:<name>`; its CLIENT target is a `crowdy-client-sdk` crate
+ * CLIENT Rust mods for the grid they stand on. A project runs as a ck-exec mod:
+ * its SERVER target is a `ckx-sdk` crate the platform builds, deploys to the
+ * grid and switches on, which players in the grid call as `mod:<name>`; its CLIENT target is a `crowdy-client-sdk` crate
  * the platform builds as that mod's CLIENT half, which the grid serves to the
  * players who stand in it.
  *
@@ -35,7 +34,6 @@ import {
   CrowdyStudioTextHud,
   type CrowdyStudioController,
   type CrowdyStudioEmbedContext,
-  type CrowdyStudioPlayerCompute,
 } from '@crowdedkingdoms/crowdyjs/crowdy-studio';
 import glueWorkerAssetUrl from '@crowdedkingdoms/crowdyjs/player-glue-worker?worker&url';
 
@@ -122,29 +120,6 @@ function createConstructTextHud(): CrowdyStudioTextHud {
   return hud;
 }
 
-/**
- * CrowdyJS 17's embed types a legacy player compute service, which it never
- * calls while both targets run on ck-exec; this one refuses, so nothing can
- * reach the switched-off engine.
- */
-const NO_PLAYER_COMPUTE: CrowdyStudioPlayerCompute = {
-  deploy: refuseLegacyEngine,
-  versions: refuseLegacyEngine,
-  setEnabled: refuseLegacyEngine,
-  setRequires: refuseLegacyEngine,
-  artifactBytes: refuseLegacyEngine,
-  usage: refuseLegacyEngine,
-  runs: refuseLegacyEngine,
-  logs: refuseLegacyEngine,
-  invoke: refuseLegacyEngine,
-};
-
-function refuseLegacyEngine(): Promise<never> {
-  return Promise.reject(
-    new Error('Crowdy Studio runs mods on ck-exec here; legacy player compute is not used'),
-  );
-}
-
 const GRID_REFRESH_MS = 8_000;
 const MODS_REFRESH_MS = 10_000;
 /**
@@ -232,8 +207,9 @@ export class StudioService {
         get crowdyStudio() {
           return network().game.crowdyStudio;
         },
-        playerCompute: NO_PLAYER_COMPUTE,
-        // Both targets' builds, deploys, switch and preview (`serverEngine` below).
+        // Both targets' builds, deploys, switch and preview: the SERVER target runs as the
+        // grid's mod and the CLIENT target as that mod's CLIENT half, which the grid serves to
+        // the players standing in it (GridClientHalves).
         get exec() {
           return network().game.exec;
         },
@@ -253,9 +229,6 @@ export class StudioService {
       },
       appId: () => this.session.appId,
       gameName: GAME_NAME,
-      // The SERVER target runs as the grid's mod and the CLIENT target as that mod's CLIENT
-      // half, which the grid serves to the players standing in it (GridClientHalves).
-      serverEngine: 'ck-exec',
       closeKeyCode: 'KeyM',
       dsh: {
         graphql: network().game.graphql,
@@ -451,7 +424,14 @@ export class StudioService {
   ): (call: PlayerCodeHostCall) => Promise<unknown> {
     const game = this.session.network.game;
     const scope = game.grid(this.session.appId, gridId, toBrokerBounds(bounds));
-    return createGridHostCalls({ scope, client: game });
+    return createGridHostCalls({
+      scope,
+      client: game,
+      local: {
+        gridPermissionKeys: () =>
+          this.currentGrid?.gridId === gridId ? this.currentGrid.permissions.effectiveKeys : [],
+      },
+    });
   }
 
   /**

package/src/platform/studio/clientHalves.test.ts

@@ -64,6 +64,7 @@ function harness(
     self?: string;
     confirm?: (prompt: unknown, signal: AbortSignal) => Promise<boolean>;
     filter?: (mod: { name: string }) => boolean;
+    log?: (line: string) => void;
   } = {},
 ) {
   const listings = options.listings ?? [[half({ callerConsented: true })]];
@@ -95,6 +96,7 @@ function harness(
     options: {
       onHostCall(call: unknown): Promise<unknown>;
       onPresentation?(presentation: unknown): void;
+      onLog?(line: unknown): void;
       consentedHostCalls?: readonly string[];
       engine?: string;
     };
@@ -117,11 +119,16 @@ function harness(
     overlay: overlay as never,
     ...(options.confirm ? { confirm: options.confirm as never } : {}),
     ...(options.filter ? { filter: options.filter as never } : {}),
+    ...(options.log ? { log: options.log } : {}),
     onChange: (running) => changes.push(running.length),
     brokerFactory: (brokerOptions) => {
       const broker = { options: brokerOptions as never, stop: vi.fn() };
       brokers.push(broker);
-      return { start: async () => {}, stop: broker.stop };
+      return {
+        start: async () => {},
+        stop: broker.stop,
+        invoke: async (payload: Uint8Array) => new Uint8Array([...payload].reverse()),
+      };
     },
   });
   return { halves, exec, brokers, hud, overlay, actorsInChunk, serverCall, serverCalls, changes };
@@ -159,6 +166,19 @@ describe('GridClientHalves', () => {
     expect(h.serverCalls).toHaveBeenCalledWith(GRID);
   });
 
+  it("forwards a CLIENT half's log lines and invokes its handle_invoke", async () => {
+    const lines: string[] = [];
+    const h = harness({ log: (line) => lines.push(line) });
+    h.halves.enterGrid(GRID);
+    await h.halves.refresh();
+    h.brokers[0]!.options.onLog?.({ level: 'info', message: 'ready', moduleName: 'greeter' });
+    expect(lines).toContain('CLIENT half of mod greeter info: ready');
+    await expect(h.halves.invoke('m1', new Uint8Array([1, 2, 3]))).resolves.toEqual(
+      new Uint8Array([3, 2, 1]),
+    );
+    await expect(h.halves.invoke('nope', new Uint8Array())).rejects.toThrow();
+  });
+
   it('asks about another author, and a yes trusts them at the hash the grid listed', async () => {
     const asked: unknown[] = [];
     const h = harness({

package/src/platform/studio/clientHalves.ts

@@ -4,8 +4,7 @@
  * into the text HUD and the holodeck overlay. CrowdyJS's `ExecClientHalves`
  * lists what the grid serves, asks, fetches by digest and sandboxes each half
  * in a `PlayerCodeBroker` (`engine: 'ck-exec'`); this adds what only the game
- * knows. It replaces `runConsentedGridMod` + `ClientModLifecycle`, which run
- * the legacy grid-attached client mods.
+ * knows.
  *
  * The player's own CLIENT halves run without a question (on your own grid
  * every half is yours), unless one was installed from a marketplace listing:
@@ -22,6 +21,7 @@ import {
   type ExecGridClientMod,
   type PlayerCodeGridBounds,
   type PlayerCodeHostCall,
+  type PlayerCodeLogLine,
   type PlayerCodePresentation,
 } from '@crowdedkingdoms/crowdyjs';
 import {
@@ -80,6 +80,11 @@ export interface GridClientHalvesOptions {
   filter?: (mod: ExecGridClientMod) => boolean;
   /** After a CLIENT half starts or stops. */
   onChange?: (running: readonly ExecGridClientMod[]) => void;
+  /**
+   * A CLIENT half's `crowdy::log` lines (rate- and length-capped by the broker). The text is
+   * the mod author's: render it as text. Without it they go to `log`.
+   */
+  onLog?: (line: PlayerCodeLogLine, mod: ExecGridClientMod) => void;
   log?: (line: string) => void;
   brokerFactory?: ExecClientHalvesOptions['brokerFactory'];
   now?: () => number;
@@ -114,6 +119,10 @@ export class GridClientHalves {
       },
       onStopped: (mod, reason) => this.stopped(mod, reason),
       onError: (error) => this.options.log?.(this.describeError(error)),
+      onLog: (line, mod) => {
+        if (this.options.onLog) this.options.onLog(line, mod);
+        else this.options.log?.(`CLIENT half of mod ${mod.name} ${line.level}: ${line.message}`);
+      },
       ...(options.brokerFactory ? { brokerFactory: options.brokerFactory } : {}),
       ...(options.now ? { now: options.now } : {}),
     });
@@ -141,6 +150,18 @@ export class GridClientHalves {
     return this.runner.refresh();
   }
 
+  /**
+   * Calls the `handle_invoke` export of the running CLIENT half of mod `modId`. The reply is
+   * the mod author's bytes: treat them as untrusted input.
+   */
+  invoke(
+    modId: string,
+    payload: Uint8Array,
+    options?: { timeoutMs?: number },
+  ): Promise<Uint8Array> {
+    return this.runner.invoke(modId, payload, options);
+  }
+
   stop(): void {
     this.asking?.abort();
     this.asking = null;

package/src/platform/studio/clientModHost.test.ts

@@ -1,6 +1,4 @@
-import { describe, expect, it, vi } from 'vitest';
-
-vi.mock('@crowdedkingdoms/crowdyjs', () => ({ PlayerCodeBroker: class {} }));
+import { describe, expect, it } from 'vitest';
 
 const {
   DEFAULT_VOXEL_STATE,

package/src/platform/studio/clientModHost.ts

@@ -10,19 +10,8 @@
  * return only what the running player can already lawfully see. Writes go
  * through ChunkStore.setVoxel (optimistic + UDP) and markDirty (durable
  * write-back), the same route Paint uses. Never hand a mod the raw client.
- *
- * `runConsentedGridMod` starts a legacy grid-attached client mod, until
- * CrowdyJS 18 removes them.
  */
-import {
-  PlayerCodeBroker,
-  type CrowdyClient,
-  type PlayerCodeGridBounds,
-  type PlayerCodeHostCall,
-  type PlayerCodePresentation,
-} from '@crowdedkingdoms/crowdyjs';
-import type { CrowdyStudioTextHud } from '@crowdedkingdoms/crowdyjs/crowdy-studio';
-import type { ModOverlayStore } from './modOverlay';
+import type { PlayerCodeGridBounds, PlayerCodeHostCall } from '@crowdedkingdoms/crowdyjs';
 
 export interface ClientModHostReads {
   actorsInChunk(x: bigint, y: bigint, z: bigint): Array<Record<string, unknown>>;
@@ -242,119 +231,6 @@ export function bytesToBase64(bytes: Uint8Array): string {
   return btoa(binary);
 }
 
-interface CachedArtifact {
-  bytes: Uint8Array;
-  artifactHash?: string;
-  fuelPerDispatch?: string | bigint;
-}
-
-const artifactCache = new Map<string, CachedArtifact>();
-
-/**
- * Fetch a consented grid-attached client mod's artifact and run it in a
- * hash-verified broker with the same allowlist, grid clamp, rate caps and
- * circuit breaker as the Studio's own Test/Run path. Its HUD output lands in
- * the persistent text HUD. Returns null (fails closed) when the artifact
- * cannot be fetched.
- *
- * @deprecated A legacy grid-attached client mod (`marketplace.gridClientMods`),
- * which CrowdyJS 18 removes. A ck-exec mod's CLIENT half runs through
- * `GridClientHalves` (`clientHalves.ts`).
- */
-export async function runConsentedGridMod(options: {
-  client: CrowdyClient;
-  appId: string;
-  attachmentId: string;
-  artifactCacheKey: string;
-  hudSource: string;
-  hudLabel: string;
-  /** The module's name, which addressed grid events target (default `hudLabel`). */
-  moduleName?: string;
-  grid: PlayerCodeGridBounds;
-  workerUrl: string;
-  reads: ClientModHostReads;
-  writes?: ClientModHostWrites;
-  hud: CrowdyStudioTextHud;
-  overlay?: ModOverlayStore;
-  input?: ClientModHostInput;
-  /**
-   * Answers the host calls this game does not route itself (DN-10: the rest
-   * of the client catalog, through CrowdyJS `createGridHostCalls`).
-   */
-  serverCalls?: (call: PlayerCodeHostCall) => Promise<unknown>;
-  /**
-   * How often the worker self-drives `on_tick`. Omitted/0 means invoke-only
-   * and a HUD mod then never runs (measured 2026-09-07: broker started, HUD
-   * stayed empty). Studio Test/Deploy reads `[package.metadata.crowdy]
-   * tick_interval_ms` from the CLIENT Cargo.toml (default 1000, clamped
-   * 16–1000). Pass this only for grid-attached visitors until that field is
-   * stored on the compiled version.
-   */
-  tickIntervalMs?: number;
-}): Promise<{ stop: () => void } | null> {
-  let fetched: { bytes: ArrayBuffer; artifactHash?: string; fuelPerDispatch?: string | bigint };
-  const cached = artifactCache.get(options.artifactCacheKey);
-  if (cached) {
-    fetched = {
-      bytes: cached.bytes.slice().buffer,
-      artifactHash: cached.artifactHash,
-      fuelPerDispatch: cached.fuelPerDispatch,
-    };
-  } else {
-    try {
-      fetched = await options.client.marketplace.clientArtifactBytes({
-        appId: options.appId,
-        attachmentId: options.attachmentId,
-      });
-    } catch {
-      return null;
-    }
-    artifactCache.set(options.artifactCacheKey, {
-      bytes: new Uint8Array(fetched.bytes).slice(),
-      artifactHash: fetched.artifactHash,
-      fuelPerDispatch: fetched.fuelPerDispatch,
-    });
-  }
-  const broker = new PlayerCodeBroker({
-    workerUrl: options.workerUrl,
-    grid: options.grid,
-    artifactHash: fetched.artifactHash,
-    fuelPerDispatch: fetched.fuelPerDispatch != null ? BigInt(fetched.fuelPerDispatch) : undefined,
-    tickIntervalMs: options.tickIntervalMs ?? 1000,
-    moduleName: options.moduleName ?? options.hudLabel,
-    onHostCall: (call) =>
-      routeWithFallback(
-        call,
-        () => routeClientHostCall(call, options.reads, options.grid, options.writes, options.input),
-        options.serverCalls,
-      ),
-    onPresentation: (presentation: PlayerCodePresentation) => {
-      if (presentation.channel === 'hud') {
-        options.hud.set({
-          source: options.hudSource,
-          label: options.hudLabel,
-          payload: presentation.payload,
-        });
-      }
-      if (presentation.channel === 'overlay') {
-        options.overlay?.apply(options.hudSource, presentation.payload, options.grid);
-      }
-    },
-    onCircuitOpen: () => {
-      options.hud.remove(options.hudSource);
-      options.overlay?.remove(options.hudSource);
-    },
-  });
-  await broker.start(fetched.bytes);
-  return {
-    stop: () => {
-      broker.stop();
-      options.hud.remove(options.hudSource);
-      options.overlay?.remove(options.hudSource);
-    },
-  };
-}
-
 /**
  * The game's own router first (local reads, optimistic writes); anything it
  * does not offer goes to `serverCalls` when the game supplied it.

package/src/platform/studio/ClientModLifecycle.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import { ClientModLifecycle } from './ClientModLifecycle';
-
-const d = (id: string, artifactHash = 'a', capabilityHash = 'c') => ({
-  attachmentId: id,
-  artifactHash,
-  capabilityHash,
-});
-
-describe('ClientModLifecycle', () => {
-  it('stops every worker when the grid changes', () => {
-    const life = new ClientModLifecycle();
-    expect(life.enterGrid('g1')).toBe(true);
-    const scope = life.scope('g1')!;
-    const stop = vi.fn();
-    expect(life.track(scope, d('m1'), { stop })).toBe(true);
-    expect(life.enterGrid('g1')).toBe(false);
-    expect(life.enterGrid('g2')).toBe(true);
-    expect(stop).toHaveBeenCalledTimes(1);
-    expect(life.runningCount).toBe(0);
-  });
-
-  it('rejects a worker that finished starting after the grid changed', () => {
-    const life = new ClientModLifecycle();
-    life.enterGrid('g1');
-    const stale = life.scope('g1')!;
-    life.enterGrid('g2');
-    const stop = vi.fn();
-    expect(life.track(stale, d('m1'), { stop })).toBe(false);
-    expect(stop).toHaveBeenCalled();
-  });
-
-  it('reconciles by immutable hashes', () => {
-    const life = new ClientModLifecycle();
-    life.enterGrid('g1');
-    const scope = life.scope('g1')!;
-    const stopA = vi.fn();
-    const stopB = vi.fn();
-    life.track(scope, d('a'), { stop: stopA });
-    life.track(scope, d('b'), { stop: stopB });
-    expect(life.reconcile(scope, [d('a'), d('b', 'a2')])).toBe(true);
-    expect(stopA).not.toHaveBeenCalled();
-    expect(stopB).toHaveBeenCalled();
-    expect(life.has('a')).toBe(true);
-    expect(life.has('b')).toBe(false);
-  });
-
-  it('is inert after shutdown', () => {
-    const life = new ClientModLifecycle();
-    life.enterGrid('g1');
-    life.shutdown();
-    expect(life.enterGrid('g2')).toBe(false);
-    expect(life.scope('g2')).toBeNull();
-  });
-});

package/src/platform/studio/ClientModLifecycle.ts

@@ -1,107 +0,0 @@
-/**
- * Owns the worker handles of grid-attached CLIENT mods independently of any
- * scene. Every metadata refresh reconciles immutable hashes; changing grids
- * synchronously tears everything down; a worker that finishes starting after
- * a grid change (or shutdown) is stopped instead of attached stale.
- */
-export interface ClientModDescriptor {
-  attachmentId: string;
-  artifactHash: string;
-  capabilityHash: string;
-}
-
-export interface ClientModHandle {
-  stop: () => void;
-}
-
-export interface ClientModScope {
-  gridId: string;
-  generation: number;
-}
-
-interface RunningClientMod extends ClientModDescriptor, ClientModHandle {}
-
-/**
- * @deprecated For the legacy grid-attached client mods (`runConsentedGridMod`),
- * which CrowdyJS 18 removes; `GridClientHalves` keeps a ck-exec grid's CLIENT
- * halves.
- */
-export class ClientModLifecycle {
-  private readonly running = new Map<string, RunningClientMod>();
-  private activeGridId: string | null = null;
-  private generation = 0;
-  private stopped = false;
-
-  /** Returns true when the grid actually changed (callers reset their caches). */
-  enterGrid(gridId: string | null): boolean {
-    if (this.stopped) return false;
-    if (gridId === this.activeGridId) return false;
-    this.stopAll();
-    this.activeGridId = gridId;
-    this.generation++;
-    return true;
-  }
-
-  get currentGridId(): string | null {
-    return this.activeGridId;
-  }
-
-  has(attachmentId: string): boolean {
-    return this.running.has(attachmentId);
-  }
-
-  get runningCount(): number {
-    return this.running.size;
-  }
-
-  scope(gridId: string): ClientModScope | null {
-    if (this.stopped || gridId !== this.activeGridId) return null;
-    return { gridId, generation: this.generation };
-  }
-
-  isCurrent(scope: ClientModScope): boolean {
-    return (
-      !this.stopped && scope.gridId === this.activeGridId && scope.generation === this.generation
-    );
-  }
-
-  track(scope: ClientModScope, descriptor: ClientModDescriptor, handle: ClientModHandle): boolean {
-    if (!this.isCurrent(scope) || this.running.has(descriptor.attachmentId)) {
-      handle.stop();
-      return false;
-    }
-    this.running.set(descriptor.attachmentId, { ...descriptor, ...handle });
-    return true;
-  }
-
-  /** Stop mods that disappeared or changed hash; returns false if scope is stale. */
-  reconcile(scope: ClientModScope, descriptors: readonly ClientModDescriptor[]): boolean {
-    if (!this.isCurrent(scope)) return false;
-    const current = new Map(descriptors.map((d) => [d.attachmentId, d]));
-    for (const [attachmentId, running] of this.running) {
-      const next = current.get(attachmentId);
-      if (
-        !next ||
-        next.artifactHash !== running.artifactHash ||
-        next.capabilityHash !== running.capabilityHash
-      ) {
-        running.stop();
-        this.running.delete(attachmentId);
-      }
-    }
-    return true;
-  }
-
-  private stopAll(): void {
-    for (const running of this.running.values()) running.stop();
-    this.running.clear();
-  }
-
-  shutdown(): void {
-    if (this.stopped) return;
-    this.stopped = true;
-    this.activeGridId = null;
-    this.generation++;
-    this.stopAll();
-  }
-}