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

package/README.md

@@ -9,15 +9,15 @@ and the games built on it share.
 | `engine/` | `GameLoop`, `SceneRouter`, `Input`, `Controls`, the `GameScene` contract |
 | `platform/` | Hosted sign-in and app entry (`AuthService`, `NetworkManager`), `GameSession`, World Stores presence and the pose codec, chat, voice, webcam, envScope storage |
 | `platform/exec/`, `platform/model/` | The game's world hub on ck-exec (`WorldHub`, one connection per page as `NetworkManager.worldHub`) and `ModelService`, which reads the pulse, programs and progression from it |
-| `platform/studio/` | The Crowdy Studio dock (the SERVER target as a ck-exec mod), grid claims and the world hub's claim registry (`GridService`), CLIENT mods for the player's grid and consented grid mods, the agent's player host |
+| `platform/studio/` | The Crowdy Studio dock (a project runs as a ck-exec mod and its CLIENT half), grid claims and the world hub's claim registry (`GridService`), the CLIENT halves of the grid the player stands in (`GridClientHalves`, over CrowdyJS's `ExecClientHalves`) and the host calls they reach, the agent's player host |
 | `grid/` | JS grid programs (`GridProgramRunner`): player JavaScript with the full CrowdyJS SDK, sandboxed, relayed with a grid-scoped token |
 | `node/` | `security-headers` (site, `/dsh/`, `/grid-program.html`), `vite-plugins`, `construct-copy-dsh` |
 | `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)
-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
@@ -77,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.2-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",
-    "@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

@@ -3,8 +3,8 @@
  *
  * The platform layer every Crowded Kingdoms browser game needs (hosted
  * sign-in, app entry, World Stores presence, voice / webcam / chat, the
- * Crowdy Studio dock with app and grid mods, JS grid programs) and the engine
- * loop around it. Deep imports (`@crowdedkingdoms/construct/platform/...`,
+ * Crowdy Studio dock with grid mods and their CLIENT halves, JS grid programs)
+ * and the engine loop around it. Deep imports (`@crowdedkingdoms/construct/platform/...`,
  * `/engine/...`, `/grid/...`) reach every module; this barrel re-exports the
  * pieces a game wires at boot.
  */
@@ -81,8 +81,14 @@ export {
 export {
   routeClientHostCall,
   routeWithFallback,
-  runConsentedGridMod,
   type ClientModHostReads,
   type ClientModHostWrites,
 } from './platform/studio/clientModHost';
+export {
+  GridClientHalves,
+  describeClientHalfPrompt,
+  isOwnClientHalfPrompt,
+  type ClientHalvesGrid,
+  type GridClientHalvesOptions,
+} from './platform/studio/clientHalves';
 export { GridProgramRunner, type GridProgramRunnerOptions } from './grid/GridProgramRunner';

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: {