tileflow 0.0.0-bootstrap.0 → 0.1.0-alpha.0

package/dist/index.js

@@ -3,20 +3,20 @@
 // src/index.ts
 import { serve } from "@hono/node-server";
 import { Command } from "commander";
-import { createHash as createHash3, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash4, randomBytes as randomBytes2 } from "crypto";
 import { existsSync, readFileSync, realpathSync } from "fs";
-import { readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile7, writeFile as writeFile2 } from "fs/promises";
 import { hostname } from "os";
-import { dirname as dirname9, isAbsolute as isAbsolute4, relative as relative5, resolve as resolve7, sep as sep5 } from "path";
+import { dirname as dirname10, isAbsolute as isAbsolute4, relative as relative5, resolve as resolve7, sep as sep5 } from "path";
 import { createInterface } from "readline/promises";
-import pc2 from "picocolors";
+import pc3 from "picocolors";
 import {
+  auditTileflowMapThemeValues,
   getTileflowStyleFontFaces,
-  parseTileflowMap as parseTileflowMap2,
+  parseResolvedTileflowMap as parseResolvedTileflowMap3,
   tileflowMapIdSchema as tileflowMapIdSchema2
 } from "@tileflow/core";
 import {
-  collectTileflowMapBuildLineage,
   createTileflowMapBuildManifest
 } from "@tileflow/core/build";
 import {
@@ -27,6 +27,7 @@ import {
   createTileflowArtifactSession as createTileflowArtifactSession3,
   createTileflowBuildProvenance,
   createTileflowStyles,
+  prepareTileflowLocalTilesets,
   writeTileflowBuildArtifacts
 } from "@tileflow/dev/artifacts";
 import {
@@ -35,7 +36,7 @@ import {
   defaultTileflowConfigPath,
   defaultTileflowManifestPath,
   getTileflowMapNames as getTileflowMapNames3,
-  loadTileflowConfigWithInputs as loadTileflowConfigWithInputs2,
+  loadTileflowConfigWithInputs as loadTileflowConfigWithInputs3,
   TileflowValidationError as TileflowValidationError4
 } from "@tileflow/dev/config";
 import {
@@ -50,9 +51,10 @@ import {
   createTileflowDevRequestHandler
 } from "@tileflow/dev/server";
 import {
-  createTileflowCommandFailureDocument as createTileflowCommandFailureDocument2,
-  createTileflowCommandSummary,
-  serializeTileflowCommandDocument as serializeTileflowCommandDocument2,
+  createTileflowCommandFailureDocument as createTileflowCommandFailureDocument4,
+  createTileflowCommandSummary as createTileflowCommandSummary2,
+  createTileflowStructuredDiagnostics as createTileflowStructuredDiagnostics2,
+  serializeTileflowCommandDocument as serializeTileflowCommandDocument4,
   TileflowStyleValidationError as TileflowStyleValidationError2
 } from "@tileflow/dev/validation";
 
@@ -265,6 +267,405 @@ function compareCodeUnits(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
+// src/ai-commands.ts
+import { dirname as dirname2 } from "path";
+import {
+  createStyleResult,
+  diffTileflowMaps,
+  parseResolvedTileflowMap,
+  tileflowAuthoringManifestSchemaVersion
+} from "@tileflow/core";
+import { loadTileflowConfigWithInputs } from "@tileflow/dev/config";
+import { prepareTileflowCatalogIcons } from "@tileflow/dev/icons";
+import { sanitizeTileflowInspectableValue } from "@tileflow/dev/inspect";
+import {
+  createTileflowCommandFailureDocument,
+  createTileflowCommandSummary,
+  createTileflowStructuredDiagnostics,
+  sanitizeDiagnosticSecrets,
+  serializeTileflowCommandDocument
+} from "@tileflow/dev/validation";
+
+// src/config-execution.ts
+function hideTileflowConfigSecrets() {
+  const hadApiKey = Object.hasOwn(process.env, "TILEFLOW_API_KEY");
+  const apiKey = process.env.TILEFLOW_API_KEY;
+  const argv = [...process.argv];
+  let restored = false;
+  delete process.env.TILEFLOW_API_KEY;
+  replaceProcessArgv(stripApiKeyArguments(argv));
+  return {
+    restore() {
+      if (restored) return;
+      restored = true;
+      if (hadApiKey) {
+        process.env.TILEFLOW_API_KEY = apiKey;
+      } else {
+        delete process.env.TILEFLOW_API_KEY;
+      }
+      replaceProcessArgv(argv);
+    }
+  };
+}
+async function withTileflowConfigSecretsHidden(operation) {
+  const scope = hideTileflowConfigSecrets();
+  try {
+    return await operation();
+  } finally {
+    scope.restore();
+  }
+}
+function stripApiKeyArguments(argv) {
+  const sanitized = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "--api-key") {
+      index += 1;
+      continue;
+    }
+    if (argument.startsWith("--api-key=")) continue;
+    sanitized.push(argument);
+  }
+  return sanitized;
+}
+function replaceProcessArgv(argv) {
+  process.argv.splice(0, process.argv.length, ...argv);
+}
+
+// src/ai-commands.ts
+function registerAiCommands(program2, dependencies) {
+  program2.command("explain").description("Compile one map/theme and explain semantic compiler decisions").option("-c, --config <path>", "config path", dependencies.defaultConfigPath).option("--map <name>", "compile one exact configured map").option("--theme <name>", "compile one exact concrete theme; defaults to the map default").option("--inspection", "include physical-layer provenance in the compilation report").option("--api-base-url <url>", "Tileflow API base URL", dependencies.defaultApiUrl).option("--json", "print deterministic schema-version-1 JSON").action(
+    async (options) => runExplain(options, dependencies.createStyleResult ?? createStyleResult)
+  );
+  program2.command("semantic-diff").description("Compare resolved semantic maps from two configs or one workspace").option("-c, --config <path>", "workspace config path for the --from/--to shortcut").option("--from <map>", "before map ID in --config workspace mode").option("--to <map>", "after map ID in --config workspace mode").option("--from-config <path>", "config path used as the before state").option("--to-config <path>", "config path used as the after state").option("--from-map <map>", "before map ID; required only when --from-config is multi-map").option("--to-map <map>", "after map ID; required only when --to-config is multi-map").option("--json", "print deterministic schema-version-1 JSON").action(
+    async (options) => runSemanticDiff(options, dependencies.defaultConfigPath)
+  );
+}
+async function runExplain(options, compileStyle) {
+  let selection;
+  try {
+    const output = await withTileflowConfigSecretsHidden(async () => {
+      const loaded = await loadTileflowConfigWithInputs(options.config);
+      const mapName = selectMap(loaded, options.map, "EXPLAIN");
+      const themeName = selectTheme(loaded, mapName, options.theme);
+      selection = { map: mapName, theme: themeName };
+      const prepared = await prepareTileflowCatalogIcons(loaded.project, {
+        assetBaseUrl: "/tileflow",
+        baseDirectory: dirname2(loaded.configFile),
+        cwd: process.cwd()
+      });
+      const authoredMap = loaded.authoringMaps[mapName] ?? loaded.project.maps[mapName];
+      const metadata = loaded.project.mapMetadata?.[mapName];
+      const result = compileStyle(authoredMap, {
+        apiBaseUrl: options.apiBaseUrl,
+        inspection: options.inspection,
+        map: metadata ? {
+          id: metadata.id,
+          lineage: metadata.lineage.map(({ id }) => id),
+          version: metadata.version
+        } : void 0,
+        preparedAssets: prepared.mapAssets[mapName],
+        theme: themeName
+      });
+      const structuredDiagnostics = result.diagnostics.length === 0 ? [] : createTileflowStructuredDiagnostics({ diagnostics: result.diagnostics }, process.cwd(), {
+        code: "COMPILATION_FAILED",
+        phase: "compilation"
+      });
+      const compilation = {
+        diagnostics: structuredDiagnostics.map(toSafeCompilationDiagnostic),
+        ok: result.ok,
+        report: result.report
+      };
+      return { compilation, result, structuredDiagnostics };
+    });
+    if (!selection) throw new Error("Explain selection was not resolved.");
+    if (!output.result.ok) {
+      const failure = createTileflowCommandFailureDocument(
+        "explain",
+        { diagnostics: output.structuredDiagnostics },
+        process.cwd(),
+        { code: "COMPILATION_FAILED", phase: "compilation" }
+      );
+      const document2 = {
+        ...failure,
+        authoringManifestSchemaVersion: tileflowAuthoringManifestSchemaVersion,
+        selection,
+        compilation: output.compilation
+      };
+      if (options.json) process.stderr.write(serializeTileflowCommandDocument(document2));
+      else printHumanExplainFailure(document2);
+      process.exitCode = 1;
+      return;
+    }
+    const summary = createTileflowCommandSummary({
+      code: "COMPILATION_EXPLAINED",
+      command: "explain",
+      message: `Compiled and explained ${selection.map}/${selection.theme}.`,
+      ok: true,
+      path: "",
+      phase: "compilation",
+      severity: "info",
+      suggestion: "Use the report targets and planner decisions to make semantic authoring edits."
+    });
+    const document = {
+      ...summary,
+      authoringManifestSchemaVersion: tileflowAuthoringManifestSchemaVersion,
+      selection,
+      compilation: output.compilation,
+      diagnostics: output.structuredDiagnostics
+    };
+    if (options.json) process.stdout.write(serializeTileflowCommandDocument(document));
+    else printHumanExplain(document);
+  } catch (error) {
+    const failure = createTileflowCommandFailureDocument("explain", error, process.cwd(), {
+      code: "EXPLAIN_FAILED",
+      phase: "compilation"
+    });
+    if (options.json) process.stderr.write(serializeTileflowCommandDocument(failure));
+    else printHumanCommandFailure(failure);
+    process.exitCode = 1;
+  }
+}
+async function runSemanticDiff(options, defaultConfigPath2) {
+  try {
+    const difference = await withTileflowConfigSecretsHidden(async () => {
+      const plan = createSemanticDiffPlan(options, defaultConfigPath2);
+      if (plan.mode === "configs") {
+        const fromLoaded = await loadTileflowConfigWithInputs(plan.fromConfig);
+        const fromName2 = selectConfigMap(fromLoaded, plan.fromMap, "from");
+        const toLoaded = await loadTileflowConfigWithInputs(plan.toConfig);
+        const toName2 = selectConfigMap(toLoaded, plan.toMap, "to");
+        return sanitizeSemanticDiff(
+          diffTileflowMaps(
+            fromLoaded.authoringMaps[fromName2] ?? fromLoaded.project.maps[fromName2],
+            toLoaded.authoringMaps[toName2] ?? toLoaded.project.maps[toName2]
+          ),
+          process.cwd()
+        );
+      }
+      const loaded = await loadTileflowConfigWithInputs(plan.config);
+      const fromName = selectExactMap(loaded, plan.from, "SEMANTIC_DIFF_FROM", "from");
+      const toName = selectExactMap(loaded, plan.to, "SEMANTIC_DIFF_TO", "to");
+      const difference2 = diffTileflowMaps(
+        loaded.authoringMaps[fromName] ?? loaded.project.maps[fromName],
+        loaded.authoringMaps[toName] ?? loaded.project.maps[toName]
+      );
+      return sanitizeSemanticDiff(difference2, process.cwd());
+    });
+    const summary = createTileflowCommandSummary({
+      code: "SEMANTIC_DIFF_READY",
+      command: "semantic-diff",
+      message: `Compared ${difference.from.id} to ${difference.to.id} (${difference.summary.total} semantic changes).`,
+      ok: true,
+      path: "",
+      phase: "semantic-diff",
+      severity: "info",
+      suggestion: difference.summary.total === 0 ? "The resolved semantic designs are equivalent." : "Apply changes by JSON Pointer through the public semantic module API."
+    });
+    const document = { ...summary, diff: difference, diagnostics: [] };
+    if (options.json) process.stdout.write(serializeTileflowCommandDocument(document));
+    else printHumanSemanticDiff(difference);
+  } catch (error) {
+    const failure = createTileflowCommandFailureDocument("semantic-diff", error, process.cwd(), {
+      code: "SEMANTIC_DIFF_FAILED",
+      phase: "semantic-diff"
+    });
+    if (options.json) process.stderr.write(serializeTileflowCommandDocument(failure));
+    else printHumanCommandFailure(failure);
+    process.exitCode = 1;
+  }
+}
+function createSemanticDiffPlan(options, defaultConfigPath2) {
+  const usesConfigPair = options.fromConfig !== void 0 || options.toConfig !== void 0;
+  if (usesConfigPair) {
+    const conflictingWorkspaceOption = [
+      ["config", options.config],
+      ["from", options.from],
+      ["to", options.to]
+    ].find((entry) => entry[1] !== void 0);
+    if (conflictingWorkspaceOption) {
+      throw commandSelectionError(
+        "SEMANTIC_DIFF_MODE_CONFLICT",
+        `--${conflictingWorkspaceOption[0]} cannot be combined with --from-config/--to-config; use either paired configs or the --config --from --to workspace shortcut.`,
+        conflictingWorkspaceOption[0]
+      );
+    }
+    if (!options.fromConfig) {
+      throw commandSelectionError(
+        "SEMANTIC_DIFF_FROM_CONFIG_REQUIRED",
+        "Paired-config mode requires --from-config <path>.",
+        "from-config"
+      );
+    }
+    if (!options.toConfig) {
+      throw commandSelectionError(
+        "SEMANTIC_DIFF_TO_CONFIG_REQUIRED",
+        "Paired-config mode requires --to-config <path>.",
+        "to-config"
+      );
+    }
+    return {
+      fromConfig: options.fromConfig,
+      ...options.fromMap === void 0 ? {} : { fromMap: options.fromMap },
+      mode: "configs",
+      toConfig: options.toConfig,
+      ...options.toMap === void 0 ? {} : { toMap: options.toMap }
+    };
+  }
+  const configSelector = options.fromMap === void 0 ? options.toMap : options.fromMap;
+  if (configSelector !== void 0) {
+    const path = options.fromMap === void 0 ? "to-map" : "from-map";
+    throw commandSelectionError(
+      "SEMANTIC_DIFF_MODE_CONFLICT",
+      `--${path} is valid only with --from-config and --to-config.`,
+      path
+    );
+  }
+  if (!options.from || !options.to) {
+    throw commandSelectionError(
+      "SEMANTIC_DIFF_SELECTION_REQUIRED",
+      "Workspace mode requires both --from <map> and --to <map>.",
+      !options.from ? "from" : "to"
+    );
+  }
+  return {
+    config: options.config ?? defaultConfigPath2,
+    from: options.from,
+    mode: "workspace",
+    to: options.to
+  };
+}
+function selectMap(loaded, requested, code) {
+  const mapNames = Object.keys(loaded.project.maps).sort(compareCodeUnits2);
+  if (requested) return selectExactMap(loaded, requested, `${code}_MAP`, "map");
+  if (mapNames.length === 1) return mapNames[0];
+  throw commandSelectionError(
+    `${code}_MAP_REQUIRED`,
+    `This config defines ${mapNames.length} maps; select one with --map. Available maps: ${mapNames.join(", ")}.`,
+    "map"
+  );
+}
+function selectConfigMap(loaded, requested, side) {
+  const mapNames = Object.keys(loaded.project.maps).sort(compareCodeUnits2);
+  const sideCode = side.toUpperCase();
+  const path = `${side}-map`;
+  if (mapNames.length === 1) {
+    if (requested === void 0) return mapNames[0];
+    throw commandSelectionError(
+      `SEMANTIC_DIFF_${sideCode}_MAP_UNNECESSARY`,
+      `--${path} is not valid because --${side}-config defines exactly one map (${mapNames[0]}).`,
+      path
+    );
+  }
+  if (requested === void 0) {
+    throw commandSelectionError(
+      `SEMANTIC_DIFF_${sideCode}_MAP_REQUIRED`,
+      `--${side}-config defines ${mapNames.length} maps; select one with --${path}. Available maps: ${mapNames.join(", ")}.`,
+      path
+    );
+  }
+  return selectExactMap(loaded, requested, `SEMANTIC_DIFF_${sideCode}_MAP`, path);
+}
+function selectExactMap(loaded, requested, code, path) {
+  if (Object.hasOwn(loaded.project.maps, requested)) return requested;
+  const mapNames = Object.keys(loaded.project.maps).sort(compareCodeUnits2);
+  throw commandSelectionError(
+    `${code}_NOT_FOUND`,
+    `Unknown Tileflow map "${requested}". Available maps: ${mapNames.join(", ") || "(none)"}.`,
+    path
+  );
+}
+function selectTheme(loaded, mapName, requested) {
+  const map = parseResolvedTileflowMap(loaded.project.maps[mapName]);
+  const themeNames = Object.keys(map.themes).sort(compareCodeUnits2);
+  const themeName = requested ?? map.defaultTheme;
+  if (Object.hasOwn(map.themes, themeName)) return themeName;
+  throw commandSelectionError(
+    "EXPLAIN_THEME_NOT_FOUND",
+    `Unknown theme "${themeName}" for map "${mapName}". Available themes: ${themeNames.join(", ")}.`,
+    "theme"
+  );
+}
+function commandSelectionError(code, message, path) {
+  return Object.assign(new Error(message), {
+    code,
+    issues: [{ code, message, path, phase: "command-validation" }],
+    phase: "command-validation"
+  });
+}
+function sanitizeSemanticDiff(difference, cwd) {
+  return {
+    ...difference,
+    changes: difference.changes.map((change) => ({
+      ...change,
+      path: sanitizeDiagnosticSecrets(change.path),
+      ..."before" in change ? {
+        before: sanitizeTileflowInspectableValue(
+          change.before,
+          cwd
+        )
+      } : {},
+      ..."after" in change ? {
+        after: sanitizeTileflowInspectableValue(change.after, cwd)
+      } : {}
+    }))
+  };
+}
+function toSafeCompilationDiagnostic(diagnostic) {
+  return {
+    code: diagnostic.code,
+    ...diagnostic.domain ? { domain: diagnostic.domain } : {},
+    message: diagnostic.message,
+    path: diagnostic.path,
+    phase: diagnostic.phase,
+    severity: diagnostic.severity === "info" ? "warning" : diagnostic.severity,
+    ...diagnostic.suggestion ? { suggestion: diagnostic.suggestion } : {},
+    ...diagnostic.target ? { target: diagnostic.target } : {}
+  };
+}
+function printHumanExplain(document) {
+  console.log(document.message);
+  const emitted = document.compilation.report.domains.filter(({ status }) => status === "emitted");
+  const suppressed = document.compilation.report.domains.length - emitted.length;
+  console.log(`Domains: ${emitted.length} emitted, ${suppressed} suppressed.`);
+  console.log(`Semantic targets: ${document.compilation.report.targets.length}.`);
+  for (const decision of document.compilation.report.planner) {
+    console.log(`Planner ${decision.stage}: ${decision.inputCount} -> ${decision.outputCount}.`);
+  }
+  console.log(
+    document.compilation.diagnostics.length === 0 ? "Diagnostics: none." : `Diagnostics: ${document.compilation.diagnostics.length}.`
+  );
+  console.log("Run tileflow explain --json for the complete machine-readable report.");
+}
+function printHumanExplainFailure(document) {
+  console.error(`${document.message} [${document.code}; ${document.phase}]`);
+  for (const diagnostic of document.compilation.diagnostics) {
+    console.error(`- ${diagnostic.path || "(root)"}: ${diagnostic.message}`);
+  }
+  console.error(`Suggestion: ${document.suggestion}`);
+}
+function printHumanSemanticDiff(difference) {
+  console.log(
+    `Compared ${difference.from.id}@${difference.from.version} to ${difference.to.id}@${difference.to.version}.`
+  );
+  console.log(
+    `Changes: ${difference.summary.total} (${difference.summary.add} add, ${difference.summary.remove} remove, ${difference.summary.change} change).`
+  );
+  for (const change of difference.changes) {
+    console.log(`${change.kind.padEnd(6)} ${change.path || "/"}`);
+  }
+}
+function printHumanCommandFailure(document) {
+  console.error(`${document.message} [${document.code}; ${document.phase}]`);
+  for (const diagnostic of document.diagnostics.slice(1)) {
+    console.error(`- ${diagnostic.path || "(root)"}: ${diagnostic.message}`);
+  }
+  console.error(`Suggestion: ${document.suggestion}`);
+}
+function compareCodeUnits2(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
 // src/capture-command.ts
 import { spawn } from "child_process";
 import { isAbsolute, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
@@ -277,7 +678,7 @@ import {
   TileflowVisualReviewError
 } from "@tileflow/capture";
 import {
-  compareCodeUnits as compareCodeUnits2,
+  compareCodeUnits as compareCodeUnits3,
   normalizeTileflowCaptureScene,
   tileflowCaptureSceneNameSchema,
   tileflowCaptureSceneSchema
@@ -293,12 +694,12 @@ import { TileflowStyleValidationError } from "@tileflow/dev/validation";
 // src/capture-output.ts
 import { randomUUID } from "crypto";
 import { lstat, mkdir as mkdir2, open as open2, readFile as readFile2, rename as rename2, unlink as unlink2 } from "fs/promises";
-import { basename, dirname as dirname2, relative, resolve as resolve2, sep } from "path";
+import { basename, dirname as dirname3, relative, resolve as resolve2, sep } from "path";
 var maximumAtomicArtifactBytes = 256 * 1024 * 1024;
 async function writeCapturePair(input) {
   const outputPath = resolve2(input.outputPath);
   const receiptPath = resolve2(input.receiptPath);
-  const boundaryPath = resolve2(input.boundaryPath ?? dirname2(outputPath));
+  const boundaryPath = resolve2(input.boundaryPath ?? dirname3(outputPath));
   if (outputPath === receiptPath) {
     throw new Error("Capture PNG and receipt paths must be different.");
   }
@@ -325,7 +726,7 @@ async function writeAtomicFileSet(input) {
     throw new Error(`${input.label} paths must be unique and include at least one file.`);
   }
   for (const path of targets) {
-    await assertNoSymlinkComponents(dirname2(path), boundaryPath);
+    await assertNoSymlinkComponents(dirname3(path), boundaryPath);
     await assertNotSymlink(path);
   }
   const existing = /* @__PURE__ */ new Map();
@@ -345,12 +746,12 @@ async function writeAtomicFileSet(input) {
     );
   }
   await Promise.all(
-    [...new Set(files.map((file) => dirname2(file.path)))].map(
+    [...new Set(files.map((file) => dirname3(file.path)))].map(
       (path) => mkdir2(path, { recursive: true })
     )
   );
   for (const path of targets) {
-    await assertNoSymlinkComponents(dirname2(path), boundaryPath);
+    await assertNoSymlinkComponents(dirname3(path), boundaryPath);
     await assertNotSymlink(path);
   }
   const transaction = `${process.pid}.${randomUUID()}`;
@@ -378,7 +779,7 @@ async function writeAtomicFileSet(input) {
       stateByPath.get(file.path).installed = true;
     }
     await Promise.all(
-      [...new Set(targets.map((path) => dirname2(path)))].map((path) => syncDirectory2(path))
+      [...new Set(targets.map((path) => dirname3(path)))].map((path) => syncDirectory2(path))
     );
     const cleanup = await Promise.allSettled(states.map((state) => removeOptional(state.backup)));
     cleanup.forEach((result, index) => {
@@ -415,7 +816,7 @@ async function writeAtomicFile(input) {
   const boundaryPath = resolve2(input.boundaryPath);
   const path = resolve2(input.path);
   const source = typeof input.source === "string" ? new TextEncoder().encode(input.source) : new Uint8Array(input.source);
-  await assertNoSymlinkComponents(dirname2(path), boundaryPath);
+  await assertNoSymlinkComponents(dirname3(path), boundaryPath);
   await assertNotSymlink(path);
   const existing = await readOptional(path);
   if (existing !== void 0 && Buffer.from(existing).equals(Buffer.from(source))) return false;
@@ -424,14 +825,14 @@ async function writeAtomicFile(input) {
       `${input.label} already exists with different contents. Use --force to replace it.`
     );
   }
-  await mkdir2(dirname2(path), { recursive: true });
-  await assertNoSymlinkComponents(dirname2(path), boundaryPath);
+  await mkdir2(dirname3(path), { recursive: true });
+  await assertNoSymlinkComponents(dirname3(path), boundaryPath);
   await assertNotSymlink(path);
   const temporary = temporarySibling(path, `${process.pid}.${randomUUID()}`, "new");
   try {
     await writeSyncedExclusive(temporary, source);
     await rename2(temporary, path);
-    await syncDirectory2(dirname2(path));
+    await syncDirectory2(dirname3(path));
     return true;
   } finally {
     await removeOptional(temporary);
@@ -466,7 +867,7 @@ async function assertBoundaryOrNearestExistingAncestorIsNotSymlink(path) {
       throw new Error("Capture paths cannot contain symbolic links.");
     }
     if (info) return;
-    const parent = dirname2(current);
+    const parent = dirname3(current);
     if (parent === current) return;
     current = parent;
   }
@@ -501,7 +902,7 @@ async function syncDirectory2(path) {
   }
 }
 function temporarySibling(path, transaction, role) {
-  return resolve2(dirname2(path), `.${basename(path)}.${transaction}.${role}.tmp`);
+  return resolve2(dirname3(path), `.${basename(path)}.${transaction}.${role}.tmp`);
 }
 async function readOptional(path) {
   const info = await lstatOptional(path);
@@ -532,52 +933,6 @@ function isMissingFile2(error) {
   return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
 }
 
-// src/config-execution.ts
-function hideTileflowConfigSecrets() {
-  const hadApiKey = Object.hasOwn(process.env, "TILEFLOW_API_KEY");
-  const apiKey = process.env.TILEFLOW_API_KEY;
-  const argv = [...process.argv];
-  let restored = false;
-  delete process.env.TILEFLOW_API_KEY;
-  replaceProcessArgv(stripApiKeyArguments(argv));
-  return {
-    restore() {
-      if (restored) return;
-      restored = true;
-      if (hadApiKey) {
-        process.env.TILEFLOW_API_KEY = apiKey;
-      } else {
-        delete process.env.TILEFLOW_API_KEY;
-      }
-      replaceProcessArgv(argv);
-    }
-  };
-}
-async function withTileflowConfigSecretsHidden(operation) {
-  const scope = hideTileflowConfigSecrets();
-  try {
-    return await operation();
-  } finally {
-    scope.restore();
-  }
-}
-function stripApiKeyArguments(argv) {
-  const sanitized = [];
-  for (let index = 0; index < argv.length; index += 1) {
-    const argument = argv[index];
-    if (argument === "--api-key") {
-      index += 1;
-      continue;
-    }
-    if (argument.startsWith("--api-key=")) continue;
-    sanitized.push(argument);
-  }
-  return sanitized;
-}
-function replaceProcessArgv(argv) {
-  process.argv.splice(0, process.argv.length, ...argv);
-}
-
 // src/capture-command.ts
 function registerCaptureCommands(program2, dependencies) {
   const setup = program2.command("setup").description("Provision local Tileflow tooling");
@@ -642,7 +997,7 @@ function createTileflowCaptureJson(captures, cwd) {
   return {
     schemaVersion: 1,
     command: "capture",
-    captures: [...captures].sort((left, right) => compareCodeUnits2(left.capture.scene, right.capture.scene)).map(({ capture, definition, outputPath, receiptPath }) => ({
+    captures: [...captures].sort((left, right) => compareCodeUnits3(left.capture.scene, right.capture.scene)).map(({ capture, definition, outputPath, receiptPath }) => ({
       scene: capture.scene,
       map: capture.map,
       theme: capture.theme,
@@ -657,7 +1012,7 @@ function createTileflowCaptureJson(captures, cwd) {
       dpr: capture.dpr,
       renderer: capture.renderer,
       networkDependent: capture.networkDependent,
-      warnings: [...capture.warnings].sort(compareCodeUnits2)
+      warnings: [...capture.warnings].sort(compareCodeUnits3)
     }))
   };
 }
@@ -898,7 +1253,13 @@ async function runCaptureWatchCommand(positionalScenes, options) {
       emit({ event: "recovered", generation: state.generation });
       invalidSinceLastReady = false;
     }
-    const task = captureGeneration(state.generation, state.artifacts, activeCapture.signal);
+    const acquisition = artifactSession.acquireArtifacts(state.generation);
+    if (!acquisition) return;
+    const task = captureGeneration(
+      state.generation,
+      acquisition.artifacts,
+      activeCapture.signal
+    ).finally(() => acquisition.release());
     activeTasks.add(task);
     void task.finally(() => activeTasks.delete(task));
   };
@@ -1185,8 +1546,8 @@ function runGit(cwd, args) {
 // src/config-inspect-command.ts
 import { inspectTileflowConfig } from "@tileflow/dev/inspect";
 import {
-  createTileflowCommandFailureDocument,
-  serializeTileflowCommandDocument
+  createTileflowCommandFailureDocument as createTileflowCommandFailureDocument2,
+  serializeTileflowCommandDocument as serializeTileflowCommandDocument2
 } from "@tileflow/dev/validation";
 function registerConfigInspectCommand(inspect, dependencies) {
   inspect.description("Inspect resolved maps, lineage, and merge provenance").option("-c, --config <path>", "config path", dependencies.defaultConfigPath).option("--map <name>", "inspect one exact configured map").option("--json", "print deterministic schema-version-1 JSON").action(async (options) => {
@@ -1195,17 +1556,17 @@ function registerConfigInspectCommand(inspect, dependencies) {
         () => inspectTileflowConfig({ config: options.config, cwd: process.cwd(), map: options.map })
       );
       if (options.json) {
-        process.stdout.write(serializeTileflowCommandDocument(document));
+        process.stdout.write(serializeTileflowCommandDocument2(document));
         return;
       }
       printHumanConfigInspection(document);
     } catch (error) {
-      const failure = createTileflowCommandFailureDocument("inspect", error, process.cwd(), {
+      const failure = createTileflowCommandFailureDocument2("inspect", error, process.cwd(), {
         code: "INSPECTION_FAILED",
         phase: "config-inspection"
       });
       if (options.json) {
-        process.stderr.write(serializeTileflowCommandDocument(failure));
+        process.stderr.write(serializeTileflowCommandDocument2(failure));
       } else {
         console.error(`${failure.message} [${failure.code}; ${failure.phase}]`);
         for (const diagnostic of failure.diagnostics.slice(1)) {
@@ -1378,13 +1739,13 @@ function tileflowDevOrigin(host, port) {
 }
 
 // src/feature-inspect-command.ts
-import { dirname as dirname3 } from "path";
+import { dirname as dirname4 } from "path";
 import {
   getFirstTileflowMapName,
   loadValidTileflowConfigWithInputs,
   TileflowValidationError as TileflowValidationError2
 } from "@tileflow/dev/config";
-import { prepareTileflowCatalogIcons } from "@tileflow/dev/icons";
+import { prepareTileflowCatalogIcons as prepareTileflowCatalogIcons2 } from "@tileflow/dev/icons";
 import { inspectTileflowFeatures } from "@tileflow/dev/inspect";
 function registerFeatureInspectCommand(inspect, dependencies) {
   inspect.command("features").description("Inspect bounded vector features near a map camera").requiredOption("--center <longitude,latitude>", "camera center").requiredOption("--zoom <number>", "camera zoom from 0 to 24").requiredOption("--layers <names>", "comma-separated source-layer names").option(
@@ -1419,9 +1780,9 @@ async function runFeatureInspect(options) {
   );
   const project = loaded.project;
   const mapName = options.map ?? getFirstTileflowMapName(project);
-  const prepared = await prepareTileflowCatalogIcons(project, {
+  const prepared = await prepareTileflowCatalogIcons2(project, {
     assetBaseUrl: "/tileflow",
-    baseDirectory: dirname3(loaded.configFile),
+    baseDirectory: dirname4(loaded.configFile),
     cwd: process.cwd()
   });
   const inspection = await inspectTileflowFeatures(project, mapName, {
@@ -1514,7 +1875,7 @@ var publicHttpUrlSchema = z2.url().max(2048).refine((value) => {
 var hostedStyleDeploymentResponseSchema = z2.object({
   changed: z2.boolean().optional(),
   deploymentId: safeIdentifierSchema.optional(),
-  mapId: safeIdentifierSchema,
+  mapId: z2.string().regex(/^map_[A-Za-z0-9_-]{16}$/u),
   themes: z2.record(
     safeIdentifierSchema,
     z2.object({
@@ -1522,8 +1883,7 @@ var hostedStyleDeploymentResponseSchema = z2.object({
       styleUrl: publicHttpUrlSchema
     }).strict()
   ).refine((themes) => Object.keys(themes).length > 0),
-  version: z2.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
-  worldPromotionId: safeIdentifierSchema.optional()
+  version: z2.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional()
 }).strict();
 var hostedIconPackageResponseSchema = z2.object({
   changed: z2.boolean().optional(),
@@ -1548,8 +1908,8 @@ var hostedStatusStyleSchema = z2.object({
   size: z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
   uploaded: z2.iso.datetime({ offset: true })
 });
-var hostedProjectStatusSchema = z2.object({
-  projectId: safeIdentifierSchema,
+var hostedMapStatusSchema = z2.object({
+  mapId: z2.string().regex(/^map_[A-Za-z0-9_-]{16}$/u),
   styles: z2.array(hostedStatusStyleSchema).max(1e4)
 });
 async function readBoundedResponseText(response, label) {
@@ -1685,7 +2045,7 @@ async function validateApiKey(apiUrl, apiKey, options = {}) {
     return { error: `API key validation failed (${response.status}).`, ok: false };
   }
   const body = asRecord(response.body);
-  if (!response.json || typeof body.apiKeyId !== "string" || body.credentialType !== "project_api_key" || !isProjectIdentity(body.organization) || !isProjectIdentity(body.project) || typeof body.projectId !== "string" || body.projectId !== body.project.id || !Array.isArray(body.scopes)) {
+  if (!response.json || typeof body.apiKeyId !== "string" || body.credentialType !== "project_api_key" || typeof body.mapId !== "string" || !/^map_[A-Za-z0-9_-]{16}$/u.test(body.mapId) || !isProjectIdentity(body.organization) || !isProjectIdentity(body.project) || typeof body.projectId !== "string" || body.projectId !== body.project.id || !Array.isArray(body.scopes)) {
     return { error: "API key validation returned an invalid response.", ok: false };
   }
   return {
@@ -1693,6 +2053,7 @@ async function validateApiKey(apiUrl, apiKey, options = {}) {
     value: {
       apiKeyId: body.apiKeyId,
       credentialType: body.credentialType,
+      mapId: body.mapId,
       organization: body.organization,
       project: body.project,
       projectId: body.projectId,
@@ -1700,6 +2061,33 @@ async function validateApiKey(apiUrl, apiKey, options = {}) {
     }
   };
 }
+async function requestMapCapability(session, target, scopes, options = {}) {
+  let response;
+  try {
+    response = await requestHostedJson(
+      session.apiOrigin,
+      "/v1/cli/map-capabilities",
+      {
+        ...jsonRequest("POST", { ...target, scopes }),
+        headers: {
+          ...authorizationHeaders(session.accountSession),
+          "Content-Type": "application/json"
+        }
+      },
+      options
+    );
+  } catch (error) {
+    return { error: safeTransportError(error, "Map capability request failed."), ok: false };
+  }
+  if (!response.ok) {
+    return { error: `Map capability request failed (${response.status}).`, ok: false };
+  }
+  const body = asRecord(response.body);
+  if (!response.json || typeof body.capability !== "string" || !body.capability.startsWith("tf_cap_") || body.capability.length > 8192 || typeof body.mapId !== "string" || !/^map_[A-Za-z0-9_-]{16}$/u.test(body.mapId) || body.mapId !== target.mapId || !validIsoDate(body.expiresAt) || !Array.isArray(body.scopes) || body.scopes.join("\0") !== [...scopes].sort().join("\0")) {
+    return { error: "Map capability response was invalid.", ok: false };
+  }
+  return { capability: body.capability, mapId: body.mapId, ok: true };
+}
 async function requestProjectCapability(session, project, scopes, options = {}) {
   let response;
   try {
@@ -1730,6 +2118,53 @@ async function requestProjectCapability(session, project, scopes, options = {})
   }
   return { capability: body.capability, ok: true };
 }
+async function requestTeamCapability(session, team, scopes, options = {}) {
+  let response;
+  try {
+    response = await requestHostedJson(
+      session.apiOrigin,
+      "/v1/cli/team-capabilities",
+      {
+        ...jsonRequest("POST", { scopes, team }),
+        headers: {
+          ...authorizationHeaders(session.accountSession),
+          "Content-Type": "application/json"
+        }
+      },
+      options
+    );
+  } catch (error) {
+    return { error: safeTransportError(error, "Team capability request failed."), ok: false };
+  }
+  if (!response.ok) {
+    return { error: `Team capability request failed (${response.status}).`, ok: false };
+  }
+  const body = asRecord(response.body);
+  if (!response.json || body.schemaVersion !== 1 || typeof body.capability !== "string" || !body.capability.startsWith("tf_cap_") || body.capability.length > 8192 || body.reference !== team || !isProjectIdentity(body.team) || `@${body.team.slug}` !== team || !validIsoDate(body.expiresAt) || !Array.isArray(body.scopes) || body.scopes.join("\0") !== [...scopes].sort().join("\0")) {
+    return { error: "Team capability response was invalid.", ok: false };
+  }
+  return { capability: body.capability, ok: true, team: body.team };
+}
+async function listAccountTeams(session, options = {}) {
+  const response = await requestHostedJson(
+    session.apiOrigin,
+    "/v1/cli/teams",
+    { headers: authorizationHeaders(session.accountSession) },
+    options
+  );
+  const body = asRecord(response.body);
+  if (!response.ok) return { error: `Team discovery failed (${response.status}).`, ok: false };
+  if (!response.json || body.schemaVersion !== 1 || !Array.isArray(body.teams) || !body.teams.every(isProjectIdentity)) {
+    return { error: "Team discovery returned an invalid response.", ok: false };
+  }
+  const teams = [...body.teams].sort(
+    (left, right) => left.slug < right.slug ? -1 : left.slug > right.slug ? 1 : 0
+  );
+  if (new Set(teams.map(({ id }) => id)).size !== teams.length || teams.some((team, index) => index > 0 && teams[index - 1].slug >= team.slug)) {
+    return { error: "Team discovery returned unstable ordering.", ok: false };
+  }
+  return { ok: true, teams };
+}
 async function publishHostedStyle(api, body, responseLabel, options = {}) {
   const response = await requestHostedJson(
     api.apiUrl,
@@ -1816,7 +2251,7 @@ async function uploadHostedFontBundle(api, bundle, options = {}) {
   }
   return { ok: true, value };
 }
-async function fetchHostedProjectStatus(api, options = {}) {
+async function fetchHostedMapStatus(api, options = {}) {
   const response = await requestHostedJson(
     api.apiUrl,
     "/v1/status",
@@ -1824,7 +2259,7 @@ async function fetchHostedProjectStatus(api, options = {}) {
     options
   );
   if (!response.ok) throw new Error(`Status failed: ${response.status}.`);
-  return parseResponse(response, hostedProjectStatusSchema, "Status response");
+  return parseResponse(response, hostedMapStatusSchema, "Status response");
 }
 async function revokeHostedAccountSession(apiUrl, accountSession, options = {}) {
   try {
@@ -1981,20 +2416,54 @@ function safeTransportError(error, fallback) {
 }
 
 // src/hosted-preflight.ts
-import { compareCodeUnits as compareCodeUnits3, tileflowHostedAlphaCompatibility } from "@tileflow/core";
-function inspectTileflowHostedCompatibility(project, styles) {
-  const issues = [];
-  const mapNames = Object.keys(project.maps).sort(compareCodeUnits3);
-  if (mapNames.length > tileflowHostedAlphaCompatibility.maxMapsPerDeploy) {
-    issues.push({
-      message: `Hosted alpha accepts at most ${tileflowHostedAlphaCompatibility.maxMapsPerDeploy} maps per deploy.`,
-      path: "maps"
-    });
-  }
-  for (const mapName of [...mapNames].sort(compareCodeUnits3)) {
-    const themes = styles[mapName] ?? {};
-    for (const themeName of Object.keys(themes).sort(compareCodeUnits3)) {
-      const data = themes[themeName]?.metadata?.["tileflow:data"];
+import {
+  compareCodeUnits as compareCodeUnits4,
+  tileflowHostedAlphaCompatibility
+} from "@tileflow/core";
+function prepareTileflowHostedThemeFamily(mapName, map, styles) {
+  const prepared = Object.fromEntries(
+    Object.entries(styles).sort(([left], [right]) => compareCodeUnits4(left, right)).map(([themeName, style]) => [themeName, cloneStyle(style)])
+  );
+  const teamSources = Object.fromEntries(
+    Object.entries(map.sources ?? {}).sort(([left], [right]) => compareCodeUnits4(left, right)).map(([sourceId, source]) => {
+      for (const [themeName, style] of Object.entries(prepared)) {
+        const definition = style.sources[sourceId];
+        if (!definition) {
+          throw Object.assign(
+            new Error(`Hosted theme ${themeName} is missing logical source ${sourceId}.`),
+            {
+              code: "TF_HOSTED_SOURCE_MISSING",
+              path: `maps.${mapName}.themes.${themeName}.sources.${sourceId}`
+            }
+          );
+        }
+        definition.url = `tileflow://hosted-sources/${sourceId}`;
+        delete definition.tiles;
+      }
+      return [
+        sourceId,
+        Object.freeze({
+          tileset: source.tileset,
+          type: source.type
+        })
+      ];
+    })
+  );
+  return { styles: prepared, teamSources };
+}
+function inspectTileflowHostedCompatibility(project, styles) {
+  const issues = [];
+  const mapNames = Object.keys(project.maps).sort(compareCodeUnits4);
+  if (mapNames.length > tileflowHostedAlphaCompatibility.maxMapsPerDeploy) {
+    issues.push({
+      message: `Hosted alpha accepts at most ${tileflowHostedAlphaCompatibility.maxMapsPerDeploy} maps per deploy.`,
+      path: "maps"
+    });
+  }
+  for (const mapName of [...mapNames].sort(compareCodeUnits4)) {
+    const themes = styles[mapName] ?? {};
+    for (const themeName of Object.keys(themes).sort(compareCodeUnits4)) {
+      const data = themes[themeName]?.metadata?.["tileflow:data"];
       if (!data || typeof data !== "object" || Array.isArray(data) || data.kind !== "tileflow-world") {
         issues.push({
           map: mapName,
@@ -2006,9 +2475,12 @@ function inspectTileflowHostedCompatibility(project, styles) {
   }
   return issues;
 }
+function cloneStyle(style) {
+  return JSON.parse(JSON.stringify(style));
+}
 
 // src/icon-diff-command.ts
-import { dirname as dirname5, resolve as resolve4 } from "path";
+import { dirname as dirname6, resolve as resolve4 } from "path";
 import { z as z4 } from "zod";
 import {
   diffTileflowIconPackageManifests,
@@ -2022,17 +2494,17 @@ import {
 import {
   assertValidTileflowConfig,
   getTileflowMapNames,
-  loadTileflowConfigWithInputs
+  loadTileflowConfigWithInputs as loadTileflowConfigWithInputs2
 } from "@tileflow/dev/config";
 import { compileTileflowIconPackages } from "@tileflow/dev/icons";
 
 // src/icon-diff-report.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { mkdir as mkdir3, readFile as readFile3, rename as rename3, unlink as unlink3, writeFile } from "fs/promises";
-import { basename as basename2, dirname as dirname4, join } from "path";
+import { basename as basename2, dirname as dirname5, join } from "path";
 import { z as z3 } from "zod";
 import {
-  compareCodeUnits as compareCodeUnits4,
+  compareCodeUnits as compareCodeUnits5,
   sha256Hex,
   tileflowIconIdSchema,
   tileflowIconPackageLimits as tileflowIconPackageLimits2
@@ -2153,9 +2625,9 @@ async function readBoundedResponse(response, exactMaximum) {
 }
 function renderReport(document, before, after, mapName) {
   const changeGroups = [
-    { id: "added", label: "Added", names: [...document.icons.added].sort(compareCodeUnits4) },
-    { id: "modified", label: "Modified", names: [...document.icons.modified].sort(compareCodeUnits4) },
-    { id: "removed", label: "Removed", names: [...document.icons.removed].sort(compareCodeUnits4) }
+    { id: "added", label: "Added", names: [...document.icons.added].sort(compareCodeUnits5) },
+    { id: "modified", label: "Modified", names: [...document.icons.modified].sort(compareCodeUnits5) },
+    { id: "removed", label: "Removed", names: [...document.icons.removed].sort(compareCodeUnits5) }
   ];
   const changedCount = changeGroups.reduce((total, group) => total + group.names.length, 0);
   const beforeIconCount = document.icons.unchangedCount + document.icons.modified.length + document.icons.removed.length;
@@ -2500,9 +2972,9 @@ async function writeAtomicReport(path, html, force) {
   } catch (error) {
     if (!isMissingFile3(error)) throw error;
   }
-  await mkdir3(dirname4(path), { recursive: true });
+  await mkdir3(dirname5(path), { recursive: true });
   const temporaryPath = join(
-    dirname4(path),
+    dirname5(path),
     `.${basename2(path)}.${process.pid}.${randomUUID2()}.tmp`
   );
   try {
@@ -2583,7 +3055,7 @@ var tileflowIconDiffDocumentSchema = z4.object({
   hasChanges: z4.boolean()
 }).strict();
 function registerIconDiffCommand(icons, dependencies) {
-  icons.command("diff").description("Preview a local icon package against an active hosted revision").requiredOption("--against <environment>", "named map environment to compare").option("-c, --config <path>", "config path", dependencies.defaultConfigPath).option("--api-url <url>", "Tileflow API URL", process.env.TILEFLOW_API_URL).option("--api-key <key>", "Tileflow API key", process.env.TILEFLOW_API_KEY).option("--project <target>", "technical destination @organization/project").option("--json", "print deterministic schema-version-1 JSON").option("--report <path>", "write a self-contained HTML visual report").option("--open", "open an explicitly requested report").option("--force", "replace a different explicitly requested report").action(async (options) => {
+  icons.command("diff").description("Preview a local icon package against an active hosted revision").requiredOption("--against <environment>", "named map environment to compare").option("-c, --config <path>", "config path", dependencies.defaultConfigPath).option("--api-url <url>", "Tileflow API URL", process.env.TILEFLOW_API_URL).option("--api-key <key>", "Tileflow API key", process.env.TILEFLOW_API_KEY).requiredOption("--map-id <id>", "managed Map destination").option("--json", "print deterministic schema-version-1 JSON").option("--report <path>", "write a self-contained HTML visual report").option("--open", "open an explicitly requested report").option("--force", "replace a different explicitly requested report").action(async (options) => {
     try {
       await runIconDiff(options, dependencies);
     } catch (error) {
@@ -2603,12 +3075,8 @@ async function runIconDiff(options, dependencies) {
     throw new Error("--force requires --report <path>");
   }
   const environment = environmentSchema.parse(options.against);
-  const api = await dependencies.resolveApi(options);
-  if (!api) {
-    throw new Error("Missing Tileflow API key. Run tileflow login or set TILEFLOW_API_KEY.");
-  }
   const loaded = await withTileflowConfigSecretsHidden(
-    () => loadTileflowConfigWithInputs(options.config)
+    () => loadTileflowConfigWithInputs2(options.config)
   );
   const project = loaded.project;
   assertValidTileflowConfig(project);
@@ -2618,9 +3086,13 @@ async function runIconDiff(options, dependencies) {
       `Unknown map environment "${environment}". Available maps: ${mapNames.join(", ") || "(none)"}`
     );
   }
+  const api = await dependencies.resolveApi(options);
+  if (!api) {
+    throw new Error("Missing Tileflow API key. Run tileflow login or set TILEFLOW_API_KEY.");
+  }
   const selectedProject = { ...project, maps: { [environment]: project.maps[environment] } };
   const compiled = await compileTileflowIconPackages(selectedProject, {
-    baseDirectory: dirname5(loaded.configFile),
+    baseDirectory: dirname6(loaded.configFile),
     cwd: process.cwd(),
     target: "hosted"
   });
@@ -2763,8 +3235,8 @@ function formatSignedBytes(bytes) {
 }
 
 // src/icon-list-command.ts
-import { dirname as dirname6 } from "path";
-import { compareCodeUnits as compareCodeUnits5 } from "@tileflow/core";
+import { dirname as dirname7 } from "path";
+import { compareCodeUnits as compareCodeUnits6 } from "@tileflow/core";
 import {
   getTileflowMapNames as getTileflowMapNames2,
   loadValidTileflowConfigWithInputs as loadValidTileflowConfigWithInputs2,
@@ -2795,7 +3267,7 @@ function createTileflowIconListJson(inspection) {
   return {
     schemaVersion: 2,
     pathBase: "cwd",
-    maps: [...inspection.maps].sort((left, right) => compareCodeUnits5(left.name, right.name)).map((map) => createMapJson(map, inspection.catalogs))
+    maps: [...inspection.maps].sort((left, right) => compareCodeUnits6(left.name, right.name)).map((map) => createMapJson(map, inspection.catalogs))
   };
 }
 function serializeTileflowIconListJson(value) {
@@ -2807,14 +3279,14 @@ async function runIconList(options) {
     () => loadValidTileflowConfigWithInputs2(options.config)
   );
   const project = loaded.project;
-  const mapIds = getTileflowMapNames2(project).sort(compareCodeUnits5);
+  const mapIds = getTileflowMapNames2(project).sort(compareCodeUnits6);
   if (options.map && !Object.hasOwn(project.maps, options.map)) {
     throw new Error(
       `Unknown map "${options.map}". Available maps: ${mapIds.join(", ") || "(none)"}`
     );
   }
   const inspection = await inspectTileflowIconCatalogs(project, {
-    baseDirectory: dirname6(loaded.configFile),
+    baseDirectory: dirname7(loaded.configFile),
     cwd: process.cwd(),
     ...options.map ? { mapNames: [options.map] } : {}
   });
@@ -2844,7 +3316,7 @@ function createMapJson(map, catalogs) {
         winner: replacement.winner
       })),
       packageHash: mapIcons.packageHash,
-      sources: [...catalog.icons].sort((left, right) => compareCodeUnits5(left.id, right.id)).map((icon) => ({
+      sources: [...catalog.icons].sort((left, right) => compareCodeUnits6(left.id, right.id)).map((icon) => ({
         id: icon.id,
         path: icon.source.path,
         format: icon.source.format,
@@ -2874,6 +3346,83 @@ function printIssues(heading, issues) {
   );
 }
 
+// src/language-command.ts
+import { readFile as readFile4 } from "fs/promises";
+import { fileURLToPath } from "url";
+import {
+  serializeCanonicalJson,
+  tileflowAuthoringManifest
+} from "@tileflow/core";
+import {
+  createTileflowCommandFailureDocument as createTileflowCommandFailureDocument3,
+  serializeTileflowCommandDocument as serializeTileflowCommandDocument3
+} from "@tileflow/dev/validation";
+function registerLanguageCommand(program2, dependencies = {}) {
+  const language = program2.command("language").description("Inspect the complete machine-readable Tileflow semantic language");
+  language.command("manifest").description("Print the semantic compiler authoring manifest").option("--json", "print deterministic JSON").action(
+    async (options) => runLanguageCommand(
+      "language-manifest",
+      options,
+      () => printManifest((dependencies.loadManifest ?? (() => tileflowAuthoringManifest))(), options)
+    )
+  );
+  language.command("schema").description("Print the generated authoring and resolved JSON Schema").option("--json", "print deterministic JSON").action(
+    async (options) => runLanguageCommand(
+      "language-schema",
+      options,
+      async () => printSchema(await (dependencies.loadSchema ?? loadPackagedSchema)(), options)
+    )
+  );
+}
+async function runLanguageCommand(command2, options, operation) {
+  try {
+    await operation();
+  } catch (error) {
+    const failure = createTileflowCommandFailureDocument3(command2, error, process.cwd(), {
+      code: command2 === "language-manifest" ? "LANGUAGE_MANIFEST_FAILED" : "LANGUAGE_SCHEMA_FAILED",
+      phase: "language-discovery"
+    });
+    if (options.json) process.stderr.write(serializeTileflowCommandDocument3(failure));
+    else {
+      console.error(`${failure.message} [${failure.code}; ${failure.phase}]`);
+      console.error(`Suggestion: ${failure.suggestion}`);
+    }
+    process.exitCode = 1;
+  }
+}
+function printManifest(manifest, options) {
+  if (options.json) {
+    process.stdout.write(`${serializeCanonicalJson(manifest)}
+`);
+    return;
+  }
+  console.log(
+    `${manifest.language} (${manifest.compiler.name} v${manifest.compiler.version}); ${manifest.domains.length} domains, ${manifest.expressions.builders.length} expression builders.`
+  );
+  console.log("Run tileflow language manifest --json for the complete machine-readable document.");
+}
+function printSchema(schema, options) {
+  if (options.json) {
+    process.stdout.write(`${serializeCanonicalJson(schema)}
+`);
+    return;
+  }
+  console.log(
+    `Tileflow config reference schema ${String(schema.schemaVersion)}: ${String(schema.$id)}.`
+  );
+  console.log("Run tileflow language schema --json for the complete machine-readable document.");
+}
+async function loadPackagedSchema() {
+  const schemaUrl = import.meta.resolve("@tileflow/core/config-reference.json");
+  const parsed = JSON.parse(await readFile4(fileURLToPath(schemaUrl), "utf8"));
+  if (!isRecord(parsed))
+    throw new Error("Packaged Tileflow config reference is not a JSON object.");
+  return parsed;
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
 // src/open-external.ts
 import { spawn as spawnChild } from "child_process";
 import { platform as hostPlatform } from "os";
@@ -3050,147 +3599,1233 @@ async function fetchAccountProjects(session, includeArchived) {
     if (!Array.isArray(body.items) || !body.items.every(isAccountProjectTarget)) {
       return { error: "Destination discovery returned an invalid response.", ok: false, status: 502 };
     }
-    items.push(...body.items);
-    cursor = typeof body.nextCursor === "string" ? body.nextCursor : null;
-    if (!cursor) return validateTargetOrder(items);
-  }
-  return { error: "Destination discovery exceeded its safe page limit.", ok: false, status: 502 };
+    items.push(...body.items);
+    cursor = typeof body.nextCursor === "string" ? body.nextCursor : null;
+    if (!cursor) return validateTargetOrder(items);
+  }
+  return { error: "Destination discovery exceeded its safe page limit.", ok: false, status: 502 };
+}
+async function resolveAccountProjectTarget(session, requestedProject) {
+  const result = await fetchAccountProjects(session, false);
+  if (!result.ok) return { error: result.error, kind: "remote", status: result.status };
+  if (requestedProject) {
+    const parsed = parseProjectReference(requestedProject);
+    if (!parsed) return { kind: "invalid", targets: result.items };
+    const target = result.items.find((candidate) => candidate.reference === requestedProject);
+    return target ? { kind: "selected", target } : { kind: "missing", targets: result.items };
+  }
+  if (result.items.length === 1) return { kind: "selected", target: result.items[0] };
+  return result.items.length ? { kind: "ambiguous", targets: result.items } : { kind: "missing", targets: [] };
+}
+async function requireCommandSession(options, dependencies) {
+  let config;
+  try {
+    config = await dependencies.loadAuthConfig();
+  } catch (error) {
+    emitLocalFailure(options.json, "auth_state_unavailable", safeMessage(error));
+    return null;
+  }
+  const resolved = resolveAccountSession(config, options.apiUrl ?? dependencies.defaultApiUrl);
+  if (resolved.kind !== "selected") {
+    emitLocalFailure(
+      options.json,
+      `account_session_${resolved.kind}`,
+      resolved.kind === "expired" ? "The Tileflow account session has expired. Run tileflow login." : "Not logged in. Run tileflow login."
+    );
+    return null;
+  }
+  return resolved.session;
+}
+async function accountRequest(session, path, init) {
+  let response;
+  try {
+    response = await requestHostedJson(session.apiOrigin, path, {
+      ...init,
+      headers: { ...init.headers, Authorization: `Bearer ${session.accountSession}` }
+    });
+  } catch (error) {
+    return {
+      body: null,
+      error: error instanceof Error && /safe size limit|timed out/u.test(error.message) ? error.message : "Hosted request failed.",
+      ok: false,
+      status: 502
+    };
+  }
+  if (response.ok && !response.json) {
+    return {
+      body: null,
+      error: "Hosted response returned invalid JSON.",
+      ok: false,
+      status: 502
+    };
+  }
+  return response.ok ? { body: response.body, ok: true, status: response.status } : {
+    body: response.body,
+    error: `Request failed (${response.status}).`,
+    ok: false,
+    status: response.status
+  };
+}
+function validateTargetOrder(items) {
+  const references = items.map((item) => item.reference);
+  if (new Set(references).size !== references.length || references.some((reference, index) => index > 0 && references[index - 1] >= reference)) {
+    return {
+      error: "Destination discovery returned unstable ordering.",
+      ok: false,
+      status: 502
+    };
+  }
+  return { items, ok: true };
+}
+function uniqueOrganizations(items) {
+  return [...new Map(items.map((item) => [item.organization.id, item.organization])).values()];
+}
+function parseOrganizationReference(value) {
+  if (!value) return null;
+  const match = /^@([A-Za-z0-9][A-Za-z0-9._-]{0,127})$/u.exec(value);
+  return match?.[1] ?? null;
+}
+function emitAmbiguousOrganizations(json, organizations, slug, name) {
+  const references = organizations.map((organization) => `@${organization.slug}`);
+  const retry = `tileflow projects create ${slug} --name ${JSON.stringify(name.trim())} --organization ${references[0]}`;
+  return emitLocalFailure(
+    json,
+    "organization_ambiguous",
+    `More than one organization is available: ${references.join(", ")}. Retry with: ${retry}`,
+    { options: references, retry }
+  );
+}
+function emitRemoteFailure(json, result) {
+  return emitLocalFailure(json, `http_${result.status}`, result.error);
+}
+function emitLocalFailure(json, code, message, details = {}) {
+  if (json) {
+    console.error(message);
+    emitJson({ schemaVersion: 1, ok: false, error: { code, ...details } });
+  } else {
+    console.error(`${pc.red("\u2715")} ${message}`);
+  }
+  process.exitCode = 1;
+}
+function emitJson(value) {
+  process.stdout.write(`${JSON.stringify(value)}
+`);
+}
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function isAccountProjectTarget(value) {
+  const target = asRecord2(value);
+  return isIdentity(target.organization) && isProjectItem(target.project) && typeof target.reference === "string" && target.reference === `@${target.organization.slug}/${target.project.slug}`;
+}
+function isIdentity(value) {
+  const identity = asRecord2(value);
+  return typeof identity.id === "string" && typeof identity.name === "string" && typeof identity.slug === "string";
+}
+function isProjectItem(value) {
+  const item = asRecord2(value);
+  return isIdentity(value) && (item.archivedAt === null || typeof item.archivedAt === "string") && typeof item.createdAt === "string" && typeof item.updatedAt === "string";
+}
+function validSlug(value) {
+  return /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(value);
+}
+function validName(value) {
+  const normalized = value.trim();
+  return normalized.length > 0 && normalized.length <= 200 && !/[\p{Cc}]/u.test(normalized);
+}
+function safeMessage(error) {
+  return error instanceof Error && error.message.length <= 300 ? error.message : "Tileflow auth state is unavailable.";
+}
+
+// src/tileset-command.ts
+import pc2 from "picocolors";
+import { serializeCanonicalJson as serializeCanonicalJson3 } from "@tileflow/core";
+import { inspectTileflowPmtiles } from "@tileflow/dev/tilesets";
+import { z as z6 } from "zod";
+
+// src/tileset-upload.ts
+import { createHash } from "crypto";
+import { open as open3, stat } from "fs/promises";
+import { z as z5 } from "zod";
+import { serializeCanonicalJson as serializeCanonicalJson2 } from "@tileflow/core";
+var teamTilesetPartSize = 16777216;
+var maximumTeamTilesetBytes = 4e9;
+var authorizationBatchSize = 16;
+var uploadConcurrency = 4;
+var maximumPartAttempts = 4;
+var maximumControlAttempts = 4;
+var maximumInitiatingWaitMs = 2 * 60 * 1e3;
+var partTransferTimeoutMs = 10 * 60 * 1e3;
+var authorizationClockSkewMs = 3e4;
+var minimumPartAuthorizationLifetimeMs = partTransferTimeoutMs + authorizationClockSkewMs;
+var TeamTilesetUploadError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "TeamTilesetUploadError";
+    this.code = code;
+    this.details = details;
+  }
+};
+function createTeamTilesetPartLayout(byteCount) {
+  if (!Number.isSafeInteger(byteCount) || byteCount < 1 || byteCount > maximumTeamTilesetBytes) {
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_VERSION_TOO_LARGE",
+      "PMTiles archive exceeds the 4,000,000,000-byte platform maximum.",
+      {
+        actualBytes: Number.isSafeInteger(byteCount) && byteCount >= 0 ? byteCount : 0,
+        limitBytes: maximumTeamTilesetBytes
+      }
+    );
+  }
+  return Object.freeze(
+    Array.from({ length: Math.ceil(byteCount / teamTilesetPartSize) }, (_, index) => {
+      const position = index * teamTilesetPartSize;
+      return Object.freeze({
+        byteCount: Math.min(teamTilesetPartSize, byteCount - position),
+        partNumber: index + 1,
+        position
+      });
+    })
+  );
+}
+async function inspectNodeTeamTilesetArchive(path) {
+  let value;
+  try {
+    value = await stat(path, { bigint: true });
+  } catch {
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_ARCHIVE_INVALID",
+      "PMTiles archive is unavailable."
+    );
+  }
+  if (!value.isFile()) {
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_ARCHIVE_INVALID",
+      "PMTiles archive must be a file."
+    );
+  }
+  return checkedIdentity(value.dev, value.ino, value.mtimeNs, value.size);
+}
+async function openNodeTeamTilesetArchive(path, expectedIdentity) {
+  const handle = await open3(path, "r");
+  const identity = async () => {
+    let pathStat;
+    let handleStat;
+    try {
+      [pathStat, handleStat] = await Promise.all([
+        stat(path, { bigint: true }),
+        handle.stat({ bigint: true })
+      ]);
+    } catch {
+      throw localFileChanged();
+    }
+    if (!pathStat.isFile() || !handleStat.isFile()) throw localFileChanged();
+    const pathIdentity = checkedIdentity(
+      pathStat.dev,
+      pathStat.ino,
+      pathStat.mtimeNs,
+      pathStat.size
+    );
+    const handleIdentity = checkedIdentity(
+      handleStat.dev,
+      handleStat.ino,
+      handleStat.mtimeNs,
+      handleStat.size
+    );
+    assertFileIdentity(pathIdentity, handleIdentity);
+    return pathIdentity;
+  };
+  try {
+    assertFileIdentity(expectedIdentity, await identity());
+  } catch (error) {
+    await handle.close();
+    throw error;
+  }
+  return {
+    close: () => handle.close(),
+    identity,
+    async read(position, byteCount) {
+      const bytes = Buffer.allocUnsafe(byteCount);
+      let offset = 0;
+      while (offset < byteCount) {
+        const result = await handle.read(bytes, offset, byteCount - offset, position + offset);
+        if (result.bytesRead === 0) throw localFileChanged();
+        offset += result.bytesRead;
+      }
+      return bytes;
+    }
+  };
+}
+async function prepareTeamTilesetUpload(file) {
+  const identity = await file.identity();
+  const layout = createTeamTilesetPartLayout(identity.size);
+  const parts = [];
+  for (const part of layout) {
+    const bytes = await file.read(part.position, part.byteCount);
+    if (bytes.byteLength !== part.byteCount) throw localFileChanged();
+    parts.push(
+      Object.freeze({
+        byteCount: part.byteCount,
+        md5Base64: createHash("md5").update(bytes).digest("base64"),
+        partNumber: part.partNumber,
+        sha256Base64: createHash("sha256").update(bytes).digest("base64")
+      })
+    );
+  }
+  assertFileIdentity(identity, await file.identity());
+  const contentIdentity = {
+    algorithm: "sha256-fixed-parts-v1",
+    byteCount: identity.size,
+    partSize: teamTilesetPartSize,
+    parts: parts.map(({ byteCount, partNumber, sha256Base64 }) => ({
+      byteCount,
+      partNumber,
+      sha256Base64
+    }))
+  };
+  return Object.freeze({
+    byteCount: identity.size,
+    contentHash: createHash("sha256").update(serializeCanonicalJson2(contentIdentity)).digest("hex"),
+    contentHashAlgorithm: "sha256-fixed-parts-v1",
+    identity,
+    partSize: teamTilesetPartSize,
+    parts: Object.freeze(parts),
+    schemaVersion: 1
+  });
+}
+function createTeamTilesetUploadIdempotencyKey(tilesetId, upload) {
+  if (!/^tls_[A-Za-z0-9_-]{16,76}$/u.test(tilesetId)) {
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_NOT_FOUND",
+      "Tileset registration returned an invalid ID."
+    );
+  }
+  return createHash("sha256").update(
+    serializeCanonicalJson2({
+      byteCount: upload.byteCount,
+      contentHash: upload.contentHash,
+      contentHashAlgorithm: upload.contentHashAlgorithm,
+      tilesetId
+    })
+  ).digest("hex");
+}
+async function publishPreparedTeamTilesetUpload(input) {
+  assertFileIdentity(input.upload.identity, await input.file.identity());
+  const beginInput = {
+    byteCount: input.upload.byteCount,
+    contentHash: input.upload.contentHash,
+    contentHashAlgorithm: input.upload.contentHashAlgorithm,
+    idempotencyKey: createTeamTilesetUploadIdempotencyKey(input.tilesetId, input.upload),
+    parts: input.upload.parts,
+    partSize: input.upload.partSize,
+    schemaVersion: 1
+  };
+  const begun = await input.transport.begin(beginInput);
+  assertSessionMatches(begun, input.upload);
+  const changed = begun.state !== "published";
+  if (begun.state === "published") return publicationResult(begun, input.upload, changed);
+  let current = await input.transport.status(begun.uploadId);
+  assertSessionMatches(current, input.upload, true);
+  assertUsableSession(current);
+  let initiatingWaitMs = 0;
+  for (let attempt = 1; current.state === "initiating"; attempt += 1) {
+    const delay = Math.min(
+      2e3,
+      250 * 2 ** Math.min(attempt - 1, 3),
+      maximumInitiatingWaitMs - initiatingWaitMs
+    );
+    if (delay <= 0) {
+      throw new TeamTilesetUploadError(
+        "TF_TILESET_UPLOAD_UNAVAILABLE",
+        "Tileset upload initialization did not converge within two minutes."
+      );
+    }
+    await (input.sleep ?? defaultSleep)(delay);
+    initiatingWaitMs += delay;
+    current = await input.transport.status(current.uploadId);
+    assertSessionMatches(current, input.upload, true);
+    assertUsableSession(current);
+  }
+  if (current.state === "uploading") {
+    const uploading = current;
+    const missingParts = input.upload.parts.filter(
+      (part) => !uploading.parts.find((candidate) => candidate.partNumber === part.partNumber)?.uploaded
+    );
+    await uploadMissingParts({ ...input, missingParts, uploadId: uploading.uploadId });
+    assertFileIdentity(input.upload.identity, await input.file.identity());
+    current = await input.transport.complete(uploading.uploadId);
+    assertSessionMatches(current, input.upload);
+    assertUsableSession(current);
+  }
+  while (current.state !== "published") {
+    if (!["publishing", "ready_to_publish", "validating"].includes(current.state)) {
+      throw new TeamTilesetUploadError(
+        "TF_TILESET_UPLOAD_UNAVAILABLE",
+        "Tileset upload cannot continue from its current state."
+      );
+    }
+    input.onProgress?.({
+      completedParts: input.upload.parts.length,
+      phase: "validating",
+      totalParts: input.upload.parts.length
+    });
+    await (input.sleep ?? defaultSleep)(2e3);
+    current = await input.transport.status(current.uploadId);
+    assertSessionMatches(current, input.upload, true);
+    assertUsableSession(current);
+  }
+  return publicationResult(current, input.upload, changed);
+}
+function createHostedTeamTilesetUploadTransport(input) {
+  const basePath = `/v1/tilesets/${encodeURIComponent(input.tilesetId)}/uploads`;
+  const control = async (path, init) => {
+    for (let attempt = 1; attempt <= maximumControlAttempts; attempt += 1) {
+      let response;
+      try {
+        response = await requestHostedJson(
+          input.apiOrigin,
+          path,
+          {
+            ...init,
+            headers: {
+              Authorization: `Bearer ${input.credential}`,
+              ...init.body ? { "Content-Type": "application/json" } : {},
+              ...init.headers
+            }
+          },
+          { fetch: input.fetch }
+        );
+      } catch {
+        if (attempt === maximumControlAttempts) {
+          throw new TeamTilesetUploadError(
+            "TF_TILESET_UPLOAD_UNAVAILABLE",
+            "Tileset upload control request did not complete."
+          );
+        }
+      }
+      if (response?.ok) return response.body;
+      if (response && !isRetryableStatus(response.status)) throw responseError(response);
+      if (attempt === maximumControlAttempts) {
+        if (response) throw responseError(response);
+        break;
+      }
+      await (input.sleep ?? defaultSleep)(Math.min(2e3, 250 * 2 ** (attempt - 1)));
+    }
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_UPLOAD_UNAVAILABLE",
+      "Tileset upload control request did not complete."
+    );
+  };
+  return {
+    async authorize(uploadId, partNumbers) {
+      const body = await control(
+        `${basePath}/${encodeURIComponent(uploadId)}/part-authorizations`,
+        {
+          body: JSON.stringify({ partNumbers, schemaVersion: 1 }),
+          method: "POST"
+        }
+      );
+      return authorizationResponseSchema.parse(body).authorizations;
+    },
+    async begin(body) {
+      return parseUploadSession(
+        await control(basePath, { body: JSON.stringify(body), method: "POST" })
+      );
+    },
+    async complete(uploadId) {
+      return parseUploadSession(
+        await control(`${basePath}/${encodeURIComponent(uploadId)}/complete`, {
+          body: JSON.stringify({ schemaVersion: 1 }),
+          method: "POST"
+        })
+      );
+    },
+    async putPart(authorization, bytes) {
+      let response;
+      try {
+        const body = new Uint8Array(
+          bytes.buffer,
+          bytes.byteOffset,
+          bytes.byteLength
+        );
+        response = await (input.fetch ?? globalThis.fetch)(authorization.url, {
+          body,
+          headers: authorization.headers,
+          method: "PUT",
+          redirect: "error",
+          signal: AbortSignal.timeout(partTransferTimeoutMs)
+        });
+      } catch {
+        throw new Error("Direct part transfer failed.");
+      }
+      const etag = response.headers.get("etag");
+      await response.body?.cancel().catch(() => void 0);
+      return { etag, status: response.status };
+    },
+    async recordPart(uploadId, body) {
+      partReceiptResponseSchema.parse(
+        await control(`${basePath}/${encodeURIComponent(uploadId)}/parts`, {
+          body: JSON.stringify(body),
+          method: "POST"
+        })
+      );
+    },
+    async status(uploadId) {
+      return parseUploadSession(
+        await control(`${basePath}/${encodeURIComponent(uploadId)}`, { method: "GET" })
+      );
+    }
+  };
+}
+async function uploadMissingParts(input) {
+  let completedParts = input.upload.parts.length - input.missingParts.length;
+  for (let offset = 0; offset < input.missingParts.length; offset += authorizationBatchSize) {
+    const authorizationParts = input.missingParts.slice(offset, offset + authorizationBatchSize);
+    const initial = indexAuthorizations(
+      await input.transport.authorize(
+        input.uploadId,
+        authorizationParts.map(({ partNumber }) => partNumber)
+      ),
+      authorizationParts
+    );
+    for (let groupOffset = 0; groupOffset < authorizationParts.length; groupOffset += uploadConcurrency) {
+      assertFileIdentity(input.upload.identity, await input.file.identity());
+      const group = authorizationParts.slice(groupOffset, groupOffset + uploadConcurrency);
+      const settled = await Promise.allSettled(
+        group.map(async (part) => {
+          const position = (part.partNumber - 1) * teamTilesetPartSize;
+          const bytes = await input.file.read(position, part.byteCount);
+          if (bytes.byteLength !== part.byteCount) throw localFileChanged();
+          await uploadPartWithRetry({
+            ...input,
+            initialAuthorization: initial.get(part.partNumber),
+            part,
+            bytes
+          });
+        })
+      );
+      const failed = settled.find(
+        (result) => result.status === "rejected"
+      );
+      if (failed) throw failed.reason;
+      completedParts += group.length;
+      input.onProgress?.({
+        completedParts,
+        phase: "uploading",
+        totalParts: input.upload.parts.length
+      });
+    }
+  }
+}
+async function uploadPartWithRetry(input) {
+  let authorization = input.initialAuthorization;
+  for (let attempt = 1; attempt <= maximumPartAttempts; attempt += 1) {
+    if (!authorizationCoversTransfer(authorization, input.now?.() ?? Date.now())) {
+      const refreshed2 = await input.transport.authorize(input.uploadId, [input.part.partNumber]);
+      authorization = indexAuthorizations(refreshed2, [input.part]).get(input.part.partNumber);
+      if (!authorizationCoversTransfer(authorization, input.now?.() ?? Date.now())) {
+        throw invalidRemoteResponse();
+      }
+    }
+    assertAuthorizationMatches(authorization, input.part);
+    let result;
+    try {
+      result = await input.transport.putPart(authorization, input.bytes);
+    } catch {
+      result = { etag: null, status: 503 };
+    }
+    if (result.status >= 200 && result.status < 300) {
+      const etag = normalizePartEtag(result.etag, input.part.md5Base64);
+      await input.transport.recordPart(input.uploadId, {
+        etag,
+        partNumber: input.part.partNumber
+      });
+      return;
+    }
+    if ((result.status === 401 || result.status === 403) && !authorizationCoversTransfer(authorization, input.now?.() ?? Date.now()) && attempt < maximumPartAttempts) {
+      const refreshed2 = await input.transport.authorize(input.uploadId, [input.part.partNumber]);
+      authorization = indexAuthorizations(refreshed2, [input.part]).get(input.part.partNumber);
+      continue;
+    }
+    if (!isRetryableStatus(result.status)) {
+      throw new TeamTilesetUploadError(
+        result.status === 401 || result.status === 403 ? "TF_TILESET_UPLOAD_AUTHORIZATION_FAILED" : "TF_TILESET_UPLOAD_PART_INVALID",
+        "Direct part transfer was rejected."
+      );
+    }
+    if (attempt === maximumPartAttempts) break;
+    await (input.sleep ?? defaultSleep)(Math.min(2e3, 250 * 2 ** (attempt - 1)));
+    const refreshed = await input.transport.authorize(input.uploadId, [input.part.partNumber]);
+    authorization = indexAuthorizations(refreshed, [input.part]).get(input.part.partNumber);
+  }
+  throw new TeamTilesetUploadError(
+    "TF_TILESET_UPLOAD_UNAVAILABLE",
+    "Direct part transfer did not complete after bounded retries."
+  );
+}
+function authorizationCoversTransfer(authorization, now) {
+  return Date.parse(authorization.expiresAt) - now >= minimumPartAuthorizationLifetimeMs;
+}
+function isRetryableStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+function indexAuthorizations(authorizations, parts) {
+  const expected = new Map(parts.map((part) => [part.partNumber, part]));
+  const indexed = /* @__PURE__ */ new Map();
+  for (const authorization of authorizations) {
+    const part = expected.get(authorization.partNumber);
+    if (!part || indexed.has(authorization.partNumber)) {
+      throw invalidRemoteResponse();
+    }
+    assertAuthorizationMatches(authorization, part);
+    indexed.set(authorization.partNumber, authorization);
+  }
+  if (indexed.size !== expected.size) throw invalidRemoteResponse();
+  return indexed;
+}
+function assertAuthorizationMatches(authorization, part) {
+  if (authorization.partNumber !== part.partNumber || authorization.method !== "PUT" || authorization.headers["Content-Length"] !== String(part.byteCount) || authorization.headers["Content-MD5"] !== part.md5Base64) {
+    throw invalidRemoteResponse();
+  }
+}
+function normalizePartEtag(value, md5Base64) {
+  if (!value || !/^(?:[0-9a-f]{32}|"[0-9a-f]{32}")$/u.test(value)) {
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_UPLOAD_PART_INVALID",
+      "Direct part transfer returned an invalid ETag."
+    );
+  }
+  const normalized = value.replaceAll('"', "");
+  if (normalized !== Buffer.from(md5Base64, "base64").toString("hex")) {
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_UPLOAD_PART_INVALID",
+      "Direct part transfer returned a conflicting ETag."
+    );
+  }
+  return normalized;
+}
+function assertSessionMatches(session, upload, requireParts = false) {
+  if (session.byteCount !== upload.byteCount || session.contentHash !== upload.contentHash || session.contentHashAlgorithm !== upload.contentHashAlgorithm) {
+    throw invalidRemoteResponse();
+  }
+  if (session.state === "published") return;
+  if (session.partCount !== upload.parts.length || session.partSize !== upload.partSize || requireParts && session.parts.length !== upload.parts.length || session.parts.some((part, index) => {
+    const expected = upload.parts[index];
+    return !expected || part.partNumber !== expected.partNumber || part.byteCount !== expected.byteCount;
+  })) {
+    throw invalidRemoteResponse();
+  }
+}
+function assertUsableSession(session) {
+  if (session.state === "published") return;
+  if (session.failure) {
+    throw new TeamTilesetUploadError(session.failure.code, failureMessage(session.failure.code));
+  }
+  if (["aborted", "aborting", "expired", "expiring", "rejected", "rejecting"].includes(session.state)) {
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_UPLOAD_UNAVAILABLE",
+      "Tileset upload is no longer resumable."
+    );
+  }
+}
+function publicationResult(session, upload, changed) {
+  return Object.freeze({
+    byteCount: upload.byteCount,
+    changed,
+    contentHash: upload.contentHash,
+    contentHashAlgorithm: upload.contentHashAlgorithm,
+    state: "published",
+    version: session.publishedVersion,
+    versionId: session.versionId
+  });
+}
+function assertFileIdentity(expected, actual) {
+  const inodeChanged = expected.inode !== 0n && actual.inode !== 0n && (expected.inode !== actual.inode || expected.device !== actual.device);
+  if (inodeChanged || expected.size !== actual.size || expected.mtimeNanoseconds !== actual.mtimeNanoseconds) {
+    throw localFileChanged();
+  }
+}
+function checkedIdentity(device, inode, mtimeNanoseconds, size) {
+  const numericSize = Number(size);
+  if (numericSize === 0) {
+    throw new TeamTilesetUploadError("TF_TILESET_ARCHIVE_EMPTY", "PMTiles archive is empty.");
+  }
+  if (numericSize > maximumTeamTilesetBytes) {
+    throw new TeamTilesetUploadError(
+      "TF_TILESET_VERSION_TOO_LARGE",
+      "PMTiles archive exceeds the 4,000,000,000-byte platform maximum.",
+      { actualBytes: numericSize, limitBytes: maximumTeamTilesetBytes }
+    );
+  }
+  return Object.freeze({ device, inode, mtimeNanoseconds, size: numericSize });
+}
+function localFileChanged() {
+  return new TeamTilesetUploadError(
+    "TF_TILESET_LOCAL_FILE_CHANGED",
+    "PMTiles archive changed during publication."
+  );
+}
+function invalidRemoteResponse() {
+  return new TeamTilesetUploadError(
+    "TF_TILESET_UPLOAD_UNAVAILABLE",
+    "Tileset upload returned an invalid response."
+  );
+}
+function failureMessage(code) {
+  if (code === "TF_TILESET_SCHEMA_INCOMPATIBLE") {
+    return "Tileset schema is incompatible with retained Map deployments.";
+  }
+  if (code === "TF_TILESET_UPLOAD_CHECKSUM_MISMATCH") {
+    return "Tileset upload checksum validation failed.";
+  }
+  if (code === "TF_TILESET_UPLOAD_EXPIRED") return "Tileset upload expired.";
+  return "Tileset upload failed.";
+}
+function responseError(response) {
+  const body = asRecord3(response.body);
+  const code = typeof body.code === "string" && /^TF_[A-Z0-9_]{1,96}$/u.test(body.code) ? body.code : "TF_TILESET_UPLOAD_UNAVAILABLE";
+  const details = numericDetails(body.details);
+  return new TeamTilesetUploadError(code, failureMessage(code), details);
+}
+function numericDetails(value) {
+  const source = asRecord3(value);
+  const details = {};
+  for (const key of ["actualBytes", "limitBytes"]) {
+    const candidate = source[key];
+    if (Number.isSafeInteger(candidate) && candidate >= 0) {
+      details[key] = candidate;
+    }
+  }
+  return Object.freeze(details);
+}
+function parseUploadSession(value) {
+  return uploadSessionSchema.parse(value);
+}
+function asRecord3(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function defaultSleep(milliseconds) {
+  return new Promise((resolve8) => setTimeout(resolve8, milliseconds));
+}
+var identifierSchema = z5.string().min(20).max(80).regex(/^[A-Za-z0-9_-]+$/u);
+var uploadPartStatusSchema = z5.object({
+  byteCount: z5.number().int().min(1).max(teamTilesetPartSize),
+  partNumber: z5.number().int().min(1).max(239),
+  uploaded: z5.boolean(),
+  validationState: z5.enum(["mismatch", "pending", "processing", "valid"])
+}).strict();
+var publishedVersionSchema = z5.object({
+  byteCount: z5.number().int().min(1).max(maximumTeamTilesetBytes),
+  contentHash: z5.string().regex(/^[0-9a-f]{64}$/u),
+  contentHashAlgorithm: z5.literal("sha256-fixed-parts-v1"),
+  publishedVersion: z5.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  schemaVersion: z5.literal(1),
+  state: z5.literal("published"),
+  versionId: identifierSchema.regex(/^tsv_[A-Za-z0-9_-]+$/u)
+}).strict();
+var uploadControlSchema = z5.object({
+  byteCount: z5.number().int().min(1).max(maximumTeamTilesetBytes),
+  contentHash: z5.string().regex(/^[0-9a-f]{64}$/u),
+  contentHashAlgorithm: z5.literal("sha256-fixed-parts-v1"),
+  expiresAt: z5.iso.datetime({ offset: true }),
+  failure: z5.object({ code: z5.string().regex(/^TF_[A-Z0-9_]{1,96}$/u) }).strict().nullable(),
+  partCount: z5.number().int().min(1).max(239),
+  parts: z5.array(uploadPartStatusSchema).max(239),
+  partSize: z5.literal(teamTilesetPartSize),
+  publishedVersion: z5.null(),
+  schemaVersion: z5.literal(1),
+  state: z5.enum([
+    "aborted",
+    "aborting",
+    "expired",
+    "expiring",
+    "initiating",
+    "publishing",
+    "ready_to_publish",
+    "rejected",
+    "rejecting",
+    "uploading",
+    "validating"
+  ]),
+  uploadId: z5.string().min(20).max(80).regex(/^tsu_[A-Za-z0-9_-]+$/u),
+  versionId: z5.null()
+}).strict();
+var uploadSessionSchema = z5.union([publishedVersionSchema, uploadControlSchema]);
+var authorizationSchema = z5.object({
+  expiresAt: z5.iso.datetime({ offset: true }),
+  headers: z5.object({
+    "Content-Length": z5.string().regex(/^[1-9][0-9]{0,9}$/u),
+    "Content-MD5": z5.string().regex(/^[A-Za-z0-9+/]{22}==$/u)
+  }).strict(),
+  method: z5.literal("PUT"),
+  partNumber: z5.number().int().min(1).max(239),
+  url: z5.url().max(8192).refine((value) => {
+    const url = new URL(value);
+    return url.protocol === "https:" && !url.username && !url.password && !url.hash;
+  })
+}).strict();
+var authorizationResponseSchema = z5.object({
+  authorizations: z5.array(authorizationSchema).min(1).max(16),
+  schemaVersion: z5.literal(1)
+}).strict();
+var partReceiptResponseSchema = z5.object({
+  changed: z5.boolean(),
+  etag: z5.string().regex(/^[0-9a-f]{32}$/u),
+  partNumber: z5.number().int().min(1).max(239),
+  schemaVersion: z5.literal(1)
+}).strict();
+
+// src/tileset-command.ts
+function registerTilesetCommands(program2, dependencies) {
+  const tileset = program2.command("tileset").description("Inspect and manage geospatial tilesets");
+  tileset.command("inspect").description("Inspect one local PMTiles archive deterministically").argument("<archive>", "repository-local PMTiles archive").option("--json", "print deterministic inspection-schema-version-1 JSON").option("--no-sample", "read authoritative header and metadata without bounded MVT sampling").option(
+    "--include-values <fields>",
+    "include bounded observed values for comma-separated field names (requires --json)"
+  ).action(
+    async (archive, options) => {
+      try {
+        if (options.includeValues && !options.json) {
+          throw inspectionOptionError("--include-values requires --json.");
+        }
+        const inspection = await inspectTileflowPmtiles(archive, {
+          includeValues: parseIncludedValueFields(options.includeValues),
+          sample: options.sample
+        });
+        if (options.json) {
+          process.stdout.write(`${serializeCanonicalJson3(inspection)}
+`);
+          return;
+        }
+        console.log(`${pc2.green("\u2713")} PMTiles archive is valid.`);
+        console.log(`  Type: ${inspection.contract.tileType}`);
+        console.log(`  Zooms: ${inspection.contract.minzoom}-${inspection.contract.maxzoom}`);
+        console.log(`  Source layers: ${inspection.contract.sourceLayers.length}`);
+        if (inspection.observation) {
+          console.log(
+            `  Sample: ${inspection.observation.featuresRead} features in ${inspection.observation.tilesRead} tiles`
+          );
+        }
+        for (const warning of inspection.warnings) {
+          console.log(`${pc2.yellow("!")} ${warning.message}`);
+        }
+      } catch (error) {
+        const record = asRecord4(error);
+        const code = typeof record.code === "string" ? record.code : "TF_TILESET_INSPECTION_FAILED";
+        const path = typeof record.path === "string" ? record.path : "archive";
+        const message = error instanceof Error ? error.message : "Tileset inspection failed.";
+        if (options.json) {
+          process.stderr.write(
+            `${serializeCanonicalJson3({ error: { code, message, path }, ok: false, schemaVersion: 1 })}
+`
+          );
+        } else {
+          console.error(`${pc2.red("Error:")} ${message}`);
+        }
+        process.exitCode = 1;
+      }
+    }
+  );
+  tileset.command("publish").description("Register and publish one PMTiles archive to a Team").argument("<archive>", "repository-local PMTiles archive").requiredOption("--id <id>", "Team-local logical tileset ID").option("--name <name>", "display name").option("--attribution <text>", "data attribution").option("--team <team>", "target Team as @team").option("--api-url <url>", "Tileflow API URL", process.env.TILEFLOW_API_URL).option("--api-key <key>", "Team data API key", process.env.TILEFLOW_API_KEY).option("--json", "print deterministic schema-version-2 JSON").action(
+    async (archive, options) => {
+      let uploadFile = null;
+      try {
+        if (!isTilesetId(options.id)) {
+          return emitFailure(options.json, "invalid_tileset_id", "Tileset ID is invalid.");
+        }
+        const initialIdentity = await inspectNodeTeamTilesetArchive(archive);
+        await inspectTileflowPmtiles(archive, { sample: false });
+        uploadFile = await openNodeTeamTilesetArchive(archive, initialIdentity);
+        const prepared = await prepareTeamTilesetUpload(uploadFile);
+        const authority = await resolveTeamAuthority(options, ["tilesets:write"], dependencies);
+        if (!authority) return;
+        const registration = await requestHostedJson(authority.apiOrigin, "/v1/tilesets", {
+          body: JSON.stringify({
+            ...options.attribution ? { attribution: options.attribution } : {},
+            format: "pmtiles",
+            name: options.name?.trim() || options.id,
+            slug: options.id
+          }),
+          headers: {
+            Authorization: `Bearer ${authority.credential}`,
+            "Content-Type": "application/json"
+          },
+          method: "POST"
+        });
+        const registered = asRecord4(registration.body);
+        const resourceId = String(registered.tilesetId ?? "");
+        if (!registration.ok || !/^tls_[A-Za-z0-9_-]{16,76}$/u.test(resourceId)) {
+          return emitFailure(
+            options.json,
+            `http_${registration.status}`,
+            `Tileset registration failed (${registration.status}).`
+          );
+        }
+        let reportedParts = 0;
+        let reportedValidation = false;
+        const publication = await publishPreparedTeamTilesetUpload({
+          file: uploadFile,
+          onProgress: options.json ? void 0 : ({ completedParts, phase, totalParts }) => {
+            if (phase === "validating") {
+              if (!reportedValidation) {
+                process.stderr.write("Validating uploaded bytes.\n");
+                reportedValidation = true;
+              }
+              return;
+            }
+            if (completedParts === totalParts || completedParts - reportedParts >= 16) {
+              process.stderr.write(`Uploaded ${completedParts}/${totalParts} parts.
+`);
+              reportedParts = completedParts;
+            }
+          },
+          tilesetId: resourceId,
+          transport: createHostedTeamTilesetUploadTransport({
+            apiOrigin: authority.apiOrigin,
+            credential: authority.credential,
+            tilesetId: resourceId
+          }),
+          upload: prepared
+        });
+        const document = {
+          command: "tileset publish",
+          publication: publication.changed ? "changed" : "unchanged",
+          schemaVersion: 2,
+          team: authority.team ? { id: authority.team.id, slug: authority.team.slug } : null,
+          tileset: {
+            byteCount: publication.byteCount,
+            contentHash: publication.contentHash,
+            contentHashAlgorithm: publication.contentHashAlgorithm,
+            logicalId: options.id,
+            state: publication.state,
+            tilesetId: resourceId,
+            version: { id: publication.versionId, number: publication.version }
+          }
+        };
+        if (options.json) return emitJson2(document);
+        console.log(
+          `${pc2.green("\u2713")} ${publication.changed ? "Published" : "Unchanged"} ${pc2.bold(options.id)} in ${authority.team ? `@${authority.team.slug}` : "the Team bound to the data key"}.`
+        );
+      } catch (error) {
+        if (error instanceof TeamTilesetUploadError) {
+          emitFailure(options.json, error.code, error.message, error.details);
+        } else {
+          emitFailure(options.json, "tileset_publish_failed", "Tileset publication failed.");
+        }
+      } finally {
+        await uploadFile?.close().catch(() => void 0);
+      }
+    }
+  );
+  tileset.command("list").description("List tilesets owned by one Team").option("--team <team>", "target Team as @team").option("--api-url <url>", "Tileflow API URL", process.env.TILEFLOW_API_URL).option("--api-key <key>", "Team data API key", process.env.TILEFLOW_API_KEY).option("--json", "print deterministic schema-version-1 JSON").action(async (options) => {
+    try {
+      const authority = await resolveTeamAuthority(options, ["tilesets:read"], dependencies);
+      if (!authority) return;
+      const items = await fetchAllTeamTilesets(authority);
+      const document = { command: "tileset list", schemaVersion: 1, tilesets: items };
+      if (options.json) return emitJson2(document);
+      if (items.length === 0) return console.log(pc2.gray("No Team tilesets."));
+      for (const item of items) {
+        console.log(`  ${pc2.bold(item.logicalName)} ${pc2.gray(item.status)}`);
+      }
+    } catch {
+      emitFailure(options.json, "tileset_list_failed", "Tileset list failed.");
+    }
+  });
+  tileset.command("status").description("Show one Team tileset").argument("<id>", "Team-local logical ID or opaque resource ID").option("--team <team>", "target Team as @team").option("--api-url <url>", "Tileflow API URL", process.env.TILEFLOW_API_URL).option("--api-key <key>", "Team data API key", process.env.TILEFLOW_API_KEY).option("--json", "print deterministic schema-version-1 JSON").action(async (id, options) => {
+    try {
+      if (!isTilesetId(id))
+        return emitFailure(options.json, "invalid_tileset_id", "Tileset ID is invalid.");
+      const authority = await resolveTeamAuthority(options, ["tilesets:read"], dependencies);
+      if (!authority) return;
+      const response = await authorizedTeamRequest(
+        authority,
+        `/v1/tilesets/${encodeURIComponent(id)}`,
+        "GET"
+      );
+      if (!response.ok) {
+        return emitFailure(
+          options.json,
+          `http_${response.status}`,
+          `Tileset status failed (${response.status}).`
+        );
+      }
+      const parsed = tilesetDetailResponseSchema.parse(response.body);
+      const document = { command: "tileset status", schemaVersion: 1, tileset: parsed.tileset };
+      if (options.json) return emitJson2(document);
+      const item = parsed.tileset;
+      console.log(`${pc2.bold(item.name)} ${pc2.gray(item.state)}`);
+      console.log(`  ID: ${item.id}`);
+      console.log(`  Current version: ${String(item.currentVersion ?? "unpublished")}`);
+    } catch {
+      emitFailure(options.json, "tileset_status_failed", "Tileset status failed.");
+    }
+  });
+  tileset.command("purge").description("Permanently purge one unreferenced Team tileset").argument("<id>", "Team-local logical ID or opaque resource ID").requiredOption("--confirm <id>", "repeat the exact tileset ID").option("--team <team>", "target Team as @team").option("--api-url <url>", "Tileflow API URL", process.env.TILEFLOW_API_URL).option("--api-key <key>", "Team data API key", process.env.TILEFLOW_API_KEY).option("--json", "print deterministic schema-version-1 JSON").action(async (id, options) => {
+    try {
+      if (!isTilesetId(id) || options.confirm !== id) {
+        return emitFailure(
+          options.json,
+          "purge_confirmation_mismatch",
+          "Purge confirmation must match the tileset ID."
+        );
+      }
+      const authority = await resolveTeamAuthority(options, ["tilesets:write"], dependencies);
+      if (!authority) return;
+      const response = await requestHostedJson(
+        authority.apiOrigin,
+        `/v1/tilesets/${encodeURIComponent(id)}`,
+        {
+          headers: {
+            Authorization: `Bearer ${authority.credential}`,
+            "X-Tileflow-Confirm-Tileset-Purge": id
+          },
+          method: "DELETE"
+        }
+      );
+      if (!response.ok) {
+        const inUse = tilesetInUseResponseSchema.safeParse(response.body);
+        if (inUse.success) {
+          return emitFailure(
+            options.json,
+            inUse.data.code,
+            "Tileset is used by retained Map deployments.",
+            {
+              dependencies: inUse.data.dependencies,
+              nextCursor: inUse.data.nextCursor
+            }
+          );
+        }
+        return emitFailure(
+          options.json,
+          `http_${response.status}`,
+          `Tileset purge failed (${response.status}).`
+        );
+      }
+      const parsed = tilesetPurgeResponseSchema.parse(response.body);
+      const document = { command: "tileset purge", schemaVersion: 1, ...parsed };
+      if (options.json) return emitJson2(document);
+      console.log(`${pc2.green("\u2713")} Purge ${parsed.reclamation}.`);
+    } catch {
+      emitFailure(options.json, "tileset_purge_failed", "Tileset purge failed.");
+    }
+  });
 }
-async function resolveAccountProjectTarget(session, requestedProject) {
-  const result = await fetchAccountProjects(session, false);
-  if (!result.ok) return { error: result.error, kind: "remote", status: result.status };
-  if (requestedProject) {
-    const parsed = parseProjectReference(requestedProject);
-    if (!parsed) return { kind: "invalid", targets: result.items };
-    const target = result.items.find((candidate) => candidate.reference === requestedProject);
-    return target ? { kind: "selected", target } : { kind: "missing", targets: result.items };
+async function resolveTeamAuthority(options, scopes, dependencies) {
+  let apiOrigin;
+  try {
+    apiOrigin = normalizeApiOrigin(options.apiUrl ?? dependencies.defaultApiUrl);
+  } catch (error) {
+    emitFailure(options.json, "invalid_api_url", safeMessage2(error));
+    return null;
+  }
+  if (options.apiKey) {
+    if (!/^tf_live_[0-9a-f]{48}$/u.test(options.apiKey)) {
+      emitFailure(options.json, "invalid_team_data_key", "Team data API key is invalid.");
+      return null;
+    }
+    if (options.team) {
+      emitFailure(
+        options.json,
+        "team_selector_with_api_key",
+        "A Team data key already selects its Team; omit --team."
+      );
+      return null;
+    }
+    return { apiOrigin, credential: options.apiKey, team: null };
   }
-  if (result.items.length === 1) return { kind: "selected", target: result.items[0] };
-  return result.items.length ? { kind: "ambiguous", targets: result.items } : { kind: "missing", targets: [] };
-}
-async function requireCommandSession(options, dependencies) {
   let config;
   try {
     config = await dependencies.loadAuthConfig();
   } catch (error) {
-    emitLocalFailure(options.json, "auth_state_unavailable", safeMessage(error));
+    emitFailure(options.json, "auth_state_unavailable", safeMessage2(error));
     return null;
   }
-  const resolved = resolveAccountSession(config, options.apiUrl ?? dependencies.defaultApiUrl);
-  if (resolved.kind !== "selected") {
-    emitLocalFailure(
+  const selected = resolveAccountSession(config, options.apiUrl ?? dependencies.defaultApiUrl);
+  if (selected.kind !== "selected") {
+    emitFailure(
       options.json,
-      `account_session_${resolved.kind}`,
-      resolved.kind === "expired" ? "The Tileflow account session has expired. Run tileflow login." : "Not logged in. Run tileflow login."
+      `account_session_${selected.kind}`,
+      selected.kind === "expired" ? "Account session expired. Run tileflow login." : "Run tileflow login."
     );
     return null;
   }
-  return resolved.session;
-}
-async function accountRequest(session, path, init) {
-  let response;
-  try {
-    response = await requestHostedJson(session.apiOrigin, path, {
-      ...init,
-      headers: { ...init.headers, Authorization: `Bearer ${session.accountSession}` }
-    });
-  } catch (error) {
-    return {
-      body: null,
-      error: error instanceof Error && /safe size limit|timed out/u.test(error.message) ? error.message : "Hosted request failed.",
-      ok: false,
-      status: 502
-    };
+  const discovered = await listAccountTeams(selected.session);
+  if (!discovered.ok) {
+    emitFailure(options.json, "team_discovery_failed", discovered.error);
+    return null;
   }
-  if (response.ok && !response.json) {
-    return {
-      body: null,
-      error: "Hosted response returned invalid JSON.",
-      ok: false,
-      status: 502
-    };
+  const requested = options.team ? /^@([A-Za-z0-9][A-Za-z0-9._-]{0,127})$/u.exec(options.team) : null;
+  if (options.team && !requested) {
+    emitFailure(options.json, "invalid_team", "Team must use @team syntax.");
+    return null;
   }
-  return response.ok ? { body: response.body, ok: true, status: response.status } : {
-    body: response.body,
-    error: `Request failed (${response.status}).`,
-    ok: false,
-    status: response.status
-  };
-}
-function validateTargetOrder(items) {
-  const references = items.map((item) => item.reference);
-  if (new Set(references).size !== references.length || references.some((reference, index) => index > 0 && references[index - 1] >= reference)) {
-    return {
-      error: "Destination discovery returned unstable ordering.",
-      ok: false,
-      status: 502
-    };
+  const team = requested ? discovered.teams.find(({ slug }) => slug === requested[1]) : discovered.teams.length === 1 ? discovered.teams[0] : null;
+  if (!team) {
+    const options_ = discovered.teams.map(({ slug }) => `@${slug}`);
+    emitFailure(
+      options.json,
+      options_.length > 1 ? "team_ambiguous" : "team_not_found",
+      options_.length > 1 ? `Choose one Team with --team: ${options_.join(", ")}.` : "No matching Team is available.",
+      { options: options_ }
+    );
+    return null;
   }
-  return { items, ok: true };
-}
-function uniqueOrganizations(items) {
-  return [...new Map(items.map((item) => [item.organization.id, item.organization])).values()];
+  const capability = await requestTeamCapability(selected.session, `@${team.slug}`, scopes);
+  if (!capability.ok) {
+    emitFailure(options.json, "team_capability_failed", capability.error);
+    return null;
+  }
+  return {
+    apiOrigin: selected.session.apiOrigin,
+    credential: capability.capability,
+    team
+  };
 }
-function parseOrganizationReference(value) {
-  if (!value) return null;
-  const match = /^@([A-Za-z0-9][A-Za-z0-9._-]{0,127})$/u.exec(value);
-  return match?.[1] ?? null;
+function authorizedTeamRequest(authority, path, method) {
+  return requestHostedJson(authority.apiOrigin, path, {
+    headers: { Authorization: `Bearer ${authority.credential}` },
+    method
+  });
 }
-function emitAmbiguousOrganizations(json, organizations, slug, name) {
-  const references = organizations.map((organization) => `@${organization.slug}`);
-  const retry = `tileflow projects create ${slug} --name ${JSON.stringify(name.trim())} --organization ${references[0]}`;
-  return emitLocalFailure(
-    json,
-    "organization_ambiguous",
-    `More than one organization is available: ${references.join(", ")}. Retry with: ${retry}`,
-    { options: references, retry }
-  );
+async function fetchAllTeamTilesets(authority) {
+  const items = [];
+  const seenCursors = /* @__PURE__ */ new Set();
+  const seenIds = /* @__PURE__ */ new Set();
+  let cursor = null;
+  for (let page = 0; page < 100; page += 1) {
+    const query = new URLSearchParams({ limit: "100" });
+    if (cursor) query.set("cursor", cursor);
+    const response = await authorizedTeamRequest(
+      authority,
+      `/v1/tilesets?${query.toString()}`,
+      "GET"
+    );
+    if (!response.ok) {
+      throw new TeamTilesetUploadError(
+        `http_${response.status}`,
+        `Tileset list failed (${response.status}).`
+      );
+    }
+    const parsed = tilesetListResponseSchema.parse(response.body);
+    for (const item of parsed.tilesets) {
+      if (seenIds.has(item.id)) throw new Error("Tileset list returned a duplicate resource.");
+      const previous = items.at(-1);
+      if (previous && (previous.logicalName > item.logicalName || previous.logicalName === item.logicalName && previous.id >= item.id)) {
+        throw new Error("Tileset list returned unstable ordering.");
+      }
+      seenIds.add(item.id);
+      items.push(item);
+    }
+    cursor = parsed.nextCursor ?? null;
+    if (!cursor) return Object.freeze(items);
+    if (seenCursors.has(cursor)) throw new Error("Tileset list repeated a cursor.");
+    seenCursors.add(cursor);
+  }
+  throw new Error("Tileset list exceeded its safe page limit.");
 }
-function emitRemoteFailure(json, result) {
-  return emitLocalFailure(json, `http_${result.status}`, result.error);
+function emitJson2(value) {
+  process.stdout.write(`${serializeCanonicalJson3(value)}
+`);
 }
-function emitLocalFailure(json, code, message, details = {}) {
+function emitFailure(json, code, message, context = {}) {
   if (json) {
-    console.error(message);
-    emitJson({ schemaVersion: 1, ok: false, error: { code, ...details } });
+    process.stderr.write(
+      `${serializeCanonicalJson3({ error: { code, ...context, message }, ok: false, schemaVersion: 1 })}
+`
+    );
   } else {
-    console.error(`${pc.red("\u2715")} ${message}`);
+    console.error(`${pc2.red("Error:")} ${message}`);
   }
   process.exitCode = 1;
 }
-function emitJson(value) {
-  process.stdout.write(`${JSON.stringify(value)}
-`);
-}
-function asRecord2(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function isAccountProjectTarget(value) {
-  const target = asRecord2(value);
-  return isIdentity(target.organization) && isProjectItem(target.project) && typeof target.reference === "string" && target.reference === `@${target.organization.slug}/${target.project.slug}`;
-}
-function isIdentity(value) {
-  const identity = asRecord2(value);
-  return typeof identity.id === "string" && typeof identity.name === "string" && typeof identity.slug === "string";
+function isTilesetId(value) {
+  return /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(value) && !["terrain", "world"].includes(value);
 }
-function isProjectItem(value) {
-  const item = asRecord2(value);
-  return isIdentity(value) && (item.archivedAt === null || typeof item.archivedAt === "string") && typeof item.createdAt === "string" && typeof item.updatedAt === "string";
+function parseIncludedValueFields(value) {
+  if (value === void 0) return void 0;
+  const fields = value.split(",").map((field) => field.trim());
+  if (fields.some((field) => !field)) {
+    throw inspectionOptionError("--include-values requires comma-separated field names.");
+  }
+  return fields;
 }
-function validSlug(value) {
-  return /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(value);
+function inspectionOptionError(message) {
+  return Object.assign(new Error(message), {
+    code: "TF_TILESET_INSPECTION_OPTIONS_INVALID",
+    path: "includeValues"
+  });
 }
-function validName(value) {
-  const normalized = value.trim();
-  return normalized.length > 0 && normalized.length <= 200 && !/[\p{Cc}]/u.test(normalized);
+function safeMessage2(error) {
+  return error instanceof Error ? error.message : "Tileset command failed.";
 }
-function safeMessage(error) {
-  return error instanceof Error && error.message.length <= 300 ? error.message : "Tileflow auth state is unavailable.";
+function asRecord4(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
+var safeIdentifierSchema2 = z6.string().min(1).max(160).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u);
+var physicalTilesetIdSchema = z6.string().min(20).max(80).regex(/^tls_[A-Za-z0-9_-]+$/u);
+var cursorSchema = z6.string().min(1).max(2048).nullable();
+var tilesetInventoryItemSchema = z6.object({
+  currentVersion: z6.number().int().positive().max(Number.MAX_SAFE_INTEGER).nullable(),
+  hasCurrent: z6.boolean(),
+  id: physicalTilesetIdSchema,
+  logicalName: z6.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
+  name: z6.string().min(1).max(200),
+  retainedBytes: z6.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  retainedDeploymentCount: z6.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  status: z6.enum(["active", "purging", "retired"]),
+  updatedAt: z6.iso.datetime({ offset: true }),
+  usedByMapCount: z6.number().int().min(0).max(Number.MAX_SAFE_INTEGER)
+}).strict();
+var tilesetListResponseSchema = z6.object({
+  nextCursor: cursorSchema.optional(),
+  schemaVersion: z6.literal(1),
+  tilesets: z6.array(tilesetInventoryItemSchema).max(100)
+}).strict();
+var tilesetDependencySchema = z6.object({
+  active: z6.boolean(),
+  deploymentId: safeIdentifierSchema2,
+  deploymentVersion: z6.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  environment: z6.string().min(1).max(64),
+  mapId: safeIdentifierSchema2,
+  sourceId: safeIdentifierSchema2
+}).strict();
+var tilesetDetailResponseSchema = z6.object({
+  schemaVersion: z6.literal(1),
+  tileset: z6.object({
+    attribution: z6.string().max(4096).nullable(),
+    currentVersion: z6.number().int().positive().max(Number.MAX_SAFE_INTEGER).nullable(),
+    dependencies: z6.array(tilesetDependencySchema).max(25),
+    dependencyNextCursor: cursorSchema,
+    id: physicalTilesetIdSchema,
+    name: z6.string().min(1).max(200),
+    slug: z6.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
+    state: z6.enum(["active", "purging", "purged"])
+  }).strict()
+}).strict();
+var purgeDependencySchema = z6.object({
+  deploymentId: safeIdentifierSchema2,
+  mapId: safeIdentifierSchema2,
+  sourceId: safeIdentifierSchema2
+}).strict();
+var tilesetInUseResponseSchema = z6.object({
+  code: z6.literal("TF_TILESET_IN_USE"),
+  dependencies: z6.array(purgeDependencySchema).max(32),
+  error: z6.literal("Tileset is used by retained Map deployments"),
+  nextCursor: cursorSchema
+}).strict();
+var tilesetPurgeResponseSchema = z6.object({
+  deliveryFence: z6.enum(["complete", "pending"]),
+  pendingVersions: z6.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  reclamation: z6.enum(["complete", "pending"]),
+  state: z6.enum(["purged", "purging"]),
+  tilesetId: physicalTilesetIdSchema
+}).strict();
 
 // src/visual-command.ts
-import { lstat as lstat3, readFile as readFile5 } from "fs/promises";
-import { dirname as dirname8, isAbsolute as isAbsolute3, parse as parse2, relative as relative4, resolve as resolve6, sep as sep4 } from "path";
+import { lstat as lstat3, readFile as readFile6 } from "fs/promises";
+import { dirname as dirname9, isAbsolute as isAbsolute3, parse as parse2, relative as relative4, resolve as resolve6, sep as sep4 } from "path";
 import {
   analyzeTileflowCaptureReference,
   compareTileflowCaptureToBaseline,
@@ -3204,12 +4839,12 @@ import {
   tileflowVisualArtifactLimits,
   validateTileflowVisualReferencePng
 } from "@tileflow/capture";
-import { compareCodeUnits as compareCodeUnits7 } from "@tileflow/core";
+import { compareCodeUnits as compareCodeUnits8 } from "@tileflow/core";
 
 // src/visual-compare-command.ts
-import { createHash as createHash2 } from "crypto";
-import { lstat as lstat2, readFile as readFile4, realpath } from "fs/promises";
-import { basename as basename3, dirname as dirname7, extname, isAbsolute as isAbsolute2, parse, relative as relative3, resolve as resolve5, sep as sep3 } from "path";
+import { createHash as createHash3 } from "crypto";
+import { lstat as lstat2, readFile as readFile5, realpath } from "fs/promises";
+import { basename as basename3, dirname as dirname8, extname, isAbsolute as isAbsolute2, parse, relative as relative3, resolve as resolve5, sep as sep3 } from "path";
 import {
   compareTileflowCapturesForReview,
   createTileflowCaptureSession as createTileflowCaptureSession2,
@@ -3218,9 +4853,9 @@ import {
   tileflowSyntheticAssetOrigin as tileflowSyntheticAssetOrigin2
 } from "@tileflow/capture";
 import {
-  compareCodeUnits as compareCodeUnits6,
+  compareCodeUnits as compareCodeUnits7,
   normalizeTileflowCaptureScene as normalizeTileflowCaptureScene2,
-  parseTileflowMap,
+  parseResolvedTileflowMap as parseResolvedTileflowMap2,
   resolveThemeSelection,
   tileflowCaptureSceneLimits
 } from "@tileflow/core";
@@ -3231,7 +4866,7 @@ import {
 } from "@tileflow/dev/artifacts";
 
 // src/visual-compare-report.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 var tileflowVisualCompareReportSchemaVersion = 1;
 var tileflowVisualCompareReportLimits = Object.freeze({
   maximumEmbeddedPngBytes: 64 * 1024 * 1024,
@@ -3286,7 +4921,7 @@ function renderTileflowVisualCompareReport(input) {
   };
   const rowHtml = rows.map((row, index) => renderRow(row, index)).join("\n");
   const script = reportScript();
-  const scriptHash = createHash("sha256").update(script).digest("base64");
+  const scriptHash = createHash2("sha256").update(script).digest("base64");
   return `<!doctype html>
 <html lang="en">
   <head>
@@ -3650,7 +5285,7 @@ async function prepareVisualCompareOutput(plan, leftArtifacts, rightArtifacts, c
       documentPath: relativePath(cwd, plan.output.documentPath),
       reportPath: relativePath(cwd, plan.output.reportPath)
     },
-    warnings: [...warnings].sort(compareCodeUnits6)
+    warnings: [...warnings].sort(compareCodeUnits7)
   };
   const report = renderTileflowVisualCompareReport({
     generatedBy: "Tileflow CLI",
@@ -3938,7 +5573,7 @@ async function runVisualCompareWatch(plan, openReport) {
   }
 }
 function resolveVisualCompareSide(artifacts, config, requestedMap, requestedTheme, role) {
-  const availableMaps = Object.keys(artifacts.project.maps).sort(compareCodeUnits6);
+  const availableMaps = Object.keys(artifacts.project.maps).sort(compareCodeUnits7);
   const map = requestedMap ?? (availableMaps.length === 1 ? availableMaps[0] : void 0);
   if (!map) {
     throw new Error(
@@ -3951,7 +5586,7 @@ function resolveVisualCompareSide(artifacts, config, requestedMap, requestedThem
       `Unknown ${role} map "${map}". Available maps: ${availableMaps.join(", ") || "(none)"}.`
     );
   }
-  const resolvedMap = parseTileflowMap(candidate);
+  const resolvedMap = parseResolvedTileflowMap2(candidate);
   const theme = resolveThemeSelection(resolvedMap, requestedTheme).name;
   if (!artifacts.styles[map]?.[theme]) {
     throw new Error(`The ${role} map theme "${map}/${theme}" was not compiled.`);
@@ -4007,7 +5642,7 @@ async function resolveVisualCompareOutput(cwd, value, managed, force, watch, zoo
   if (extname(reportPath).toLowerCase() !== ".html") {
     throw new Error("--report must name an .html file.");
   }
-  const reportDirectory = dirname7(reportPath);
+  const reportDirectory = dirname8(reportPath);
   if (reportDirectory === cwd || reportDirectory === parse(reportPath).root) {
     throw new Error("Visual compare output must use a dedicated subdirectory.");
   }
@@ -4147,7 +5782,7 @@ function createVisualCompareInventory(assetDirectory, assets) {
         throw new Error("Visual compare produced an invalid managed asset path.");
       }
       return { path: relativeAssetPath, sha256: sha256Source(source) };
-    }).sort((left, right) => compareCodeUnits6(left.path, right.path))
+    }).sort((left, right) => compareCodeUnits7(left.path, right.path))
   };
 }
 function serializeVisualCompareInventory(inventory) {
@@ -4155,7 +5790,7 @@ function serializeVisualCompareInventory(inventory) {
 `;
 }
 async function readVisualCompareInventory(assetDirectory, inventoryPath, boundary) {
-  await assertNoSymlinkComponents(dirname7(inventoryPath), boundary);
+  await assertNoSymlinkComponents(dirname8(inventoryPath), boundary);
   let info;
   try {
     info = await lstat2(inventoryPath);
@@ -4171,7 +5806,7 @@ async function readVisualCompareInventory(assetDirectory, inventoryPath, boundar
   }
   let parsed;
   try {
-    parsed = JSON.parse(await readFile4(inventoryPath, "utf8"));
+    parsed = JSON.parse(await readFile5(inventoryPath, "utf8"));
   } catch (error) {
     throw new Error("Visual compare inventory is not valid bounded JSON.", { cause: error });
   }
@@ -4179,7 +5814,7 @@ async function readVisualCompareInventory(assetDirectory, inventoryPath, boundar
   const assets = [];
   for (const asset of inventory.assets) {
     const path = resolve5(assetDirectory, asset.path);
-    await assertNoSymlinkComponents(dirname7(path), boundary);
+    await assertNoSymlinkComponents(dirname8(path), boundary);
     let assetInfo;
     try {
       assetInfo = await lstat2(path);
@@ -4193,7 +5828,7 @@ async function readVisualCompareInventory(assetDirectory, inventoryPath, boundar
     if (assetInfo.size > tileflowVisualCompareReportLimits.maximumEmbeddedPngBytes) {
       throw new Error("A managed visual compare asset exceeds its bounded byte limit.");
     }
-    const source = await readFile4(path);
+    const source = await readFile5(path);
     if (sha256Source(source) !== asset.sha256) {
       throw new Error(
         "A previously managed visual compare asset was modified; move or remove it explicitly."
@@ -4222,7 +5857,7 @@ function validateVisualCompareInventory(input) {
     return { path: asset.path, sha256: asset.sha256 };
   });
   const paths = assets.map((asset) => asset.path);
-  const sortedPaths = [...paths].sort(compareCodeUnits6);
+  const sortedPaths = [...paths].sort(compareCodeUnits7);
   if (new Set(paths).size !== paths.length || paths.some((path, index) => path !== sortedPaths[index])) {
     throw new Error("Visual compare inventory asset paths must be unique and sorted.");
   }
@@ -4242,12 +5877,12 @@ function isVisualCompareOwnedAssetName(value) {
   return Number.isInteger(row) && row >= 1 && row <= tileflowVisualCompareLimits.maximumRows;
 }
 function hasExactKeys(record, keys) {
-  const actual = Object.keys(record).sort(compareCodeUnits6);
-  const expected = [...keys].sort(compareCodeUnits6);
+  const actual = Object.keys(record).sort(compareCodeUnits7);
+  const expected = [...keys].sort(compareCodeUnits7);
   return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
 }
 function sha256Source(source) {
-  return createHash2("sha256").update(typeof source === "string" ? Buffer.from(source, "utf8") : Buffer.from(source)).digest("hex");
+  return createHash3("sha256").update(typeof source === "string" ? Buffer.from(source, "utf8") : Buffer.from(source)).digest("hex");
 }
 async function canonicalPathIdentity(path) {
   const absolute = resolve5(path);
@@ -4260,7 +5895,7 @@ async function canonicalPathIdentity(path) {
       return process.platform === "win32" ? canonical.toLowerCase() : canonical;
     } catch (error) {
       if (!isMissingPathComponent(error)) throw error;
-      const parent = dirname7(current);
+      const parent = dirname8(current);
       if (parent === current) {
         const canonical = absolute.normalize("NFC");
         return process.platform === "win32" ? canonical.toLowerCase() : canonical;
@@ -4417,7 +6052,7 @@ function createTileflowVisualDiffJson(comparisons, cwd) {
   return {
     schemaVersion: 1,
     command: "visual.diff",
-    comparisons: [...comparisons].sort((left, right) => compareCodeUnits7(left.comparison.scene, right.comparison.scene)).map(({ comparison, baselinePath, actualPath, diffPath, reportPath }) => ({
+    comparisons: [...comparisons].sort((left, right) => compareCodeUnits8(left.comparison.scene, right.comparison.scene)).map(({ comparison, baselinePath, actualPath, diffPath, reportPath }) => ({
       ...createTileflowVisualComparisonDocument(comparison),
       baselinePath: relativePath(cwd, baselinePath),
       actualPath: relativePath(cwd, actualPath),
@@ -4632,7 +6267,7 @@ async function runVisualUpdate(scenes, options) {
           renderer: capture.renderer,
           networkDependent: capture.networkDependent
         },
-        warnings: [...capture.warnings].sort(compareCodeUnits7)
+        warnings: [...capture.warnings].sort(compareCodeUnits8)
       });
       outputFiles.push(
         { path: files.pngPath, source: capture.png },
@@ -4649,7 +6284,7 @@ async function runVisualUpdate(scenes, options) {
     const document = {
       schemaVersion: 1,
       command: "visual.update",
-      updates: updates.sort((left, right) => compareCodeUnits7(left.scene, right.scene))
+      updates: updates.sort((left, right) => compareCodeUnits8(left.scene, right.scene))
     };
     if (options.json) {
       process.stdout.write(serializeTileflowVisualCommandJson(document));
@@ -4705,7 +6340,7 @@ async function readBaselineFiles(directory, scene) {
   return { kind: "complete", pngPath, receiptPath, baseline: { png, receipt } };
 }
 async function readOptionalArtifact(path, boundary, maximumBytes) {
-  await assertNoSymlinkComponents(dirname8(path), boundary);
+  await assertNoSymlinkComponents(dirname9(path), boundary);
   let info;
   try {
     info = await lstat3(path);
@@ -4723,7 +6358,7 @@ async function readOptionalArtifact(path, boundary, maximumBytes) {
     throw new TileflowCaptureError2("BASELINE_INVALID", "A visual baseline artifact is too large.");
   }
   await assertNotSymlink(path);
-  return new Uint8Array(await readFile5(path));
+  return new Uint8Array(await readFile6(path));
 }
 async function readVisualReference(path) {
   let info;
@@ -4747,7 +6382,7 @@ async function readVisualReference(path) {
     );
   }
   await assertNotSymlink(path);
-  return new Uint8Array(await readFile5(path));
+  return new Uint8Array(await readFile6(path));
 }
 async function resolveVisualDirectory(cwd, value, kind) {
   const path = resolve6(cwd, value);
@@ -4810,7 +6445,9 @@ var defaultApiUrl = defaultTileflowApiUrl;
 var defaultAppUrl = "https://tileflow.dev";
 var defaultConfigPath = defaultTileflowConfigPath;
 var defaultManifestPath = defaultTileflowManifestPath;
-program.name("tileflow").description("Beautiful maps from config.").version(packageJson.version).showHelpAfterError(pc2.gray("\nRun tileflow <command> --help for usage.")).showSuggestionAfterError();
+program.name("tileflow").description("Beautiful maps from config.").version(packageJson.version).showHelpAfterError(pc3.gray("\nRun tileflow <command> --help for usage.")).showSuggestionAfterError();
+registerLanguageCommand(program);
+registerTilesetCommands(program, { defaultApiUrl, loadAuthConfig });
 program.command("init").description("Create a starter tileflow.config.ts").option("-f, --force", "overwrite an existing config").action(async (options) => {
   const configPath = resolve7(process.cwd(), defaultConfigPath);
   const ignorePath = resolve7(process.cwd(), ".gitignore");
@@ -4829,9 +6466,9 @@ program.command("init").description("Create a starter tileflow.config.ts").optio
   }
   logSuccess(`Created ${pathLabel(defaultConfigPath)}.`);
   printKeyValue("Path", pathLabel(configPath));
-  printKeyValue("Map", pc2.bold("madrid"));
+  printKeyValue("Map", pc3.bold("madrid"));
   printNextSteps([
-    `Install ${pc2.cyan("@tileflow/core")} and ${pc2.cyan("@tileflow/maps")} in this project if needed.`,
+    `Install ${pc3.cyan("@tileflow/core")} and ${pc3.cyan("@tileflow/maps")} in this project if needed.`,
     `Preview locally with ${command("tileflow preview")}.`,
     `Validate the config with ${command("tileflow validate")}.`
   ]);
@@ -4927,7 +6564,7 @@ program.command("validate").description("Validate a Tileflow config").option("-c
 ).option("--json", "print deterministic schema-version-1 JSON").action(async (options) => {
   if (options.target !== "local" && options.target !== "hosted") {
     if (options.json) {
-      const failure = createTileflowCommandFailureDocument2(
+      const failure = createTileflowCommandFailureDocument4(
         "validate",
         {
           code: "INVALID_TARGET",
@@ -4944,7 +6581,7 @@ program.command("validate").description("Validate a Tileflow config").option("-c
         process.cwd(),
         { code: "INVALID_TARGET", phase: "command-validation" }
       );
-      process.stderr.write(serializeTileflowCommandDocument2(failure));
+      process.stderr.write(serializeTileflowCommandDocument4(failure));
       process.exitCode = 1;
       return;
     }
@@ -4959,10 +6596,10 @@ program.command("validate").description("Validate a Tileflow config").option("-c
   try {
     if (!options.json) logInfo(`Validating ${pathLabel(options.config)}.`);
     const loaded = await withTileflowConfigSecretsHidden(
-      () => loadTileflowConfigWithInputs2(options.config)
+      () => loadTileflowConfigWithInputs3(options.config)
     );
     const project = loaded.project;
-    const baseDirectory = dirname9(loaded.configFile);
+    const baseDirectory = dirname10(loaded.configFile);
     failureDefaults = { code: "CONFIG_INVALID", phase: "config-validation" };
     assertValidTileflowConfig2(project);
     const mapNames = getTileflowMapNames3(project).sort();
@@ -4981,8 +6618,14 @@ program.command("validate").description("Validate a Tileflow config").option("-c
       apiBaseUrl: options.apiBaseUrl,
       mapAssets
     });
+    failureDefaults = { code: "TF_LOCAL_TILESET_INVALID", phase: "local-tileset-resolution" };
+    const localTilesets = await prepareTileflowLocalTilesets(project, compiledStyles, {
+      assetBaseUrl: "/tileflow",
+      baseDirectory,
+      cwd: process.cwd()
+    });
     failureDefaults = { code: "FONT_COMPILATION_FAILED", phase: "font-compilation" };
-    const { styles } = await prepareTileflowStyleFonts(project, compiledStyles, {
+    const { styles } = await prepareTileflowStyleFonts(project, localTilesets.styles, {
       assetBaseUrl: "/tileflow",
       baseDirectory,
       cwd: process.cwd(),
@@ -5006,6 +6649,17 @@ program.command("validate").description("Validate a Tileflow config").option("-c
         phase: "hosted-validation"
       });
     }
+    const diagnostics = createTileflowStructuredDiagnostics2(
+      {
+        diagnostics: mapNames.flatMap(
+          (mapName) => auditTileflowMapThemeValues(project.maps[mapName]).filter(
+            ({ severity }) => severity === "warning"
+          )
+        )
+      },
+      process.cwd(),
+      { code: "VALIDATION_WARNING", phase: "theme-audit" }
+    );
     const checks = [
       "Config schema",
       "Icon asset closure",
@@ -5015,7 +6669,7 @@ program.command("validate").description("Validate a Tileflow config").option("-c
       ...options.target === "hosted" ? ["Hosted compatibility"] : []
     ];
     if (options.json) {
-      const summary = createTileflowCommandSummary({
+      const summary = createTileflowCommandSummary2({
         code: "VALIDATION_OK",
         command: "validate",
         message: `Tileflow config is valid (${plural(mapNames.length, "map")}).`,
@@ -5026,27 +6680,30 @@ program.command("validate").description("Validate a Tileflow config").option("-c
         suggestion: "No changes are required."
       });
       process.stdout.write(
-        serializeTileflowCommandDocument2({
+        serializeTileflowCommandDocument4({
           ...summary,
           target: options.target,
           maps: mapNames,
           checks,
-          diagnostics: []
+          diagnostics
         })
       );
       return;
     }
     logSuccess(`Config is valid (${plural(mapNames.length, "map")}).`);
     printChecks(checks);
+    for (const diagnostic of diagnostics) {
+      logWarning(`${diagnostic.path || "(root)"}: ${diagnostic.message}`);
+    }
   } catch (error) {
     if (!options.json) throw error;
-    const failure = createTileflowCommandFailureDocument2(
+    const failure = createTileflowCommandFailureDocument4(
       "validate",
       error,
       process.cwd(),
       failureDefaults
     );
-    process.stderr.write(serializeTileflowCommandDocument2(failure));
+    process.stderr.write(serializeTileflowCommandDocument4(failure));
     process.exitCode = 1;
   }
 });
@@ -5224,7 +6881,7 @@ program.command("preview").alias("dev").description("Run a local map preview").o
     });
   }
 );
-program.command("deploy").description("Deploy maps to Tileflow and write the frontend manifest").option("-c, --config <path>", "config path", defaultConfigPath).option("--manifest <path>", "manifest path written for frontend bundlers", defaultManifestPath).option("--api-url <url>", "Tileflow API URL", process.env.TILEFLOW_API_URL).option("--api-key <key>", "Tileflow API key", process.env.TILEFLOW_API_KEY).option("--project <target>", "technical destination @organization/project").option("--world-promotion <id>", "continue one verified Tileflow World promotion").option("--map <name>", "map to connect when a promotion config contains multiple maps").option(
+program.command("deploy").description("Deploy maps to Tileflow and write the frontend manifest").option("-c, --config <path>", "config path", defaultConfigPath).option("--manifest <path>", "manifest path written for frontend bundlers", defaultManifestPath).option("--api-url <url>", "Tileflow API URL", process.env.TILEFLOW_API_URL).option("--api-key <key>", "Tileflow API key", process.env.TILEFLOW_API_KEY).option("--map-id <id>", "managed Map destination").option("--map <name>", "configured map to connect when the repository contains multiple maps").option(
   "--overwrite-self-hosted-manifest",
   "explicitly replace an existing self-hosted manifest at --manifest"
 ).action(
@@ -5232,6 +6889,7 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
     const source = resolveDeploySource(process.env);
     const resolveApi = (selectedMap) => requireApiOptions(options, {
       allowStoredCredential: allowsStoredDeployCredential(source),
+      assertExplicitKeyMap: true,
       capabilityScopes: ["styles:write"],
       retryCommand: cliInvocation([
         "tileflow",
@@ -5243,21 +6901,23 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
         "--api-url",
         options.apiUrl ?? defaultApiUrl,
         ...options.overwriteSelfHostedManifest ? ["--overwrite-self-hosted-manifest"] : [],
-        ...options.worldPromotion && selectedMap ? ["--world-promotion", options.worldPromotion, "--map", selectedMap] : []
+        ...options.mapId ? ["--map-id", options.mapId] : [],
+        ...options.map && selectedMap ? ["--map", selectedMap] : []
       ])
     });
     const apiUrl = normalizeApiOrigin(options.apiUrl ?? defaultApiUrl);
     delete process.env.TILEFLOW_API_KEY;
     logInfo(`Deploying ${pathLabel(options.config)}.`);
     const loaded = await withTileflowConfigSecretsHidden(
-      () => loadTileflowConfigWithInputs2(options.config)
+      () => loadTileflowConfigWithInputs3(options.config)
     );
     const project = loaded.project;
-    const baseDirectory = dirname9(loaded.configFile);
+    const baseDirectory = dirname10(loaded.configFile);
     assertValidTileflowConfig2(project);
     const configuredMapNames = getTileflowMapNames3(project);
-    const mapNames = selectWorldPromotionMaps(configuredMapNames, options);
+    const mapNames = selectManagedDeployMaps(configuredMapNames, options);
     if (!mapNames) return;
+    if (!validateDeployTarget(options)) return;
     if (!validateDeployManifestMapNames(mapNames)) return;
     const deploymentProject = mapNames.length === configuredMapNames.length ? project : {
       ...project,
@@ -5284,9 +6944,14 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
       apiBaseUrl: apiUrl,
       mapAssets: preflightMapAssets
     });
-    const preflightFonts = await prepareTileflowStyleFonts(
+    const preflightLocalTilesets = await prepareTileflowLocalTilesets(
       deploymentProject,
       compiledPreflightStyles,
+      { assetBaseUrl: apiUrl, baseDirectory, cwd: process.cwd() }
+    );
+    const preflightFonts = await prepareTileflowStyleFonts(
+      deploymentProject,
+      preflightLocalTilesets.styles,
       {
         assetBaseUrl: `${apiUrl}/fonts/preflight`,
         baseDirectory,
@@ -5299,6 +6964,14 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
     )) {
       return;
     }
+    const mapsWithHostedFontBundles = Object.keys(preflightFonts.bundles).sort();
+    if (mapsWithHostedFontBundles.length > 0) {
+      logError("Hosted deploy does not yet support package-owned web fonts.");
+      printKeyValue("Maps", mapsWithHostedFontBundles.join(", "));
+      printNextSteps(["Use self-hosted delivery or an explicit public glyph provider."]);
+      process.exitCode = 1;
+      return;
+    }
     let outputManifest = null;
     try {
       outputManifest = await loadExistingDeployManifest(options.manifest, {
@@ -5315,7 +6988,7 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
       process.exitCode = 1;
       return;
     }
-    const existingManifest = options.worldPromotion ? outputManifest : null;
+    const existingManifest = outputManifest;
     const api = await resolveApi(mapNames[0]);
     if (!api) return;
     const hostedSpriteByPackageHash = /* @__PURE__ */ new Map();
@@ -5335,7 +7008,7 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
       );
       const action = uploaded.value.changed === false ? "Reused" : "Uploaded";
       logSuccess(
-        `${action} icon package ${pc2.bold(binding?.label ?? "Icons")} (${plural(iconPackage.manifest.iconNames.length, "icon")}, ${formatBytes3(totalBytes)}, ${iconPackage.contentHash.slice(0, 12)}).`
+        `${action} icon package ${pc3.bold(binding?.label ?? "Icons")} (${plural(iconPackage.manifest.iconNames.length, "icon")}, ${formatBytes3(totalBytes)}, ${iconPackage.contentHash.slice(0, 12)}).`
       );
       hostedSpriteByPackageHash.set(iconPackage.contentHash, uploaded.value.spriteUrl);
     }
@@ -5348,12 +7021,21 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
       apiBaseUrl: api.apiUrl,
       mapAssets: hostedMapAssets
     });
-    const hostedFonts = await prepareTileflowStyleFonts(deploymentProject, compiledHostedStyles, {
-      assetBaseUrl: `${api.apiUrl}/font-bundles/preflight`,
-      baseDirectory,
-      cwd: process.cwd(),
-      target: "hosted"
-    });
+    const hostedLocalTilesets = await prepareTileflowLocalTilesets(
+      deploymentProject,
+      compiledHostedStyles,
+      { assetBaseUrl: api.apiUrl, baseDirectory, cwd: process.cwd() }
+    );
+    const hostedFonts = await prepareTileflowStyleFonts(
+      deploymentProject,
+      hostedLocalTilesets.styles,
+      {
+        assetBaseUrl: `${api.apiUrl}/font-bundles/preflight`,
+        baseDirectory,
+        cwd: process.cwd(),
+        target: "hosted"
+      }
+    );
     for (const mapName of mapNames) {
       if (hostedFonts.bundles[mapName]?.contentHash !== preflightFonts.bundles[mapName]?.contentHash) {
         throw new Error(`Font bundle changed after authentication for map ${mapName}.`);
@@ -5378,7 +7060,7 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
       );
       hostedFontBaseByHash.set(bundle.contentHash, uploaded.value.baseUrl);
     }
-    const styles = Object.fromEntries(
+    const fontBoundStyles = Object.fromEntries(
       mapNames.map((mapName) => {
         const themeStyles = hostedFonts.styles[mapName];
         const bundle = hostedFonts.bundles[mapName];
@@ -5396,6 +7078,19 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
         ];
       })
     );
+    const hostedThemeFamilies = Object.fromEntries(
+      mapNames.map((mapName) => [
+        mapName,
+        prepareTileflowHostedThemeFamily(
+          mapName,
+          deploymentProject.maps[mapName],
+          fontBoundStyles[mapName]
+        )
+      ])
+    );
+    const styles = Object.fromEntries(
+      Object.entries(hostedThemeFamilies).map(([mapName, family]) => [mapName, family.styles])
+    );
     const buildManifest = await createTileflowMapBuildManifest(
       Object.fromEntries(
         mapNames.map((mapName) => {
@@ -5413,7 +7108,9 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
                 })),
                 ...hostedFonts.bundles[mapName]?.files ?? []
               ],
-              lineage: deploymentProject.mapMetadata?.[mapName]?.lineage ?? collectTileflowMapBuildLineage(map),
+              lineage: deploymentProject.mapMetadata?.[mapName]?.lineage ?? [
+                { id: map.id, mapVersion: map.version }
+              ],
               map,
               sourceAssets: {
                 fonts: hostedFonts.sourceIdentities[mapName] ?? [],
@@ -5431,11 +7128,11 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
       const iconPackage = iconBinding ? packagesByHash.get(iconBinding.packageHash) : void 0;
       const fontBundle = hostedFonts.bundles[mapName];
       return {
-        allowedOrigins: deploymentProject.maps[mapName]?.delivery?.hosted?.allowedOrigins,
         iconBinding,
         iconPackage,
         fontBundle,
         mapName,
+        teamSources: hostedThemeFamilies[mapName].teamSources,
         buildManifest: {
           maps: { [mapName]: buildManifest.maps[mapName] },
           ...buildManifest.provenance ? { provenance: buildManifest.provenance } : {},
@@ -5447,30 +7144,32 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
     const deployedMaps = {};
     for (const deployment of deployments) {
       const {
-        allowedOrigins,
         buildManifest: buildManifest2,
         fontBundle,
         iconBinding,
         iconPackage,
         mapName,
+        teamSources,
         styles: themeStyles
       } = deployment;
       const themeNames = Object.keys(themeStyles).sort();
       logInfo(
-        `Deploying compiled map ${pc2.bold(mapName)} (${plural(themeNames.length, "theme")}).`
+        `Deploying compiled map ${pc3.bold(mapName)} (${plural(themeNames.length, "theme")}).`
       );
       const response = await publishHostedStyle(
         api,
         {
           artifact: {
             buildManifest: buildManifest2,
+            kind: "tileflow-map-deployment",
             mapId: mapName,
-            schemaVersion: 3,
-            styles: themeStyles
+            schemaVersion: 1,
+            styles: themeStyles,
+            teamSources
           },
           environment: mapName,
-          ...options.worldPromotion ? { usageMode: "session", worldPromotionId: options.worldPromotion } : {},
-          ...allowedOrigins ? { policy: { allowedOrigins } } : {},
+          managedMapId: options.mapId,
+          usageMode: "session",
           ...iconBinding && iconPackage ? {
             iconPackage: {
               contentHash: iconPackage.contentHash,
@@ -5493,8 +7192,9 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
         return;
       }
       const body = response.value;
-      if (options.worldPromotion && body.worldPromotionId !== options.worldPromotion) {
-        logError(`Deploy response did not confirm the World promotion for ${mapName}.`);
+      const expectedMapId = options.mapId ?? api.mapId;
+      if (expectedMapId && body.mapId !== expectedMapId) {
+        logError(`Deploy response did not confirm the requested Map for ${mapName}.`);
         process.exitCode = 1;
         return;
       }
@@ -5504,7 +7204,7 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
         process.exitCode = 1;
         return;
       }
-      const resolvedMap = parseTileflowMap2(deploymentProject.maps[mapName]);
+      const resolvedMap = parseResolvedTileflowMap3(deploymentProject.maps[mapName]);
       const mapBuild = buildManifest2.maps[mapName];
       deployedMaps[mapName] = {
         defaultTheme: resolvedMap.defaultTheme,
@@ -5528,13 +7228,14 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
           })
         ),
         ...resolvedMap.view ? { view: resolvedMap.view } : {},
-        ...options.worldPromotion ? { usageMode: "session", worldGeneration: "v1" } : {}
+        usageMode: "session",
+        worldGeneration: "v1"
       };
       const versionLabel = Number.isInteger(body.version) ? ` (v${body.version})` : "";
       if (body.changed === false) {
-        logSuccess(`Unchanged ${pc2.bold(mapName)}${versionLabel}.`);
+        logSuccess(`Unchanged ${pc3.bold(mapName)}${versionLabel}.`);
       } else {
-        logSuccess(`Published ${pc2.bold(mapName)}${versionLabel}.`);
+        logSuccess(`Published ${pc3.bold(mapName)}${versionLabel}.`);
       }
     }
     const manifestPath = await writeDeployManifest(options.manifest, {
@@ -5545,10 +7246,21 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
     logSuccess("Deployed Tileflow maps.");
     printKeyValue("Manifest", pathLabel(manifestPath));
     printDeployedMaps(deployedMaps);
-    printNextSteps([`Check hosted state with ${command("tileflow status")}.`]);
+    const deployedMapId = Object.values(deployedMaps)[0]?.mapId;
+    if (deployedMapId) {
+      printNextSteps([
+        `Check hosted state with ${command(`tileflow status --map-id ${deployedMapId}`)}.`
+      ]);
+    }
   }
 );
-program.command("status").description("Show deployed compiled styles").option("--api-url <url>", "Tileflow API URL", process.env.TILEFLOW_API_URL).option("--api-key <key>", "Tileflow API key", process.env.TILEFLOW_API_KEY).option("--project <target>", "technical destination @organization/project").option("--json", "print raw JSON").action(async (options) => {
+program.command("status").description("Show deployed compiled styles").option("--api-url <url>", "Tileflow API URL", process.env.TILEFLOW_API_URL).option("--api-key <key>", "Tileflow API key", process.env.TILEFLOW_API_KEY).option("--map-id <id>", "managed Map destination").option("--json", "print raw JSON").action(async (options) => {
+  if (!options.mapId || !/^map_[A-Za-z0-9_-]{16}$/u.test(options.mapId)) {
+    if (options.json) console.error("Status requires a valid --map-id.");
+    else logError("Status requires a valid --map-id.");
+    process.exitCode = 1;
+    return;
+  }
   let api;
   try {
     api = await requireApiOptions(options, {
@@ -5576,7 +7288,7 @@ program.command("status").description("Show deployed compiled styles").option("-
   }
   let status;
   try {
-    status = await fetchHostedProjectStatus(api);
+    status = await fetchHostedMapStatus(api);
   } catch (error) {
     const message = safeStatusError(error);
     if (options.json) console.error(message);
@@ -5584,11 +7296,17 @@ program.command("status").description("Show deployed compiled styles").option("-
     process.exitCode = 1;
     return;
   }
+  if (status.mapId !== options.mapId) {
+    if (options.json) console.error("Status response belongs to another Map.");
+    else logError("Status response belongs to another Map.");
+    process.exitCode = 1;
+    return;
+  }
   if (options.json) {
     console.log(JSON.stringify(status, null, 2));
     return;
   }
-  printProjectStatus(status, api.apiUrl);
+  printMapStatus(status, api.apiUrl);
 });
 var iconsCommand = program.command("icons").description("Inspect managed Tileflow icons");
 registerIconListCommand(iconsCommand, { defaultConfigPath });
@@ -5599,6 +7317,7 @@ registerIconDiffCommand(iconsCommand, {
   resolveApi: (options) => {
     const source = resolveDeploySource(process.env);
     return requireApiOptions(options, {
+      assertExplicitKeyMap: true,
       allowStoredCredential: allowsStoredDeployCredential(source),
       capabilityScopes: ["status:read"],
       retryCommand: cliInvocation([
@@ -5608,6 +7327,8 @@ registerIconDiffCommand(iconsCommand, {
         "--against",
         options.against,
         ...options.config ? ["--config", options.config] : [],
+        "--map-id",
+        options.mapId,
         "--api-url",
         options.apiUrl ?? defaultApiUrl
       ]),
@@ -5618,6 +7339,7 @@ registerIconDiffCommand(iconsCommand, {
 var inspectCommand = program.command("inspect").description("Inspect map data for authoring");
 registerConfigInspectCommand(inspectCommand, { defaultConfigPath });
 registerFeatureInspectCommand(inspectCommand, { defaultConfigPath });
+registerAiCommands(program, { defaultApiUrl, defaultConfigPath });
 registerCaptureCommands(program, { defaultConfigPath });
 registerVisualCommands(program, {
   defaultConfigPath,
@@ -5857,7 +7579,7 @@ async function loginWithDeviceFlow(options) {
     codeChallenge,
     deviceName: hostname()
   });
-  printKeyValue("Code", pc2.bold(authorization.userCode));
+  printKeyValue("Code", pc3.bold(authorization.userCode));
   printKeyValue("URL", link(authorization.verificationUriComplete));
   if (options.noBrowser) {
     logMuted("Open the URL above to continue.");
@@ -5867,7 +7589,7 @@ async function loginWithDeviceFlow(options) {
       output: process.stdout
     });
     try {
-      await readline.question(`${pc2.cyan("?")} Press Enter to open Tileflow Dashboard...`);
+      await readline.question(`${pc3.cyan("?")} Press Enter to open Tileflow Dashboard...`);
       openBrowser(authorization.verificationUriComplete);
     } finally {
       readline.close();
@@ -5901,7 +7623,7 @@ async function loginWithDeviceFlow(options) {
   printKeyValue("Dashboard", link(options.appUrl));
 }
 function createPkceChallenge(verifier) {
-  return createHash3("sha256").update(verifier).digest("base64url");
+  return createHash4("sha256").update(verifier).digest("base64url");
 }
 function randomBase64Url(byteLength) {
   return randomBytes2(byteLength).toString("base64url");
@@ -5920,7 +7642,7 @@ function openBrowser(url, errorsToStderr = false) {
 async function writeDeployManifest(manifestPath, manifest) {
   const outputPath = resolve7(process.cwd(), manifestPath);
   await writeAtomicFile({
-    boundaryPath: dirname9(outputPath),
+    boundaryPath: dirname10(outputPath),
     force: true,
     label: "Deploy manifest",
     managed: true,
@@ -5938,36 +7660,46 @@ function createCompiledMapAssets(compiled, resolveSprite) {
     ])
   );
 }
-function selectWorldPromotionMaps(mapNames, options) {
-  if (options.map && !options.worldPromotion) {
-    logError("--map is reserved for continuing a verified World promotion.");
-    process.exitCode = 1;
-    return null;
-  }
-  if (!options.worldPromotion) return mapNames;
-  if (!/^wpr_[A-Za-z0-9_-]{8,80}$/u.test(options.worldPromotion)) {
-    logError("World promotion reference is invalid.");
+function selectManagedDeployMaps(mapNames, options) {
+  if (options.map && !options.mapId) {
+    logError("--map requires --map-id.");
     process.exitCode = 1;
     return null;
   }
   if (options.map) {
     if (!mapNames.includes(options.map)) {
-      logError(`Unknown Tileflow map for World promotion: ${options.map}.`);
+      logError(`Unknown Tileflow map: ${options.map}.`);
       printKeyValue("Maps", mapNames.join(", "));
       process.exitCode = 1;
       return null;
     }
     return [options.map];
   }
+  if (!options.mapId) return mapNames;
   if (mapNames.length === 1) return [mapNames[0]];
-  logError("World promotion requires an explicit map because this config contains multiple maps.");
+  logError(
+    "This managed target requires an explicit map because the config contains multiple maps."
+  );
   printKeyValue("Maps", mapNames.join(", "));
   printNextSteps([
-    `Retry with ${command(`tileflow deploy --world-promotion ${options.worldPromotion} --map ${mapNames[0]}`)}.`
+    `Retry with ${command(`tileflow deploy --map-id ${options.mapId} --map ${mapNames[0]}`)}.`
   ]);
   process.exitCode = 1;
   return null;
 }
+function validateDeployTarget(options) {
+  if (!options.mapId) {
+    logError("Managed deploy requires --map-id.");
+    process.exitCode = 1;
+    return false;
+  }
+  if (options.mapId && !/^map_[A-Za-z0-9_-]{16}$/u.test(options.mapId)) {
+    logError("Managed Map ID is invalid.");
+    process.exitCode = 1;
+    return false;
+  }
+  return true;
+}
 function validateDeployManifestMapNames(mapNames) {
   for (const mapName of mapNames) {
     if (!tileflowMapIdSchema2.safeParse(mapName).success) {
@@ -5981,7 +7713,7 @@ function validateDeployManifestMapNames(mapNames) {
 async function loadExistingDeployManifest(manifestPath, options) {
   let source;
   try {
-    source = await readFile6(resolve7(process.cwd(), manifestPath), "utf8");
+    source = await readFile7(resolve7(process.cwd(), manifestPath), "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw new Error("Existing Tileflow manifest could not be read.");
@@ -6014,13 +7746,32 @@ async function loadExistingDeployManifest(manifestPath, options) {
 }
 async function requireApiOptions(options, behavior = {}) {
   const apiUrl = normalizeApiOrigin(options.apiUrl ?? defaultApiUrl);
+  const requestedMapId = options.mapId;
   const requested = options.project ? parseProjectReference(options.project) : null;
+  if (requestedMapId && !/^map_[A-Za-z0-9_-]{16}$/u.test(requestedMapId)) {
+    if (!behavior.silent) logError("Managed Map ID is invalid.");
+    process.exitCode = 1;
+    return null;
+  }
   if (options.project && !requested) {
     if (!behavior.silent) logError("Managed destination must use @organization/project syntax.");
     process.exitCode = 1;
     return null;
   }
   if (options.apiKey) {
+    if (requestedMapId && behavior.assertExplicitKeyMap) {
+      const profile = await validateApiKey(apiUrl, options.apiKey);
+      if (!profile.ok) {
+        if (!behavior.silent) logError(profile.error);
+        process.exitCode = 1;
+        return null;
+      }
+      if (profile.value.mapId !== requestedMapId) {
+        if (!behavior.silent) logError("This API key belongs to another Map.");
+        process.exitCode = 1;
+        return null;
+      }
+    }
     if (requested) {
       const profile = await validateApiKey(apiUrl, options.apiKey);
       if (!profile.ok) {
@@ -6028,7 +7779,7 @@ async function requireApiOptions(options, behavior = {}) {
         process.exitCode = 1;
         return null;
       }
-      if (projectReference(profile.value) !== options.project) {
+      if (requested && projectReference(profile.value) !== options.project) {
         if (!behavior.silent) {
           logError(
             `This project key belongs to ${projectReference(profile.value)}, not ${options.project}.`
@@ -6038,14 +7789,18 @@ async function requireApiOptions(options, behavior = {}) {
         return null;
       }
     }
-    return { apiKey: options.apiKey, apiUrl };
+    return {
+      apiKey: options.apiKey,
+      apiUrl,
+      ...requestedMapId ? { mapId: requestedMapId } : {}
+    };
   }
   const allowStoredCredential = behavior.allowStoredCredential !== false && allowsStoredDeployCredential(resolveDeploySource(process.env));
   if (!allowStoredCredential) {
     if (!behavior.silent) {
-      logError("CI requires an explicit application-scoped Tileflow API key.");
+      logError("CI requires an explicit Map-scoped Tileflow API key.");
       printNextSteps([
-        `Set ${pc2.cyan("TILEFLOW_API_KEY")} from the CI secret store.`,
+        `Set ${pc3.cyan("TILEFLOW_API_KEY")} from the CI secret store.`,
         "The saved personal account session is never used in CI."
       ]);
     }
@@ -6071,6 +7826,19 @@ async function requireApiOptions(options, behavior = {}) {
     process.exitCode = 1;
     return null;
   }
+  if (requestedMapId) {
+    const capability2 = await requestMapCapability(
+      resolvedSession.session,
+      { mapId: requestedMapId },
+      behavior.capabilityScopes ?? ["status:read"]
+    );
+    if (!capability2.ok) {
+      if (!behavior.silent) logError(capability2.error);
+      process.exitCode = 1;
+      return null;
+    }
+    return { apiKey: capability2.capability, apiUrl, mapId: capability2.mapId };
+  }
   const target = await resolveAccountProjectTarget(resolvedSession.session, options.project);
   if (target.kind === "remote") {
     if (!behavior.silent) logError(target.error);
@@ -6138,17 +7906,17 @@ function printCliError(error) {
   }
   const message = error instanceof Error ? error.message : "Command failed.";
   if (message.includes("Cannot find module '@tileflow/core'")) {
-    logError(`Cannot load ${pc2.cyan("@tileflow/core")} from this project.`);
+    logError(`Cannot load ${pc3.cyan("@tileflow/core")} from this project.`);
     printNextSteps([
-      `Install ${pc2.cyan("@tileflow/core")} in this project.`,
+      `Install ${pc3.cyan("@tileflow/core")} in this project.`,
       `Run the command again from the project root.`
     ]);
     return;
   }
   if (message.includes("Cannot find module '@tileflow/maps'")) {
-    logError(`Cannot load ${pc2.cyan("@tileflow/maps")} from this project.`);
+    logError(`Cannot load ${pc3.cyan("@tileflow/maps")} from this project.`);
     printNextSteps([
-      `Install ${pc2.cyan("@tileflow/maps")} in this project.`,
+      `Install ${pc3.cyan("@tileflow/maps")} in this project.`,
       `Run the command again from the project root.`
     ]);
     return;
@@ -6159,51 +7927,51 @@ function printCliError(error) {
   }
 }
 function logSuccess(message) {
-  console.log(`${pc2.green("\u2713")} ${message}`);
+  console.log(`${pc3.green("\u2713")} ${message}`);
 }
 function logError(message) {
-  console.log(`${pc2.red("\u2715")} ${message}`);
+  console.log(`${pc3.red("\u2715")} ${message}`);
 }
 function logWarning(message) {
-  console.log(`${pc2.yellow("!")} ${message}`);
+  console.log(`${pc3.yellow("!")} ${message}`);
 }
 function logInfo(message) {
-  console.log(`${pc2.cyan("i")} ${message}`);
+  console.log(`${pc3.cyan("i")} ${message}`);
 }
 function logMuted(message) {
-  console.log(pc2.gray(message));
+  console.log(pc3.gray(message));
 }
 function printTitle(title, subtitle) {
-  console.log(pc2.bold(title));
+  console.log(pc3.bold(title));
   if (subtitle) {
-    console.log(pc2.gray(subtitle));
+    console.log(pc3.gray(subtitle));
   }
 }
 function printKeyValue(label, value) {
-  console.log(`${pc2.gray(`${label}:`.padEnd(13))} ${value}`);
+  console.log(`${pc3.gray(`${label}:`.padEnd(13))} ${value}`);
 }
 function printChecks(items) {
   for (const item of items) {
-    console.log(`  ${pc2.green("\u2713")} ${item}`);
+    console.log(`  ${pc3.green("\u2713")} ${item}`);
   }
 }
 function printNextSteps(steps) {
   if (steps.length === 0) return;
   console.log(`
-${pc2.bold("Next steps")}`);
+${pc3.bold("Next steps")}`);
   for (const step of steps) {
-    console.log(`  ${pc2.cyan("\u2022")} ${step}`);
+    console.log(`  ${pc3.cyan("\u2022")} ${step}`);
   }
 }
 function printValidationErrors(messages) {
   logError("Tileflow config has errors.");
   for (const message of messages) {
-    const path = message.path ? pc2.cyan(message.path) : pc2.cyan("(root)");
-    console.log(`  ${pc2.red("\u2715")} ${path} ${pc2.gray("-")} ${message.message}`);
+    const path = message.path ? pc3.cyan(message.path) : pc3.cyan("(root)");
+    console.log(`  ${pc3.red("\u2715")} ${path} ${pc3.gray("-")} ${message.message}`);
   }
 }
 function printAccountDetails(session) {
-  printKeyValue("Account", pc2.bold(session.account.name));
+  printKeyValue("Account", pc3.bold(session.account.name));
   printKeyValue("Email", session.account.email);
   printKeyValue("API", link(session.apiOrigin));
   printKeyValue("Expires", formatDate(session.expiresAt));
@@ -6232,11 +8000,11 @@ function printDeployedMaps(maps) {
   const entries = Object.entries(maps);
   if (entries.length === 0) return;
   console.log(`
-${pc2.bold("Maps")}`);
+${pc3.bold("Maps")}`);
   for (const [name, map] of entries) {
     for (const [themeName, theme] of Object.entries(map.themes)) {
       const label = `${name}/${themeName}`;
-      console.log(`  ${pc2.green("\u2713")} ${label.padEnd(24)} ${link(theme.styleUrl)}`);
+      console.log(`  ${pc3.green("\u2713")} ${label.padEnd(24)} ${link(theme.styleUrl)}`);
     }
   }
 }
@@ -6254,7 +8022,7 @@ function plural(count, singular, pluralForm = `${singular}s`) {
   return `${count} ${count === 1 ? singular : pluralForm}`;
 }
 function command(value) {
-  return pc2.cyan(value);
+  return pc3.cyan(value);
 }
 function cliInvocation(parts) {
   return parts.map(quoteCliArgument).join(" ");
@@ -6263,10 +8031,10 @@ function quoteCliArgument(value) {
   return /^[A-Za-z0-9_./:@%+=,-]+$/u.test(value) ? value : `'${value.replaceAll("'", `'"'"'`)}'`;
 }
 function link(value) {
-  return pc2.cyan(value);
+  return pc3.cyan(value);
 }
 function pathLabel(value) {
-  return pc2.cyan(value);
+  return pc3.cyan(value);
 }
 function starterConfig() {
   return `import { defineMap, defineTheme, labels, poi } from "@tileflow/core";
@@ -6295,7 +8063,7 @@ export default defineMap({
   systemThemes: { light: "light", dark: "dark" },
   modules: {
     labels: labels({ roads: "major" }),
-    poi: poi({ enabled: true, density: 3, icons: true })
+    poi: poi({ density: 3, icons: true })
   },
   view: {
     center: [-3.7038, 40.4168],
@@ -6310,17 +8078,17 @@ function printHostedCompatibilityIssues(issues) {
   process.exitCode = 1;
   return false;
 }
-function printProjectStatus(status, apiUrl) {
+function printMapStatus(status, apiUrl) {
   printTitle("Tileflow status");
-  printKeyValue("Application", pc2.bold(status.projectId));
+  printKeyValue("Map", pc3.bold(status.mapId));
   console.log(`
-${pc2.bold("Styles")}`);
+${pc3.bold("Styles")}`);
   if (status.styles.length === 0) {
     logMuted("  No styles deployed.");
   }
   for (const style of status.styles) {
     console.log(
-      `  ${pc2.green("\u2713")} ${style.environment.padEnd(16)} ${link(`${apiUrl}/maps/${style.mapId}/style.json`).padEnd(36)} ${formatBytes3(style.size).padStart(10)}  ${pc2.gray(formatDate(style.uploaded))}`
+      `  ${pc3.green("\u2713")} ${style.environment.padEnd(16)} ${link(`${apiUrl}/maps/${style.mapId}/style.json`).padEnd(36)} ${formatBytes3(style.size).padStart(10)}  ${pc3.gray(formatDate(style.uploaded))}`
     );
   }
 }