@genex-ai/cli-demo 0.21.0 → 0.23.0

package/README.md

@@ -8,10 +8,10 @@ genex init <name>          # authorize + create the draft project
 genex link <slug>          # re-link this folder to an existing game of yours (recovery)
 genex preview              # build + push to the hosted draft URL (unlisted)
 genex publish              # build + push, then list the game in the gallery
-genex model "<prompt>"     # generate a 3D model  → assets/models/
-genex skybox "<prompt>"    # generate a 360° sky  → assets/skybox/
-genex sfx "<prompt>"       # generate a sound fx  → assets/sfx/
-genex texture "<prompt>"   # generate a texture   → assets/textures/
+genex model "<prompt>"     # generate a 3D model  → prints an asset URL
+genex skybox "<prompt>"    # generate a 360° sky  → prints an asset URL
+genex sfx "<prompt>"       # generate a sound fx  → prints an asset URL
+genex texture "<prompt>"   # generate a texture   → prints an asset URL
 genex controller <type>    # install a tuned character|car|drone controller → src/controllers/
 ```
 
@@ -70,22 +70,22 @@ Defaults: API `https://demo-api.glotech.world`, auth site
 ## Generating assets
 
 `genex model | skybox | sfx | texture "<prompt>"` turn a prompt into a real,
-game-ready asset and download it into the project's `./assets/<kind>/` folder. The
-command blocks until the asset is ready (poll loop), then writes the file(s):
+game-ready asset stored in R2. The command blocks until the asset is ready (live SSE
+stream), then prints its public URL — the game loads it directly, nothing is
+downloaded or committed:
 
-| Command | Provider | Writes |
+| Command | Provider | Prints (role) |
 | --- | --- | --- |
-| `genex model "<prompt>"` | Tripo | `assets/models/<slug>.glb` |
-| `genex skybox "<prompt>"` | Blockade Labs | `assets/skybox/<slug>.jpg` |
-| `genex sfx "<prompt>" [--duration <s>]` | ElevenLabs | `assets/sfx/<slug>.mp3` |
-| `genex texture "<prompt>" [--terrain]` | Gemini | `assets/textures/<slug>/basecolor.<ext>` |
-
-Because the file lands in the project and `genex publish` uploads the whole built
-directory, generated assets **ship inside the published R2 bundle** — games serve
-at the domain root (`https://<slug>.genex.technology/`), so both absolute
-(`/assets/...`) and relative (`./assets/...`) paths resolve, and players get them
-from the same origin (no CORS, no runtime dependency on this API). Each kind has a scaffolded
-`genex-ai-<kind>` skill with the exact Three.js loader code.
+| `genex model "<prompt>"` | Tripo | `…/generations/<id>/model-glb` |
+| `genex skybox "<prompt>"` | Blockade Labs | `…/generations/<id>/skybox-equirect` |
+| `genex sfx "<prompt>" [--duration <s>]` | ElevenLabs | `…/generations/<id>/audio-sfx` |
+| `genex texture "<prompt>" [--terrain]` | Gemini | `…/generations/<id>/texture-basecolor` |
+
+Each URL is a permanent `https://assets.genex.technology/...` address served straight
+from R2 (with CORS, so three.js loads it cross-origin without tainting). It resolves
+the same in local dev, the published game, and remixes, and the bytes never pass back
+through this API. Each kind has a scaffolded `genex-ai-<kind>` skill with the exact
+Three.js loader code.
 
 Auth reuses the existing `GENEX_TOKEN` (run `genex init` first). Server-side, each
 provider is keyed by an env var (`TRIPO_API_KEY`, `BLOCKADE_LABS_API_KEY`,

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { readFileSync } from "fs";
-import path14 from "path";
+import path12 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/commands/init.ts
@@ -1468,25 +1468,6 @@ async function runPreview(opts) {
   log.success("Preview deployed \u2014 unlisted draft (run `genex publish` to list it).");
 }
 
-// src/commands/generate.ts
-import path12 from "path";
-
-// src/lib/assets.ts
-import fs10 from "fs/promises";
-import path11 from "path";
-function slugify(input) {
-  const s = input.toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50).replace(/-+$/g, "");
-  return s || "asset";
-}
-async function downloadToFile(url, dest, headers) {
-  const res = await fetch(url, { headers });
-  if (!res.ok) throw new Error(`download failed (HTTP ${res.status}) for ${url}`);
-  const buf = Buffer.from(await res.arrayBuffer());
-  await fs10.mkdir(path11.dirname(dest), { recursive: true });
-  await fs10.writeFile(dest, buf);
-  return buf.byteLength;
-}
-
 // src/lib/sse.ts
 async function* readSSE(body) {
   const decoder = new TextDecoder();
@@ -1527,24 +1508,7 @@ async function* readSSE(body) {
 }
 
 // src/commands/generate.ts
-var PUBLIC_PREFIX = "public/";
-var KIND_DIR = {
-  model: "public/assets/models",
-  skybox: "public/assets/skybox",
-  sfx: "public/assets/sfx",
-  texture: "public/assets/textures"
-};
-function runtimePath(rel) {
-  return `./${rel.replace(PUBLIC_PREFIX, "")}`;
-}
 var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
-function fileDest(kind, slug, f) {
-  if (kind === "texture") {
-    const name = f.role.replace(/^texture-/, "");
-    return `public/assets/textures/${slug}/${name}.${f.ext}`;
-  }
-  return `${KIND_DIR[kind]}/${slug}.${f.ext}`;
-}
 async function runGenerate(kind, opts) {
   const log = createLogger({ quiet: opts.quiet });
   const prompt = opts.prompt?.trim();
@@ -1591,7 +1555,7 @@ async function runGenerate(kind, opts) {
     return;
   }
   if (opts.noWait) {
-    log.success(`Queued (${id}). Re-run without --no-wait to fetch the finished asset.`);
+    log.success(`Queued (${id}). Re-run without --no-wait to get the finished asset URL.`);
     return;
   }
   log.step("Generating\u2026 (this can take up to a minute)");
@@ -1609,25 +1573,20 @@ async function runGenerate(kind, opts) {
     process.exitCode = 1;
     return;
   }
-  const slug = slugify(prompt);
-  const written = [];
-  try {
-    for (const f of view.files ?? []) {
-      const rel = fileDest(kind, slug, f);
-      const url = `${apiUrl}/api/generations/${id}/asset/${f.role}`;
-      const bytes = await downloadToFile(url, path12.join(process.cwd(), rel), {
-        Authorization: `Bearer ${token}`
-      });
-      written.push(rel);
-      log.success(`${rel} ${c.dim(`(${(bytes / 1024).toFixed(0)} KB)`)}`);
-    }
-  } catch (err) {
-    log.error(`Download failed: ${String(err)}`);
+  const files = view.files ?? [];
+  if (files.length === 0) {
+    log.error("Generation completed but produced no files.");
     process.exitCode = 1;
     return;
   }
   log.plain("");
-  printHint(kind, written, log);
+  log.success("Done \u2014 live on R2 (nothing downloaded or committed):");
+  for (const f of files) {
+    const label = files.length > 1 ? `${c.dim(`${f.role.replace(/^texture-/, "")}: `)}` : "";
+    log.plain(`  ${label}${f.url}`);
+  }
+  log.plain("");
+  printHint(kind, files, log);
 }
 var WAIT_TIMEOUT_MS = 10 * 60 * 1e3;
 var TERMINAL = /* @__PURE__ */ new Set(["completed", "failed"]);
@@ -1706,23 +1665,21 @@ async function poll(apiUrl, token, id, onProgress) {
   }
   return null;
 }
-function printHint(kind, written, log) {
-  const load = runtimePath(written[0] ?? "");
+function printHint(kind, files, log) {
+  const url = files[0]?.url ?? "";
   const hint = {
-    model: `Load with GLTFLoader and add to the scene \u2014 see the genex-ai-model skill. Use the relative path "${load}".`,
-    skybox: `Load as an equirectangular texture \u2192 scene.background + scene.environment \u2014 see genex-ai-skybox. Path "${load}".`,
-    sfx: `Load with AudioLoader into a THREE.PositionalAudio (camera needs an AudioListener) \u2014 see genex-ai-sfx. Path "${load}".`,
-    texture: `Load with TextureLoader, set RepeatWrapping, build a MeshStandardMaterial \u2014 see genex-ai-texture. Path "${load}".`
+    model: `Load with GLTFLoader from the URL and add it to the scene \u2014 see the genex-ai-model skill. url = "${url}"`,
+    skybox: `Load as an equirectangular texture \u2192 scene.background + scene.environment \u2014 see genex-ai-skybox. url = "${url}"`,
+    sfx: `Load with AudioLoader into a THREE.PositionalAudio (camera needs an AudioListener) \u2014 see genex-ai-sfx. url = "${url}"`,
+    texture: `Load each map with TextureLoader (RepeatWrapping) into a MeshStandardMaterial \u2014 see genex-ai-texture. Use the URLs above by role.`
   };
-  log.success(
-    "Done. Asset saved into public/assets (so Vite ships it; load it as ./assets/\u2026 \u2014 `genex publish` commits and ships it with the game)."
-  );
   log.dim(`  ${hint[kind]}`);
+  log.dim("  Reference the URL directly in your code \u2014 don't download it into the repo.");
 }
 
 // src/commands/controller.ts
-import fs11 from "fs/promises";
-import path13 from "path";
+import fs10 from "fs/promises";
+import path11 from "path";
 var CONTROLLER_KINDS = ["character", "car", "drone"];
 var SHARED = [
   "shared/math.ts",
@@ -1801,8 +1758,8 @@ var CONTROLLER_FILE_SETS = {
     ]
   }
 };
-var CODE_DEST = path13.join("src", "controllers");
-var ASSETS_DEST = path13.join("public", "assets");
+var CODE_DEST = path11.join("src", "controllers");
+var ASSETS_DEST = path11.join("public", "assets");
 async function runController(opts) {
   const log = createLogger({ quiet: opts.quiet });
   const kind = opts.kind?.trim();
@@ -1815,31 +1772,31 @@ async function runController(opts) {
     process.exitCode = 1;
     return;
   }
-  const srcDir = path13.join(getTemplatesDir(), "controllers");
+  const srcDir = path11.join(getTemplatesDir(), "controllers");
   const root = opts.cwd ?? process.cwd();
   const set = CONTROLLER_FILE_SETS[kind];
   log.plain(c.bold(`genex controller ${kind}`));
   log.plain("");
-  log.step(`Installing the ${kind} controller into ${c.cyan(CODE_DEST + path13.sep)}`);
+  log.step(`Installing the ${kind} controller into ${c.cyan(CODE_DEST + path11.sep)}`);
   const plan = [
-    ...set.code.map((rel) => ({ from: rel, rel: path13.join(CODE_DEST, rel) })),
+    ...set.code.map((rel) => ({ from: rel, rel: path11.join(CODE_DEST, rel) })),
     ...set.assets.map((rel) => ({
       from: rel,
-      rel: path13.join(ASSETS_DEST, path13.basename(rel))
+      rel: path11.join(ASSETS_DEST, path11.basename(rel))
     }))
   ];
   let copied = 0;
   let skipped = 0;
   try {
     for (const file of plan) {
-      const dest = path13.join(root, file.rel);
+      const dest = path11.join(root, file.rel);
       if (!opts.force && await exists2(dest)) {
         skipped++;
         log.dim(`  skipped ${file.rel} (exists \u2014 use --force to overwrite)`);
         continue;
       }
-      await fs11.mkdir(path13.dirname(dest), { recursive: true });
-      await fs11.copyFile(path13.join(srcDir, file.from), dest);
+      await fs10.mkdir(path11.dirname(dest), { recursive: true });
+      await fs10.copyFile(path11.join(srcDir, file.from), dest);
       copied++;
       log.dim(`  ${file.rel}`);
     }
@@ -1871,8 +1828,8 @@ async function runController(opts) {
 }
 async function installOwnerAvatar(args) {
   const { root, srcDir, apiUrl, token, log } = args;
-  const dest = path13.join(root, ASSETS_DEST, "avatar.vrm");
-  await fs11.mkdir(path13.dirname(dest), { recursive: true });
+  const dest = path11.join(root, ASSETS_DEST, "avatar.vrm");
+  await fs10.mkdir(path11.dirname(dest), { recursive: true });
   if (token) {
     try {
       const res = await fetch(`${apiUrl}/api/avatars/me`, {
@@ -1884,7 +1841,7 @@ async function installOwnerAvatar(args) {
           const vrmRes = await fetch(me.vrmUrl);
           if (vrmRes.ok) {
             const buf = Buffer.from(await vrmRes.arrayBuffer());
-            await fs11.writeFile(dest, buf);
+            await fs10.writeFile(dest, buf);
             log.dim(`  public/assets/avatar.vrm (your avatar \u2014 ${(buf.length / 1e6).toFixed(1)} MB)`);
             return;
           }
@@ -1895,14 +1852,14 @@ async function installOwnerAvatar(args) {
       log.dim("  avatar fetch failed (offline?); using the bundled default.");
     }
   }
-  await fs11.copyFile(path13.join(srcDir, "assets", "default-avatar.vrm"), dest);
+  await fs10.copyFile(path11.join(srcDir, "assets", "default-avatar.vrm"), dest);
   log.dim(
     token ? "  public/assets/avatar.vrm (bundled default)" : "  public/assets/avatar.vrm (bundled default \u2014 sign in and re-run for your own)"
   );
 }
 async function exists2(p) {
   try {
-    await fs11.access(p);
+    await fs10.access(p);
     return true;
   } catch {
     return false;
@@ -1913,11 +1870,6 @@ async function exists2(p) {
 async function runExplore(opts) {
   const log = createLogger({ quiet: opts.quiet });
   const query = opts.query?.trim();
-  if (!query) {
-    log.error('Missing query. Usage: genex explore "<what you need>"');
-    process.exitCode = 1;
-    return;
-  }
   const apiUrl = getApiUrl(opts.apiUrl);
   let res;
   try {
@@ -1933,17 +1885,21 @@ async function runExplore(opts) {
     return;
   }
   const { items } = await res.json();
-  const ranked = rank(items, query).slice(0, 5);
+  const ranked = query ? rank(items, query).slice(0, 5) : [...items].sort((a, b) => b.playsCount - a.playsCount);
   if (opts.json) {
     console.log(JSON.stringify(ranked, null, 2));
     return;
   }
   if (ranked.length === 0) {
     log.plain(
-      `No curated projects matched "${query}". Try a broader term (terrain, grass, vehicle, water, building, dungeon, fish, shader).`
+      query ? `No curated projects matched "${query}". Run \`genex explore\` with no arguments to browse the whole catalog, or try a broader term (terrain, grass, vehicle, water, building, dungeon, fish, shader).` : `The curated catalog is empty right now \u2014 check back soon.`
     );
     return;
   }
+  if (!query) {
+    log.plain(c.bold(`The full curated catalog (${ranked.length} project${ranked.length === 1 ? "" : "s"}):`));
+    log.plain("");
+  }
   for (const [i, p] of ranked.entries()) {
     const meta = [
       p.categories.join(", "),
@@ -1979,9 +1935,9 @@ function rank(items, query) {
 var GEN_KINDS = /* @__PURE__ */ new Set(["model", "skybox", "sfx", "texture"]);
 function getVersion() {
   try {
-    const here = path14.dirname(fileURLToPath2(import.meta.url));
+    const here = path12.dirname(fileURLToPath2(import.meta.url));
     const pkg = JSON.parse(
-      readFileSync(path14.resolve(here, "..", "package.json"), "utf8")
+      readFileSync(path12.resolve(here, "..", "package.json"), "utf8")
     );
     return pkg.version ?? "0.0.0";
   } catch {
@@ -2003,8 +1959,9 @@ ${c.bold("Usage")}
   genex texture "<prompt>" [options] Generate a PBR texture into public/assets/textures.
   genex controller <type> [--force]  Install a physics controller (character|car|drone)
                                      into src/controllers (+ assets into public/assets).
-  genex explore "<query>" [options]  Search the curated community gallery \u2014 proven
-                                     Three.js systems you can clone or borrow parts from.
+  genex explore ["<query>"] [options] Search the curated community gallery \u2014 proven
+                                     Three.js systems you can clone or borrow parts
+                                     from. No query lists the whole catalog.
 
 ${c.bold("Options for the generators (`model` `skybox` `sfx` `texture`)")}
   --terrain            (texture) seamless tiling surface for terrain/ground.
@@ -2051,8 +2008,9 @@ ${c.bold("Options for `preview` / `publish`")}
   --env <path>         Token env file (default: ~/.genex/env).
 
 ${c.bold("Options for `explore`")}
-  --json               Print the top matches as JSON (for tools/agents).
+  --json               Print the matches as JSON (for tools/agents).
   --api-url <url>      Override the API base URL.
+                       (No query at all lists the entire curated catalog.)
 
 ${c.bold("Global")}
   --quiet              Reduce output.
@@ -2079,6 +2037,7 @@ ${c.bold("Examples")}
   genex texture "mossy cracked cobblestone" --terrain
   genex controller character
   genex explore "grass"
+  genex explore
 `;
 function parseArgs(argv) {
   const parsed = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/cli-demo",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "Set up your ~/.claude workspace, authorize, create a game project, generate AI assets, and publish (genex CLI).",
   "type": "module",
   "bin": {

package/templates/skills/genex-ai-model/SKILL.md

@@ -21,16 +21,17 @@ npx genex model "<prompt>"
 ```
 
 Write a specific prompt — "weathered wooden barrel with rusted iron bands" beats
-"barrel". The command blocks until the mesh is ready (up to ~a minute), then saves:
+"barrel". The command blocks until the mesh is ready (up to ~a minute), then prints
+its public URL:
 
 ```
-public/assets/models/<slug>.glb
+https://assets.genex.technology/generations/<id>/model-glb
 ```
 
-`<slug>` is derived from the prompt (e.g. `weathered-wooden-barrel.glb`). The file
-lives under `public/` so Vite ships it in the build (load it as `./assets/models/...` —
-the `public/` prefix is stripped when served). It is **committed by `npx genex publish`**,
-so it ships inside your published game.
+The GLB lives in Genex storage (R2) and loads straight from that URL. You **don't
+download it** and **nothing is committed to your repo** — copy the URL the command
+prints into your loader. The URL is permanent, so it works the same in local dev, your
+published game, and remixes.
 
 ## Models that point somewhere must face forward
 
@@ -62,14 +63,16 @@ side — reads as broken at a glance.
 
 ## Load it into the scene
 
-Use Three.js `GLTFLoader` (the game serves at the domain root
-`https://<slug>.genex.technology/`, so relative or absolute paths both work):
+Use Three.js `GLTFLoader` with the URL the command printed (R2 sends the right CORS
+headers, so cross-origin loading just works):
 
 ```ts
 import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
 
 const loader = new GLTFLoader();
-const gltf = await loader.loadAsync("./assets/models/weathered-wooden-barrel.glb");
+// the URL `npx genex model` printed:
+const MODEL_URL = "https://assets.genex.technology/generations/<id>/model-glb";
+const gltf = await loader.loadAsync(MODEL_URL);
 const model = gltf.scene;
 model.scale.setScalar(1); // tune to taste
 model.position.set(0, 0, 0);
@@ -86,17 +89,14 @@ scene is a ghost: players and objects pass straight through it.
 
 ## Publish checklist (so players see the model)
 
-- Reference assets with **relative** paths (`./assets/...`); absolute
-  (`/assets/...`) also resolves since the game serves at the domain root.
-- Set `base: "./"` in `vite.config.ts` before `npm run build` (see the scaffold
-  prompt's publish step).
-- Keep generated assets under `public/assets/` — Vite only ships files under `public/`
-  (or files you `import`); `npx genex publish` ships that folder with the game.
+- Load it from the **URL** the command printed — it's absolute and permanent, so it
+  resolves the same in local dev, the published game, and remixes. Nothing to commit.
+- Don't copy the GLB into `public/assets/` — generated assets live in R2, not the repo.
 
 ## Options
 
-- `--no-wait` — enqueue and return immediately (the file won't be downloaded;
-  re-run without `--no-wait` to fetch it).
+- `--no-wait` — enqueue and return immediately (won't print the URL; re-run without
+  `--no-wait` to get it).
 - `--api-url <url>` — override the API base (local dev).
 
 ## Troubleshooting

package/templates/skills/genex-ai-sfx/SKILL.md

@@ -15,13 +15,15 @@ npx genex sfx "punchy laser zap, short and dry" --duration 2
 ```
 
 `--duration <sec>` (0.5–22) sets a target length; omit it to let the model pick.
-Blocks until ready, then saves:
+Blocks until ready, then prints its public URL:
 
 ```
-public/assets/sfx/<slug>.mp3
+https://assets.genex.technology/generations/<id>/audio-sfx
 ```
 
-Committed by `npx genex publish`, so it ships with your game.
+The mp3 lives in Genex storage (R2) and loads straight from that URL — you don't download
+it and nothing is committed to your repo. The URL is permanent (local dev, published game,
+and remixes alike).
 
 ## Play it in Three.js
 
@@ -36,7 +38,9 @@ import * as THREE from "three";
 const listener = new THREE.AudioListener();
 camera.add(listener);
 
-const buffer = await new THREE.AudioLoader().loadAsync("./assets/sfx/laser-zap.mp3");
+// the URL `npx genex sfx` printed (R2 sends CORS headers, so cross-origin works):
+const SFX_URL = "https://assets.genex.technology/generations/<id>/audio-sfx";
+const buffer = await new THREE.AudioLoader().loadAsync(SFX_URL);
 
 const sound = new THREE.PositionalAudio(listener);
 sound.setBuffer(buffer);
@@ -55,8 +59,8 @@ Reuse one loaded `buffer` across many plays; create a fresh `Audio`/`PositionalA
 
 ## Publish checklist
 
-- Relative path `./assets/sfx/...`; `base: "./"` in `vite.config.ts`; files live under
-  `public/assets/` so Vite ships them; `npx genex publish` ships them to R2.
+- Load it from the **URL** the command printed — absolute and permanent, so it resolves
+  the same in local dev, the published game, and remixes. Nothing to commit.
 
 ## Options
 

package/templates/skills/genex-ai-skybox/SKILL.md

@@ -23,13 +23,15 @@ also lights it (image-based lighting).
 npx genex skybox "<prompt>"
 ```
 
-Blocks until ready, then saves:
+Blocks until ready, then prints its public URL:
 
 ```
-public/assets/skybox/<slug>.jpg
+https://assets.genex.technology/generations/<id>/skybox-equirect
 ```
 
-The JPG is **committed by `npx genex publish`**, so it ships with your game.
+The image lives in Genex storage (R2) and loads straight from that URL — you don't
+download it and nothing is committed to your repo. The URL is permanent (works the same
+in local dev, the published game, and remixes).
 
 ## Load it as background + environment
 
@@ -39,9 +41,9 @@ background and the lighting:
 ```ts
 import * as THREE from "three";
 
-const texture = await new THREE.TextureLoader().loadAsync(
-  "./assets/skybox/golden-hour-over-misty-mountains.jpg",
-);
+// the URL `npx genex skybox` printed (R2 sends CORS headers, so cross-origin works):
+const SKYBOX_URL = "https://assets.genex.technology/generations/<id>/skybox-equirect";
+const texture = await new THREE.TextureLoader().loadAsync(SKYBOX_URL);
 texture.mapping = THREE.EquirectangularReflectionMapping;
 texture.colorSpace = THREE.SRGBColorSpace;
 
@@ -62,10 +64,9 @@ scene.background = texture; // keep the raw texture for the visible sky
 
 ## Publish checklist
 
-- Use the **relative** path `./assets/skybox/...` (absolute `/assets/...` also works — the game serves at the domain root).
-- `base: "./"` in `vite.config.ts` before `npm run build`.
-- Generated files live under `public/assets/` so Vite ships them; `npx genex publish`
-  ships that folder with the game.
+- Load it from the **URL** the command printed — absolute and permanent, so it resolves
+  the same in local dev, the published game, and remixes. Nothing to commit.
+- Don't copy the image into `public/assets/` — generated assets live in R2, not the repo.
 
 ## Options
 

package/templates/skills/genex-ai-texture/SKILL.md

@@ -24,13 +24,15 @@ npx genex texture "<prompt>"
 npx genex texture "lush green grass" --terrain    # seamless tiling for ground/terrain
 ```
 
-Blocks until ready, then saves:
+Blocks until ready, then prints its public URL:
 
 ```
-public/assets/textures/<slug>/basecolor.<ext>
+https://assets.genex.technology/generations/<id>/texture-basecolor
 ```
 
-Committed by `npx genex publish`, so it ships with your game.
+The image lives in Genex storage (R2) and loads straight from that URL — you don't
+download it and nothing is committed to your repo. The URL is permanent (local dev,
+published game, and remixes alike).
 
 > **Scope:** v1 generates the **base-color (albedo)** map only. Normal / roughness
 > / AO are a planned follow-up — for now set sensible `roughness`/`metalness`
@@ -41,11 +43,9 @@ Committed by `npx genex publish`, so it ships with your game.
 ```ts
 import * as THREE from "three";
 
-// The extension varies by provider (production emits .png) — use the EXACT
-// path the CLI printed when generation finished, don't assume .jpg.
-const map = await new THREE.TextureLoader().loadAsync(
-  "./assets/textures/lush-green-grass/basecolor.png",
-);
+// the URL `npx genex texture` printed (R2 sends CORS headers, so cross-origin works):
+const TEXTURE_URL = "https://assets.genex.technology/generations/<id>/texture-basecolor";
+const map = await new THREE.TextureLoader().loadAsync(TEXTURE_URL);
 map.colorSpace = THREE.SRGBColorSpace;
 map.wrapS = map.wrapT = THREE.RepeatWrapping;
 map.repeat.set(8, 8);          // tile count — raise for large surfaces
@@ -69,8 +69,8 @@ scene.add(ground);
 
 ## Publish checklist
 
-- Relative path `./assets/textures/...`; `base: "./"` in `vite.config.ts`; files live under
-  `public/assets/` so Vite ships them; `npx genex publish` ships them to R2.
+- Load it from the **URL** the command printed — absolute and permanent, so it resolves
+  the same in local dev, the published game, and remixes. Nothing to commit.
 
 ## Options
 

package/templates/skills/genex-explore/SKILL.md

@@ -23,6 +23,13 @@ Examples: `npx genex explore "grass"`, `npx genex explore "vehicle physics"`,
 `npx genex explore "procedural building"`. No sign-in needed — this works even
 before `genex init`.
 
+**Not sure what exists?** Run it with no arguments to browse the whole curated
+catalog first — it's small and every entry is proven:
+
+```bash
+npx genex explore
+```
+
 Each result prints everything you need to act on it:
 
 - `play:` — open it in the browser to judge whether it fits.
@@ -36,8 +43,7 @@ Add `--json` for machine-readable output.
 **As a NEW game (start from the whole project):**
 
 1. `git clone <clone URL from the output> <name>` — pick a short one-word name.
-2. `cd <name>`, then `npx @genex-ai/cli-demo@latest init <name>` — choose
-   "Ignore files and continue" if it warns the folder isn't empty; never use
+2. `cd <name>`, then `npx @genex-ai/cli-demo@latest init <name>` — never use
    `--force`. This creates your own project; the original is untouched.
 3. `npm install`, keep `base: './'` in `vite.config`, then build your changes
    and ship with `npx genex preview`.
@@ -64,6 +70,7 @@ build from one:
 - keep any in-game credits screens or notices in place;
 - carry the credit into anything you publish or remix from it.
 
-If nothing matches your query, try a broader term (terrain, grass, vehicle,
+If nothing matches your query, run `npx genex explore` with no arguments to
+see everything available, or try a broader term (terrain, grass, vehicle,
 water, building, dungeon, fish, shader) — or build it with the regular
 `genex-threejs-*` skills instead.

package/templates/skills/genex-getting-started/SKILL.md

@@ -28,9 +28,9 @@ validation.
 
 ## Generating real assets
 
-Beyond procedural code, Genex can generate **real, AI-made assets** from a prompt
-and drop them into `public/assets/` (shipped with your published game; load them
-as `./assets/...` — the `public/` prefix is stripped when served):
+Beyond procedural code, Genex can generate **real, AI-made assets** from a prompt.
+Each command prints a permanent `assets.genex.technology` URL you load directly —
+the asset lives in Genex storage (R2), not your repo, so there's nothing to commit:
 
 ```bash
 npx genex model "weathered wooden barrel"      # a 3D mesh (GLB)