tileflow 0.1.0-alpha.6 → 0.1.0-alpha.8

package/dist/index.js

@@ -7,55 +7,59 @@ import { createHash as createHash4, randomBytes as randomBytes2 } from "crypto";
 import { existsSync, readFileSync, realpathSync } from "fs";
 import { readFile as readFile7, writeFile as writeFile2 } from "fs/promises";
 import { hostname } from "os";
-import { dirname as dirname10, isAbsolute as isAbsolute4, relative as relative5, resolve as resolve7, sep as sep5 } from "path";
+import { dirname as dirname12, isAbsolute as isAbsolute5, relative as relative5, resolve as resolve8, sep as sep5 } from "path";
 import { createInterface } from "readline/promises";
-import pc3 from "picocolors";
+import pc6 from "picocolors";
 import { createLocalCoordinates, setupCoordinates } from "@tileflow/coordinates-runtime";
 import {
-  auditTileflowMapThemeValues,
-  getTileflowStyleFontFaces,
-  parseResolvedTileflowMap as parseResolvedTileflowMap3,
+  auditTileflowMapThemeValues as auditTileflowMapThemeValues2,
+  getTileflowStyleFontFaces as getTileflowStyleFontFaces2,
+  parseResolvedTileflowMap as parseResolvedTileflowMap5,
   tileflowMapIdSchema as tileflowMapIdSchema2
 } from "@tileflow/core";
 import {
-  createTileflowMapBuildManifest
+  createTileflowMapBuildManifest as createTileflowMapBuildManifest2
 } from "@tileflow/core/build";
 import {
-  parseTileflowRuntimeManifest
+  parseTileflowRuntimeManifest as parseTileflowRuntimeManifest2
 } from "@tileflow/core/manifest";
+import { resolveTileflowRenderer as resolveTileflowRenderer2 } from "@tileflow/core/native-profile";
 import {
   createTileflowArtifactDiagnostics as createTileflowArtifactDiagnostics3,
   createTileflowArtifactSession as createTileflowArtifactSession3,
-  createTileflowBuildProvenance,
-  createTileflowStyles,
-  prepareTileflowLocalTilesets,
+  createTileflowBuildProvenance as createTileflowBuildProvenance2,
+  createTileflowStyles as createTileflowStyles2,
+  prepareTileflowLocalTilesets as prepareTileflowLocalTilesets2,
   writeTileflowBuildArtifacts
 } from "@tileflow/dev/artifacts";
 import {
-  assertValidTileflowConfig as assertValidTileflowConfig2,
+  assertValidTileflowConfig as assertValidTileflowConfig3,
   defaultTileflowApiUrl,
   defaultTileflowConfigPath,
   defaultTileflowManifestPath,
-  getTileflowMapNames as getTileflowMapNames3,
-  loadTileflowConfigWithInputs as loadTileflowConfigWithInputs3,
-  TileflowValidationError as TileflowValidationError4
+  getTileflowMapNames as getTileflowMapNames5,
+  loadTileflowConfigWithInputs as loadTileflowConfigWithInputs4,
+  TileflowValidationError as TileflowValidationError5
 } from "@tileflow/dev/config";
 import {
   bindTileflowStyleFontBundle,
-  prepareTileflowStyleFonts,
+  prepareTileflowStyleFonts as prepareTileflowStyleFonts2,
   TileflowFontCompilationError
 } from "@tileflow/dev/fonts";
-import { compileTileflowIconPackages as compileTileflowIconPackages2, TileflowIconCompilationError as TileflowIconCompilationError3 } from "@tileflow/dev/icons";
+import {
+  compileTileflowIconPackages as compileTileflowIconPackages3,
+  TileflowIconCompilationError as TileflowIconCompilationError3
+} from "@tileflow/dev/icons";
 import { resolveTileflowPreview } from "@tileflow/dev/preview";
 import {
   createTileflowComparisonRequestHandler,
-  createTileflowDevRequestHandler
+  createTileflowDevRequestHandler as createTileflowDevRequestHandler2
 } from "@tileflow/dev/server";
 import {
-  createTileflowCommandFailureDocument as createTileflowCommandFailureDocument4,
-  createTileflowCommandSummary as createTileflowCommandSummary2,
-  createTileflowStructuredDiagnostics as createTileflowStructuredDiagnostics2,
-  serializeTileflowCommandDocument as serializeTileflowCommandDocument4,
+  createTileflowCommandFailureDocument as createTileflowCommandFailureDocument5,
+  createTileflowCommandSummary as createTileflowCommandSummary3,
+  createTileflowStructuredDiagnostics as createTileflowStructuredDiagnostics3,
+  serializeTileflowCommandDocument as serializeTileflowCommandDocument5,
   TileflowStyleValidationError as TileflowStyleValidationError2
 } from "@tileflow/dev/validation";
 
@@ -382,14 +386,14 @@ async function runExplain(options, compileStyle) {
     });
     if (!selection) throw new Error("Explain selection was not resolved.");
     if (!output.result.ok) {
-      const failure = createTileflowCommandFailureDocument(
+      const failure2 = createTileflowCommandFailureDocument(
         "explain",
         { diagnostics: output.structuredDiagnostics },
         process.cwd(),
         { code: "COMPILATION_FAILED", phase: "compilation" }
       );
       const document2 = {
-        ...failure,
+        ...failure2,
         authoringManifestSchemaVersion: tileflowAuthoringManifestSchemaVersion,
         selection,
         compilation: output.compilation
@@ -419,12 +423,12 @@ async function runExplain(options, compileStyle) {
     if (options.json) process.stdout.write(serializeTileflowCommandDocument(document));
     else printHumanExplain(document);
   } catch (error) {
-    const failure = createTileflowCommandFailureDocument("explain", error, process.cwd(), {
+    const failure2 = createTileflowCommandFailureDocument("explain", error, process.cwd(), {
       code: "EXPLAIN_FAILED",
       phase: "compilation"
     });
-    if (options.json) process.stderr.write(serializeTileflowCommandDocument(failure));
-    else printHumanCommandFailure(failure);
+    if (options.json) process.stderr.write(serializeTileflowCommandDocument(failure2));
+    else printHumanCommandFailure(failure2);
     process.exitCode = 1;
   }
 }
@@ -468,12 +472,12 @@ async function runSemanticDiff(options, defaultConfigPath2) {
     if (options.json) process.stdout.write(serializeTileflowCommandDocument(document));
     else printHumanSemanticDiff(difference);
   } catch (error) {
-    const failure = createTileflowCommandFailureDocument("semantic-diff", error, process.cwd(), {
+    const failure2 = createTileflowCommandFailureDocument("semantic-diff", error, process.cwd(), {
       code: "SEMANTIC_DIFF_FAILED",
       phase: "semantic-diff"
     });
-    if (options.json) process.stderr.write(serializeTileflowCommandDocument(failure));
-    else printHumanCommandFailure(failure);
+    if (options.json) process.stderr.write(serializeTileflowCommandDocument(failure2));
+    else printHumanCommandFailure(failure2);
     process.exitCode = 1;
   }
 }
@@ -1212,14 +1216,14 @@ async function runCaptureWatchCommand(positionalScenes, options) {
     } catch (error) {
       if (signal.aborted || stopped) return;
       unresolvedFailure = true;
-      const failure = createTileflowCaptureFailureJson(error, cwd);
+      const failure2 = createTileflowCaptureFailureJson(error, cwd);
       emit({
         event: "failed",
         generation,
-        code: failure.code,
-        phase: failure.phase,
-        diagnostics: failure.diagnostics,
-        ...failure.resources ? { resources: failure.resources } : {}
+        code: failure2.code,
+        phase: failure2.phase,
+        diagnostics: failure2.diagnostics,
+        ...failure2.resources ? { resources: failure2.resources } : {}
       });
     }
   };
@@ -1545,6 +1549,11 @@ function runGit(cwd, args) {
   });
 }
 
+// src/cli-version.ts
+function isRootCliVersionRequest(arguments_) {
+  return arguments_.length === 1 && (arguments_[0] === "--version" || arguments_[0] === "-V");
+}
+
 // src/config-inspect-command.ts
 import { inspectTileflowConfig } from "@tileflow/dev/inspect";
 import {
@@ -1563,18 +1572,18 @@ function registerConfigInspectCommand(inspect, dependencies) {
       }
       printHumanConfigInspection(document);
     } catch (error) {
-      const failure = createTileflowCommandFailureDocument2("inspect", error, process.cwd(), {
+      const failure2 = createTileflowCommandFailureDocument2("inspect", error, process.cwd(), {
         code: "INSPECTION_FAILED",
         phase: "config-inspection"
       });
       if (options.json) {
-        process.stderr.write(serializeTileflowCommandDocument2(failure));
+        process.stderr.write(serializeTileflowCommandDocument2(failure2));
       } else {
-        console.error(`${failure.message} [${failure.code}; ${failure.phase}]`);
-        for (const diagnostic of failure.diagnostics.slice(1)) {
+        console.error(`${failure2.message} [${failure2.code}; ${failure2.phase}]`);
+        for (const diagnostic of failure2.diagnostics.slice(1)) {
           console.error(`- ${diagnostic.path || "(root)"}: ${diagnostic.message}`);
         }
-        console.error(`Suggestion: ${failure.suggestion}`);
+        console.error(`Suggestion: ${failure2.suggestion}`);
       }
       process.exitCode = 1;
     }
@@ -1654,19 +1663,19 @@ function registerCoordinatesCommands(program2, dependencies) {
     coordinates,
     "search",
     dependencies,
-    (options) => parseRequest("search", options, { query: options.query })
+    (options) => parseCoordinatesRequest("search", { query: options.query })
   );
   registerOperation(
     coordinates,
     "describe",
     dependencies,
-    (options) => parseRequest("describe", options, { id: options.id })
+    (options) => parseCoordinatesRequest("describe", { id: options.id })
   );
   registerOperation(
     coordinates,
     "operations",
     dependencies,
-    (options) => parseRequest("operations", options, { from: options.from, to: options.to })
+    (options) => parseCoordinatesRequest("operations", { from: options.from, to: options.to })
   );
   registerOperation(
     coordinates,
@@ -1765,9 +1774,6 @@ function hasConvenienceOptions(command2, options) {
   const transform = options;
   return transform.from !== void 0 || transform.to !== void 0 || transform.positions !== void 0;
 }
-function parseRequest(command2, options, request) {
-  return parseCoordinatesRequest(command2, request);
-}
 function parseTransformRequest(options) {
   let positions;
   try {
@@ -1812,7 +1818,7 @@ async function readCoordinatesInput(input, signal) {
 async function readStandardInput(signal) {
   const chunks = [];
   let length = 0;
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const finish = (result) => {
       process.stdin.removeListener("data", onData);
       process.stdin.removeListener("end", onEnd);
@@ -1834,7 +1840,7 @@ async function readStandardInput(signal) {
       }
       chunks.push(bytes);
     };
-    const onEnd = () => finish(() => resolve8(decodeInput(Buffer.concat(chunks))));
+    const onEnd = () => finish(() => resolve9(decodeInput(Buffer.concat(chunks))));
     const onError = () => finish(() => reject(new CoordinatesInputError("INVALID_VALUE")));
     if (signal.aborted) {
       onAbort();
@@ -1892,10 +1898,10 @@ function serializeCoordinatesFailure(error, command2) {
   if (!(error instanceof CoordinatesContractError)) return void 0;
   const parsed = coordinatesFailureSchema.safeParse(error.toJSON());
   if (!parsed.success) return void 0;
-  const failure = parsed.data;
+  const failure2 = parsed.data;
   return new CoordinatesContractError({
-    ...failure,
-    command: failure.command ?? command2 ?? null
+    ...failure2,
+    command: failure2.command ?? command2 ?? null
   }).toJSON();
 }
 function serializeSetupFailure(error) {
@@ -2217,6 +2223,7 @@ import { tileflowIconPackageLimits } from "@tileflow/core";
 var maximumHostedResponseBytes = 1024 * 1024;
 var safeTextSchema = z2.string().min(1).max(300).refine((value) => !/[\p{Cc}]/u.test(value));
 var safeIdentifierSchema = z2.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/u);
+var safeStorageKeySchema = z2.string().min(1).max(512).regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/u).refine((value) => value.split("/").every((segment) => segment !== "." && segment !== ".."));
 var publicHttpUrlSchema = z2.url().max(2048).refine((value) => {
   const url = new URL(value);
   return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash;
@@ -2252,7 +2259,7 @@ var hostedFontBundleResponseSchema = z2.object({
 });
 var hostedStatusStyleSchema = z2.object({
   environment: safeTextSchema,
-  key: safeIdentifierSchema,
+  key: safeStorageKeySchema,
   mapId: safeIdentifierSchema,
   size: z2.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
   uploaded: z2.iso.datetime({ offset: true })
@@ -2343,7 +2350,7 @@ async function startDeviceAuthorization(appUrl, body, options = {}) {
 async function pollDeviceToken(appUrl, authorization, input, options = {}) {
   const expiresAt = Date.now() + authorization.expiresIn * 1e3;
   const intervalMs = Math.max(authorization.interval, 1) * 1e3;
-  const wait = input.sleep ?? ((milliseconds) => new Promise((resolve8) => setTimeout(resolve8, milliseconds)));
+  const wait = input.sleep ?? ((milliseconds) => new Promise((resolve9) => setTimeout(resolve9, milliseconds)));
   while (Date.now() < expiresAt) {
     await wait(intervalMs);
     const response = await requestHostedJson(
@@ -2673,7 +2680,7 @@ async function withHostedResponse(apiUrl, path, init, options, consume) {
 }
 function raceWithAbort(operation, signal) {
   if (signal.aborted) return Promise.reject(signal.reason);
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const cleanup = () => signal.removeEventListener("abort", onAbort);
     const onAbort = () => {
       cleanup();
@@ -2683,7 +2690,7 @@ function raceWithAbort(operation, signal) {
     operation.then(
       (value) => {
         cleanup();
-        resolve8(value);
+        resolve9(value);
       },
       (error) => {
         cleanup();
@@ -2801,6 +2808,33 @@ function safeTransportError(error, fallback) {
   return fallback;
 }
 
+// src/hosted-native-deploy.ts
+import { dirname as dirname5 } from "path";
+import {
+  getTileflowStyleFontFaces,
+  parseResolvedTileflowMap as parseResolvedTileflowMap2,
+  serializeCanonicalJson
+} from "@tileflow/core";
+import {
+  createTileflowMapBuildManifest,
+  parseTileflowRendererDeploymentArtifact,
+  tileflowRendererDeploymentResponseSchema
+} from "@tileflow/core/build";
+import { parseTileflowRuntimeManifest } from "@tileflow/core/manifest";
+import {
+  createTileflowBuildProvenance,
+  createTileflowStyles,
+  prepareTileflowHostedNativeDeployment,
+  prepareTileflowLocalTilesets
+} from "@tileflow/dev/artifacts";
+import {
+  assertValidTileflowConfig,
+  getTileflowMapNames,
+  loadTileflowConfigWithInputs as loadTileflowConfigWithInputs2
+} from "@tileflow/dev/config";
+import { prepareTileflowStyleFonts } from "@tileflow/dev/fonts";
+import { compileTileflowIconPackages } from "@tileflow/dev/icons";
+
 // src/hosted-preflight.ts
 import {
   compareCodeUnits as compareCodeUnits4,
@@ -2865,44 +2899,312 @@ function cloneStyle(style) {
   return JSON.parse(JSON.stringify(style));
 }
 
+// src/hosted-native-deploy.ts
+function failure(message) {
+  return Object.assign(new Error(message), { code: "TF_NATIVE_DEPLOYMENT_INVALID" });
+}
+function requireNativeTarget(options) {
+  if (!options.mapId || !/^map_[A-Za-z0-9_-]{16}$/u.test(options.mapId))
+    throw failure("--with-native requires one valid --map-id.");
+  const apiOrigin = normalizeApiOrigin(options.apiUrl);
+  if (!apiOrigin.startsWith("https://"))
+    throw failure("Hosted Native deployment requires an HTTPS API origin.");
+  return { apiOrigin, mapId: options.mapId };
+}
+async function prepareNativeHostedDeploy(options) {
+  const { apiOrigin } = requireNativeTarget(options);
+  const loaded = await withTileflowConfigSecretsHidden(
+    () => loadTileflowConfigWithInputs2(options.config)
+  );
+  assertValidTileflowConfig(loaded.project);
+  const names = getTileflowMapNames(loaded.project);
+  const mapName = options.map ?? (names.length === 1 ? names[0] : void 0);
+  if (!mapName || !names.includes(mapName))
+    throw failure("Select one configured map with --map for this Native deployment.");
+  const map = loaded.project.maps[mapName];
+  const project = { ...loaded.project, maps: { [mapName]: map } };
+  const baseDirectory = dirname5(loaded.configFile);
+  const compiledIcons = await compileTileflowIconPackages(project, {
+    baseDirectory,
+    cwd: process.cwd(),
+    target: "hosted",
+    icons: {
+      ...options.cacheDir ? { cacheRoot: options.cacheDir } : {},
+      ...options.offline ? { offline: true } : {}
+    }
+  });
+  const binding = compiledIcons.bindings.find((entry) => entry.mapName === mapName);
+  const iconPackage = binding ? compiledIcons.packages.find((entry) => entry.contentHash === binding.packageHash) : void 0;
+  const sprite = binding ? `${apiOrigin}/sprites/preflight/${binding.packageHash}/sprite` : void 0;
+  const mapAssets = Object.fromEntries(
+    compiledIcons.bindings.map((entry) => [
+      entry.mapName,
+      {
+        icons: {
+          ids: entry.iconIds,
+          sprite: `${apiOrigin}/sprites/preflight/${entry.packageHash}/sprite`
+        }
+      }
+    ])
+  );
+  const styles = createTileflowStyles(project, { apiBaseUrl: apiOrigin, mapAssets });
+  const local = await prepareTileflowLocalTilesets(project, styles, {
+    assetBaseUrl: apiOrigin,
+    baseDirectory,
+    cwd: process.cwd()
+  });
+  try {
+    const fonts = await prepareTileflowStyleFonts(project, local.styles, {
+      assetBaseUrl: `${apiOrigin}/fonts/preflight`,
+      baseDirectory,
+      cwd: process.cwd(),
+      target: "hosted"
+    });
+    if (inspectTileflowHostedCompatibility(project, fonts.styles).length)
+      throw failure("Hosted renderer deployment requires compatible Tileflow World sources.");
+    if (Object.keys(fonts.bundles).length)
+      throw failure(
+        "Hosted deploy does not yet support package-owned web fonts. Use an explicit public glyph provider."
+      );
+    const assets = (iconPackage?.files ?? []).map((file) => ({
+      contentType: file.contentType,
+      fileName: `icons/${mapName}/${file.fileName}`,
+      source: file.source
+    }));
+    const provenance = await createTileflowBuildProvenance(process.cwd());
+    const resolved = parseResolvedTileflowMap2(map);
+    const inputStyles = JSON.parse(
+      serializeCanonicalJson(fonts.styles[mapName])
+    );
+    const createArtifact = async (selectedSprite) => {
+      const selected = JSON.parse(
+        serializeCanonicalJson(inputStyles)
+      );
+      if (binding) {
+        if (!sprite || !selectedSprite) throw failure("Missing confirmed sprite binding.");
+        for (const style of Object.values(selected)) {
+          if (style.sprite !== sprite)
+            throw failure("Compiled sprite identity changed before publication.");
+          style.sprite = selectedSprite;
+        }
+      }
+      const family = prepareTileflowHostedThemeFamily(mapName, map, selected);
+      const buildManifest = await createTileflowMapBuildManifest(
+        {
+          [mapName]: {
+            assets,
+            lineage: project.mapMetadata?.[mapName]?.lineage ?? [
+              { id: map.id, mapVersion: map.version }
+            ],
+            map,
+            sourceAssets: {
+              fonts: fonts.sourceIdentities[mapName] ?? [],
+              icons: compiledIcons.sourceIdentities[mapName] ?? [],
+              ...compiledIcons.compositions[mapName] ? { iconComposition: compiledIcons.compositions[mapName] } : {}
+            },
+            styles: family.styles
+          }
+        },
+        { provenance }
+      );
+      return prepareTileflowHostedNativeDeployment({
+        mapId: mapName,
+        buildManifest,
+        styles: family.styles,
+        teamSources: family.teamSources,
+        assets,
+        ...resolved.view ? { view: resolved.view } : {}
+      });
+    };
+    const artifact = await createArtifact(sprite);
+    return {
+      mapName,
+      artifact,
+      packages: compiledIcons.packages,
+      ...binding ? { iconBinding: binding } : {},
+      ...compiledIcons.compositions[mapName] ? { iconComposition: compiledIcons.compositions[mapName] } : {},
+      async retarget(sprites) {
+        return binding ? createArtifact(sprites.get(binding.packageHash)) : artifact;
+      },
+      dispose: local.dispose
+    };
+  } catch (error) {
+    await local.dispose();
+    throw error;
+  }
+}
+async function runHostedNativeDeploy(options, ports) {
+  const { apiOrigin, mapId } = requireNativeTarget(options);
+  const prepared = await (ports.prepare ?? prepareNativeHostedDeploy)({
+    ...options,
+    apiUrl: apiOrigin
+  });
+  try {
+    const preflight = await parseTileflowRendererDeploymentArtifact(prepared.artifact);
+    if (preflight.mapId !== prepared.mapName)
+      throw failure("The prepared map does not match its artifact.");
+    const existing = await ports.loadManifest(options.manifest, {
+      overwriteSelfHosted: options.overwriteSelfHostedManifest === true
+    });
+    const previousOrigin = existing?.apiUrl ?? (existing ? Object.values(existing.maps)[0]?.apiUrl : void 0);
+    if (previousOrigin !== void 0 && normalizeApiOrigin(previousOrigin) !== apiOrigin)
+      throw failure("Existing manifest belongs to a different Tileflow API origin.");
+    const api = await ports.resolveApi(prepared.mapName);
+    if (!api) return null;
+    if (api.apiUrl !== apiOrigin || api.mapId !== mapId || !api.apiKey || api.apiKey.length > 8192 || /[\p{Cc}]/u.test(api.apiKey))
+      throw failure("Authorization did not confirm the requested API and Map.");
+    const sprites = /* @__PURE__ */ new Map();
+    for (const icon of prepared.packages) {
+      if (sprites.has(icon.contentHash)) continue;
+      let uploaded;
+      try {
+        uploaded = await (ports.uploadIcon ?? uploadHostedIconPackage)(api, icon, ports.request);
+      } catch {
+        throw failure("Native deployment icon upload failed. The local manifest was preserved.");
+      }
+      if (!uploaded.ok)
+        throw failure("Native deployment icon upload failed. Retry the same artifact.");
+      const expected = `${apiOrigin}/sprites/${uploaded.value.id}/sprite`;
+      if (uploaded.value.contentHash !== icon.contentHash || uploaded.value.spriteUrl !== expected)
+        throw failure("Icon publication did not confirm the owned resource and origin.");
+      sprites.set(icon.contentHash, expected);
+    }
+    const artifact = await parseTileflowRendererDeploymentArtifact(
+      await prepared.retarget(sprites)
+    );
+    if (artifact.mapId !== preflight.mapId || artifact.renderers.web.buildManifest.maps[artifact.mapId].mapRevisionSha256 !== preflight.renderers.web.buildManifest.maps[preflight.mapId].mapRevisionSha256)
+      throw failure("Authored map identity changed after preflight.");
+    const iconPackage = prepared.iconBinding ? prepared.packages.find((entry) => entry.contentHash === prepared.iconBinding.packageHash) : void 0;
+    if (prepared.iconComposition && prepared.iconComposition.packageHash !== iconPackage?.contentHash)
+      throw failure("Icon composition does not match the confirmed effective package.");
+    let response;
+    try {
+      response = await requestHostedJson(
+        apiOrigin,
+        "/v1/styles",
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${api.apiKey}`,
+            "X-Tileflow-Map-Id": mapId,
+            "Content-Type": "application/json"
+          },
+          body: serializeCanonicalJson({
+            artifact,
+            environment: prepared.mapName,
+            managedMapId: mapId,
+            usageMode: "session",
+            source: ports.source,
+            ...iconPackage && prepared.iconBinding ? {
+              iconPackage: {
+                contentHash: iconPackage.contentHash,
+                label: prepared.iconBinding.label
+              }
+            } : {},
+            ...prepared.iconComposition ? { iconComposition: prepared.iconComposition } : {}
+          })
+        },
+        ports.request
+      );
+    } catch {
+      throw failure(
+        "Renderer deployment response was unavailable. Retry the same artifact; the local manifest was preserved."
+      );
+    }
+    if (!response.ok || !response.json)
+      throw failure("Renderer deployment failed. The local manifest was preserved.");
+    const parsed = tileflowRendererDeploymentResponseSchema.safeParse(response.body);
+    if (!parsed.success)
+      throw failure("Invalid renderer deployment response. The local manifest was preserved.");
+    const result = parsed.data;
+    const names = Object.keys(artifact.renderers.web.styles).sort();
+    const expectedManifestUrl = `${apiOrigin}/maps/${mapId}/native/manifest.json`;
+    if (result.mapId !== mapId || result.renderers.native.manifestUrl !== expectedManifestUrl || names.join("\0") !== Object.keys(result.renderers.web.themes).sort().join("\0") || names.join("\0") !== Object.keys(result.renderers.native.themes).sort().join("\0"))
+      throw failure(
+        "Renderer deployment did not confirm the requested Map and complete theme families."
+      );
+    for (const name of names) {
+      if (result.renderers.web.themes[name].styleUrl !== `${apiOrigin}/maps/${mapId}/${name}.json` || result.renderers.native.themes[name].styleUrl !== `${apiOrigin}/maps/${mapId}/native/v${result.version}/${name}.json`)
+        throw failure("Renderer deployment returned an unexpected delivery route.");
+    }
+    const build = artifact.renderers.web.buildManifest.maps[artifact.mapId];
+    const manifest = parseTileflowRuntimeManifest({
+      apiUrl: apiOrigin,
+      version: 1,
+      maps: {
+        ...existing?.maps ?? {},
+        [prepared.mapName]: {
+          defaultTheme: build.defaultTheme,
+          environment: prepared.mapName,
+          mapId,
+          ...build.systemThemes ? { systemThemes: build.systemThemes } : {},
+          ...artifact.view ? { view: artifact.view } : {},
+          usageMode: "session",
+          worldGeneration: "v1",
+          themes: Object.fromEntries(
+            names.map((name) => [
+              name,
+              {
+                colorScheme: build.themes[name].colorScheme,
+                fontFaces: getTileflowStyleFontFaces(
+                  artifact.renderers.web.styles[name]
+                ),
+                revision: build.themes[name].styleSha256,
+                ...result.renderers.web.themes[name]
+              }
+            ])
+          )
+        }
+      }
+    });
+    const manifestPath = await ports.writeManifest(options.manifest, manifest);
+    return Object.freeze({
+      manifestPath,
+      mapName: prepared.mapName,
+      mapId,
+      deploymentId: result.deploymentId,
+      version: result.version,
+      changed: result.changed,
+      nativeManifestUrl: expectedManifestUrl
+    });
+  } finally {
+    await prepared.dispose();
+  }
+}
+
 // src/icon-diff-command.ts
-import { dirname as dirname6, resolve as resolve4 } from "path";
-import { z as z4 } from "zod";
+import { dirname as dirname7, resolve as resolve4 } from "path";
+import { z as z3 } from "zod";
 import {
   diffTileflowIconPackageManifests,
   hashTileflowIconPackageManifest,
   tileflowIconPackageContentHashSchema,
   tileflowIconPackageLabelSchema,
-  tileflowIconPackageLimits as tileflowIconPackageLimits3,
+  tileflowIconPackageLimits as tileflowIconPackageLimits2,
   tileflowIconPackageManifestSchema,
   tileflowMapIdSchema
 } from "@tileflow/core";
 import {
-  assertValidTileflowConfig,
-  getTileflowMapNames,
-  loadTileflowConfigWithInputs as loadTileflowConfigWithInputs2
+  assertValidTileflowConfig as assertValidTileflowConfig2,
+  getTileflowMapNames as getTileflowMapNames2,
+  loadTileflowConfigWithInputs as loadTileflowConfigWithInputs3
 } from "@tileflow/dev/config";
-import { compileTileflowIconPackages } from "@tileflow/dev/icons";
+import {
+  compileTileflowIconPackages as compileTileflowIconPackages2
+} 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 dirname5, join } from "path";
-import { z as z3 } from "zod";
+import { basename as basename2, dirname as dirname6, join } from "path";
 import {
   compareCodeUnits as compareCodeUnits5,
   sha256Hex,
-  tileflowIconIdSchema,
-  tileflowIconPackageLimits as tileflowIconPackageLimits2
+  tileflowIconSpriteIndexSchema
 } from "@tileflow/core";
-var spriteEntrySchema = z3.object({
-  height: z3.number().int().positive().max(tileflowIconPackageLimits2.maxAtlasDimension),
-  pixelRatio: z3.union([z3.literal(1), z3.literal(2)]),
-  width: z3.number().int().positive().max(tileflowIconPackageLimits2.maxAtlasDimension),
-  x: z3.number().int().nonnegative().max(tileflowIconPackageLimits2.maxAtlasDimension),
-  y: z3.number().int().nonnegative().max(tileflowIconPackageLimits2.maxAtlasDimension)
-}).strict();
-var spriteIndexSchema = z3.record(tileflowIconIdSchema, spriteEntrySchema);
+import {
+  renderTileflowIconAtlasPreview
+} from "@tileflow/dev/icons";
 async function writeIconDiffReport(input) {
   const [before, after] = await Promise.all([
     input.baseline?.package ? loadRemoteSprite(input.baseline.package) : null,
@@ -2940,18 +3242,20 @@ function loadCompiledSprite(iconPackage) {
     iconPackage.manifest.sprites.twoX
   );
 }
-function reportSpriteFromFiles(files, oneX, twoX) {
+async function reportSpriteFromFiles(files, oneX, twoX) {
   const oneXJson = requiredFile(files, "sprite.json");
   const oneXPng = requiredFile(files, "sprite.png");
   const twoXJson = requiredFile(files, "sprite@2x.json");
   const twoXPng = requiredFile(files, "sprite@2x.png");
+  const indexOneX = parseIndex(oneXJson, 1, oneX.width, oneX.height);
+  const indexTwoX = parseIndex(twoXJson, 2, twoX.width, twoX.height);
   return {
-    indexOneX: parseIndex(oneXJson, 1, oneX.width, oneX.height),
-    indexTwoX: parseIndex(twoXJson, 2, twoX.width, twoX.height),
-    oneXDataUrl: pngDataUrl(oneXPng),
+    indexOneX,
+    indexTwoX,
+    oneXDataUrl: pngDataUrl(await renderTileflowIconAtlasPreview(oneXPng, indexOneX)),
     oneXHeight: oneX.height,
     oneXWidth: oneX.width,
-    twoXDataUrl: pngDataUrl(twoXPng),
+    twoXDataUrl: pngDataUrl(await renderTileflowIconAtlasPreview(twoXPng, indexTwoX)),
     twoXHeight: twoX.height,
     twoXWidth: twoX.width
   };
@@ -2963,7 +3267,7 @@ function parseIndex(source, pixelRatio, atlasWidth, atlasHeight) {
   } catch {
     throw new Error("Sprite report index is not valid UTF-8 JSON");
   }
-  const parsed = spriteIndexSchema.safeParse(value);
+  const parsed = tileflowIconSpriteIndexSchema.safeParse(value);
   if (!parsed.success) {
     throw new Error("Sprite report index does not match the MapLibre schema");
   }
@@ -3358,9 +3662,9 @@ async function writeAtomicReport(path, html, force) {
   } catch (error) {
     if (!isMissingFile3(error)) throw error;
   }
-  await mkdir3(dirname5(path), { recursive: true });
+  await mkdir3(dirname6(path), { recursive: true });
   const temporaryPath = join(
-    dirname5(path),
+    dirname6(path),
     `.${basename2(path)}.${process.pid}.${randomUUID2()}.tmp`
   );
   try {
@@ -3389,59 +3693,59 @@ function isMissingFile3(error) {
 
 // src/icon-diff-command.ts
 var environmentSchema = tileflowMapIdSchema;
-var publicHttpUrlSchema2 = z4.url().max(2048).refine((value) => {
+var publicHttpUrlSchema2 = z3.url().max(2048).refine((value) => {
   const url = new URL(value);
   return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password;
 });
-var iconPackageBaselineResponseSchema = z4.object({
-  baseline: z4.object({
-    deployedAt: z4.iso.datetime({ offset: true }),
-    deploymentId: z4.string().min(1).max(128),
-    package: z4.object({
+var iconPackageBaselineResponseSchema = z3.object({
+  baseline: z3.object({
+    deployedAt: z3.iso.datetime({ offset: true }),
+    deploymentId: z3.string().min(1).max(128),
+    package: z3.object({
       contentHash: tileflowIconPackageContentHashSchema,
       label: tileflowIconPackageLabelSchema,
       manifest: tileflowIconPackageManifestSchema,
       spriteUrl: publicHttpUrlSchema2,
-      totalBytes: z4.number().int().positive().max(tileflowIconPackageLimits3.maxGeneratedPackageBytes)
+      totalBytes: z3.number().int().positive().max(tileflowIconPackageLimits2.maxGeneratedPackageBytes)
     }).strict().nullable(),
-    version: z4.number().int().positive()
+    version: z3.number().int().positive()
   }).strict().nullable(),
   environment: environmentSchema,
-  schemaVersion: z4.literal(1)
+  schemaVersion: z3.literal(1)
 }).strict();
-var packageSummarySchema = z4.object({
+var packageSummarySchema = z3.object({
   contentHash: tileflowIconPackageContentHashSchema,
-  iconCount: z4.number().int().nonnegative().max(tileflowIconPackageLimits3.maxIconCount),
+  iconCount: z3.number().int().nonnegative().max(tileflowIconPackageLimits2.maxIconCount),
   label: tileflowIconPackageLabelSchema,
-  totalBytes: z4.number().int().nonnegative().max(tileflowIconPackageLimits3.maxGeneratedPackageBytes)
+  totalBytes: z3.number().int().nonnegative().max(tileflowIconPackageLimits2.maxGeneratedPackageBytes)
 }).strict();
-var tileflowIconDiffDocumentSchema = z4.object({
-  schemaVersion: z4.literal(1),
+var tileflowIconDiffDocumentSchema = z3.object({
+  schemaVersion: z3.literal(1),
   environment: environmentSchema,
-  baseline: z4.object({
-    deploymentId: z4.string(),
+  baseline: z3.object({
+    deploymentId: z3.string(),
     package: packageSummarySchema.nullable(),
-    version: z4.number().int().positive()
+    version: z3.number().int().positive()
   }).strict().nullable(),
-  proposed: z4.object({
+  proposed: z3.object({
     package: packageSummarySchema.nullable()
   }).strict(),
-  icons: z4.object({
-    added: z4.array(z4.string()),
-    removed: z4.array(z4.string()),
-    modified: z4.array(z4.string()),
-    unchangedCount: z4.number().int().nonnegative()
+  icons: z3.object({
+    added: z3.array(z3.string()),
+    removed: z3.array(z3.string()),
+    modified: z3.array(z3.string()),
+    unchangedCount: z3.number().int().nonnegative()
   }).strict(),
-  generatedBytes: z4.object({
-    before: z4.number().int().nonnegative(),
-    after: z4.number().int().nonnegative(),
-    delta: z4.number().int()
+  generatedBytes: z3.object({
+    before: z3.number().int().nonnegative(),
+    after: z3.number().int().nonnegative(),
+    delta: z3.number().int()
   }).strict(),
-  artifacts: z4.object({ report: z4.string().nullable() }).strict(),
-  hasChanges: z4.boolean()
+  artifacts: z3.object({ report: z3.string().nullable() }).strict(),
+  hasChanges: z3.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).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) => {
+  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("--cache-dir <path>", "verified Icon Set artifact cache root").option("--offline", "fail a locked Icon Set cache miss instead of hydrating it").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) {
@@ -3462,11 +3766,11 @@ async function runIconDiff(options, dependencies) {
   }
   const environment = environmentSchema.parse(options.against);
   const loaded = await withTileflowConfigSecretsHidden(
-    () => loadTileflowConfigWithInputs2(options.config)
+    () => loadTileflowConfigWithInputs3(options.config)
   );
   const project = loaded.project;
-  assertValidTileflowConfig(project);
-  const mapNames = getTileflowMapNames(project);
+  assertValidTileflowConfig2(project);
+  const mapNames = getTileflowMapNames2(project);
   if (!Object.hasOwn(project.maps, environment)) {
     throw new Error(
       `Unknown map environment "${environment}". Available maps: ${mapNames.join(", ") || "(none)"}`
@@ -3477,9 +3781,14 @@ async function runIconDiff(options, dependencies) {
     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: dirname6(loaded.configFile),
+  const icons = {
+    ...options.cacheDir ? { cacheRoot: options.cacheDir } : {},
+    ...options.offline ? { offline: true } : {}
+  };
+  const compiled = await compileTileflowIconPackages2(selectedProject, {
+    baseDirectory: dirname7(loaded.configFile),
     cwd: process.cwd(),
+    ...Object.keys(icons).length > 0 ? { icons } : {},
     target: "hosted"
   });
   const binding = compiled.bindings.find((candidate) => candidate.mapName === environment);
@@ -3621,10 +3930,10 @@ function formatSignedBytes(bytes) {
 }
 
 // src/icon-list-command.ts
-import { dirname as dirname7 } from "path";
+import { dirname as dirname8 } from "path";
 import { compareCodeUnits as compareCodeUnits6 } from "@tileflow/core";
 import {
-  getTileflowMapNames as getTileflowMapNames2,
+  getTileflowMapNames as getTileflowMapNames3,
   loadValidTileflowConfigWithInputs as loadValidTileflowConfigWithInputs2,
   TileflowValidationError as TileflowValidationError3
 } from "@tileflow/dev/config";
@@ -3633,7 +3942,7 @@ import {
   TileflowIconCompilationError as TileflowIconCompilationError2
 } from "@tileflow/dev/icons";
 function registerIconListCommand(icons, dependencies) {
-  icons.command("list").description("List each map icon directory composition as deterministic agent JSON").option("-c, --config <path>", "config path", dependencies.defaultConfigPath).option("--map <id>", "inspect one exact configured map").option("--json", "print deterministic schema-version-2 JSON").action(async (options) => {
+  icons.command("list").description("List each map icon directory composition as deterministic agent JSON").option("-c, --config <path>", "config path", dependencies.defaultConfigPath).option("--map <id>", "inspect one exact configured map").option("--cache-dir <path>", "verified Icon Set artifact cache root").option("--offline", "fail a locked Icon Set cache miss instead of hydrating it").option("--json", "print deterministic schema-version-3 JSON").action(async (options) => {
     if (!options.json) {
       console.error(
         "tileflow icons list currently requires --json. Run tileflow icons list --json."
@@ -3651,7 +3960,7 @@ function registerIconListCommand(icons, dependencies) {
 }
 function createTileflowIconListJson(inspection) {
   return {
-    schemaVersion: 2,
+    schemaVersion: 3,
     pathBase: "cwd",
     maps: [...inspection.maps].sort((left, right) => compareCodeUnits6(left.name, right.name)).map((map) => createMapJson(map, inspection.catalogs))
   };
@@ -3665,15 +3974,20 @@ async function runIconList(options) {
     () => loadValidTileflowConfigWithInputs2(options.config)
   );
   const project = loaded.project;
-  const mapIds = getTileflowMapNames2(project).sort(compareCodeUnits6);
+  const mapIds = getTileflowMapNames3(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 icons = {
+    ...options.cacheDir ? { cacheRoot: options.cacheDir } : {},
+    ...options.offline ? { offline: true } : {}
+  };
   const inspection = await inspectTileflowIconCatalogs(project, {
-    baseDirectory: dirname7(loaded.configFile),
+    baseDirectory: dirname8(loaded.configFile),
     cwd: process.cwd(),
+    ...Object.keys(icons).length > 0 ? { icons } : {},
     ...options.map ? { mapNames: [options.map] } : {}
   });
   process.stdout.write(serializeTileflowIconListJson(createTileflowIconListJson(inspection)));
@@ -3684,7 +3998,7 @@ function createMapJson(map, catalogs) {
   }
   const mapIcons = map.icons;
   const catalog = catalogs.find(
-    (candidate) => candidate.compiledPackage.contentHash === mapIcons.packageHash && sameStrings(candidate.directories, mapIcons.directories)
+    (candidate) => candidate.compiledPackage.contentHash === mapIcons.packageHash && sameContributors(candidate.contributors, mapIcons.contributors)
   );
   if (!catalog) {
     throw new Error(`Missing inspected icon catalog for map ${map.name}`);
@@ -3692,9 +4006,21 @@ function createMapJson(map, catalogs) {
   return {
     id: map.name,
     icons: {
-      kind: "directories",
-      directories: [...mapIcons.directories],
+      kind: "sources",
+      contributors: mapIcons.contributors.map(createContributorJson),
       finalIds: [...mapIcons.iconIds],
+      ...catalog.icons.some((icon) => icon.appearance) ? {
+        appearances: Object.fromEntries(
+          catalog.icons.flatMap(
+            (icon) => icon.appearance ? [[icon.id, icon.appearance]] : []
+          )
+        )
+      } : {},
+      ...catalog.icons.some((icon) => icon.layout) ? {
+        layouts: Object.fromEntries(
+          catalog.icons.flatMap((icon) => icon.layout ? [[icon.id, icon.layout]] : [])
+        )
+      } : {},
       insideWorkingTree: catalog.insideWorkingTree,
       replacements: catalog.replacements.map((replacement) => ({
         id: replacement.id,
@@ -3702,18 +4028,43 @@ function createMapJson(map, catalogs) {
         winner: replacement.winner
       })),
       packageHash: mapIcons.packageHash,
-      sources: [...catalog.icons].sort((left, right) => compareCodeUnits6(left.id, right.id)).map((icon) => ({
-        id: icon.id,
-        path: icon.source.path,
-        format: icon.source.format,
-        byteLength: icon.source.byteLength,
-        dimensions: icon.source.dimensions ? { width: icon.source.dimensions.width, height: icon.source.dimensions.height } : null
-      }))
+      composition: mapIcons.composition,
+      sources: [...catalog.icons].sort((left, right) => compareCodeUnits6(left.id, right.id)).map(
+        (icon) => icon.source.kind === "icon-set" ? {
+          kind: "icon-set",
+          id: icon.id,
+          contributor: icon.source.contributor,
+          reference: icon.source.reference,
+          version: icon.source.version
+        } : {
+          kind: "file",
+          id: icon.id,
+          contributor: icon.source.contributor,
+          path: icon.source.path,
+          format: icon.source.format,
+          byteLength: icon.source.byteLength,
+          dimensions: icon.source.dimensions ? { width: icon.source.dimensions.width, height: icon.source.dimensions.height } : null
+        }
+      )
     }
   };
 }
-function sameStrings(left, right) {
-  return left.length === right.length && left.every((value, index) => value === right[index]);
+function createContributorJson(contributor) {
+  return contributor.kind === "icon-set" ? {
+    kind: "icon-set",
+    label: contributor.label,
+    iconIds: [...contributor.iconIds],
+    reference: contributor.reference,
+    version: contributor.version
+  } : {
+    kind: contributor.kind,
+    label: contributor.label,
+    iconIds: [...contributor.iconIds],
+    insideWorkingTree: contributor.insideWorkingTree
+  };
+}
+function sameContributors(left, right) {
+  return left.length === right.length && left.every((contributor, index) => contributor.label === right[index]?.label);
 }
 function printIconListError(error) {
   if (error instanceof TileflowValidationError3) {
@@ -3732,116 +4083,1066 @@ function printIssues(heading, issues) {
   );
 }
 
-// src/language-command.ts
-import { readFile as readFile4 } from "fs/promises";
-import { fileURLToPath } from "url";
+// src/icon-lock-command.ts
+import { dirname as dirname9 } from "path";
+import pc3 from "picocolors";
 import {
-  serializeCanonicalJson,
-  tileflowAuthoringManifest
+  collectTileflowIconSetReferences,
+  compareCodeUnits as compareCodeUnits7,
+  parseResolvedTileflowMap as parseResolvedTileflowMap3,
+  parseTileflowIconsLockfile,
+  tileflowIconSetReferenceSchema as tileflowIconSetReferenceSchema2,
+  tileflowIconsLockfileName
 } 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) {
+  getTileflowMapNames as getTileflowMapNames4,
+  loadValidTileflowConfigWithInputs as loadValidTileflowConfigWithInputs3,
+  TileflowValidationError as TileflowValidationError4
+} from "@tileflow/dev/config";
+import { readTileflowIconsLockfileText, writeTileflowIconsLockfile } from "@tileflow/dev/icons";
+
+// src/hosted-team.ts
+import pc from "picocolors";
+import { serializeCanonicalJson as serializeCanonicalJson2 } from "@tileflow/core";
+async function resolveTeamAuthority(options, scopes, dependencies) {
+  let apiOrigin;
   try {
-    await operation();
+    apiOrigin = normalizeApiOrigin(options.apiUrl ?? dependencies.defaultApiUrl);
   } 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;
+    emitFailure(options.json, "invalid_api_url", safeMessage(error));
+    return null;
   }
-  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;
+  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 };
   }
-  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";
-function openTileflowExternal(target, dependencies = {}) {
-  const invocation = resolveTileflowExternalOpenInvocation(
-    target,
-    dependencies.platform ?? hostPlatform()
-  );
-  const spawn2 = dependencies.spawn ?? spawnChild;
-  let child;
+  let config;
   try {
-    child = spawn2(invocation.command, invocation.args, {
-      detached: true,
-      shell: false,
-      stdio: "ignore",
-      windowsHide: true
-    });
+    config = await dependencies.loadAuthConfig();
   } catch (error) {
-    dependencies.onError?.(error);
-    return;
+    emitFailure(options.json, "auth_state_unavailable", safeMessage(error));
+    return null;
   }
-  child.once("error", (error) => dependencies.onError?.(error));
-  child.unref();
-}
-function resolveTileflowExternalOpenInvocation(target, platform) {
-  if (!target || target.includes("\0")) throw new Error("The external target is invalid.");
-  if (platform === "darwin") return { command: "open", args: [target] };
-  if (platform === "win32") return { command: "explorer.exe", args: [target] };
+  const selected = resolveAccountSession(config, options.apiUrl ?? dependencies.defaultApiUrl);
+  if (selected.kind !== "selected") {
+    emitFailure(
+      options.json,
+      `account_session_${selected.kind}`,
+      selected.kind === "expired" ? "Account session expired. Run tileflow login." : "Run tileflow login."
+    );
+    return null;
+  }
+  const discovered = await listAccountTeams(selected.session);
+  if (!discovered.ok) {
+    emitFailure(options.json, "team_discovery_failed", discovered.error);
+    return null;
+  }
+  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;
+  }
+  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;
+  }
+  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 authorizedTeamRequest(authority, path, method, init = {}) {
+  return requestHostedJson(authority.apiOrigin, path, {
+    ...init.body === void 0 ? {} : { body: init.body },
+    headers: { Authorization: `Bearer ${authority.credential}`, ...init.headers },
+    method
+  });
+}
+function emitJson(value) {
+  process.stdout.write(`${serializeCanonicalJson2(value)}
+`);
+}
+function emitFailure(json, code, message, context = {}) {
+  if (json) {
+    process.stderr.write(
+      `${serializeCanonicalJson2({ error: { code, ...context, message }, ok: false, schemaVersion: 1 })}
+`
+    );
+  } else {
+    console.error(`${pc.red("Error:")} ${message}`);
+  }
+  process.exitCode = 1;
+}
+function safeMessage(error) {
+  return error instanceof Error ? error.message : "Team command failed.";
+}
+
+// src/icon-set-command.ts
+import { isAbsolute as isAbsolute2 } from "path";
+import pc2 from "picocolors";
+import { z as z4 } from "zod";
+import {
+  tileflowIconPackageLimits as tileflowIconPackageLimits3,
+  tileflowIconSetPackageIdSchema,
+  tileflowIconSetPinSchema,
+  tileflowIconSetReferenceSchema
+} from "@tileflow/core";
+import { composeTileflowIconSources } from "@tileflow/dev/icons";
+var maximumCatalogPages = 100;
+var pageSize = 100;
+function registerIconSetCommands(program2, dependencies) {
+  const iconSet = program2.command("icon-set").description("Publish and manage versioned Team Icon Sets");
+  withTeamOptions(
+    iconSet.command("publish").description("Compile one local directory and publish it as an immutable Team revision").argument("<directory>", "repository-local icon directory").requiredOption("--id <id>", "Team-local Icon Set slug").requiredOption("--idempotency-key <key>", "durable retry key for this exact publication").option("--name <name>", "display name").option("--description <text>", "display description")
+  ).action(
+    async (directory, options) => {
+      try {
+        if (!isIconSetSlug(options.id)) {
+          return emitFailure(options.json, "invalid_icon_set_id", "Icon Set ID is invalid.");
+        }
+        if (!isIdempotencyKey(options.idempotencyKey)) {
+          return emitFailure(
+            options.json,
+            "invalid_idempotency_key",
+            "Idempotency key must be 8 to 128 characters from A-Z a-z 0-9 . _ : -"
+          );
+        }
+        const source = normalizeLocalDirectory(directory);
+        if (!source) {
+          return emitFailure(
+            options.json,
+            "invalid_icon_directory",
+            "Publish one repository-relative icon directory."
+          );
+        }
+        let iconPackage;
+        try {
+          const composed = await composeTileflowIconSources([source], {
+            cwd: process.cwd(),
+            target: "hosted"
+          });
+          if (!composed.package) throw new Error("The selected directory has no icons.");
+          iconPackage = composed.package;
+        } catch (error) {
+          return emitFailure(options.json, "icon_compilation_failed", safeMessage(error));
+        }
+        const authority = await resolveTeamAuthority(options, ["icons:write"], dependencies);
+        if (!authority) return;
+        const body = new FormData();
+        for (const file of iconPackage.files) {
+          const bytes = new Uint8Array(file.source.byteLength);
+          bytes.set(file.source);
+          body.append(
+            file.fileName,
+            new Blob([bytes.buffer], { type: file.contentType }),
+            file.fileName
+          );
+        }
+        const response = await authorizedTeamRequest(
+          authority,
+          `/v1/icon-sets/${encodeURIComponent(options.id)}/versions/${encodeURIComponent(iconPackage.contentHash)}`,
+          "PUT",
+          { body, headers: { "Idempotency-Key": options.idempotencyKey } }
+        );
+        if (!response.ok) return emitHttpFailure(options.json, response.status, "publish");
+        const parsed = publishResponseSchema.parse(response.body);
+        if (parsed.revision.pin && parsed.revision.pin.contentHash !== iconPackage.contentHash) {
+          return emitFailure(
+            options.json,
+            "icon_set_publish_unconfirmed",
+            "Publication response did not confirm the submitted generated artifact."
+          );
+        }
+        const metadata = {
+          ...options.description === void 0 ? {} : { description: options.description },
+          ...options.name === void 0 ? {} : { name: options.name }
+        };
+        if (Object.keys(metadata).length > 0) {
+          try {
+            const metadataResponse = await authorizedTeamRequest(
+              authority,
+              `/v1/icon-sets/${encodeURIComponent(options.id)}`,
+              "PATCH",
+              {
+                body: JSON.stringify(metadata),
+                headers: { "Content-Type": "application/json" }
+              }
+            );
+            if (!metadataResponse.ok || !catalogDetailResponseSchema.safeParse(metadataResponse.body).success) {
+              return emitFailure(
+                options.json,
+                "icon_set_metadata_update_failed",
+                "Icon Set publication succeeded, but display metadata could not be updated; rerun the same command."
+              );
+            }
+          } catch {
+            return emitFailure(
+              options.json,
+              "icon_set_metadata_update_failed",
+              "Icon Set publication succeeded, but display metadata could not be updated; rerun the same command."
+            );
+          }
+        }
+        const totalBytes = iconPackage.manifest.files.reduce(
+          (total, file) => total + file.byteLength,
+          0
+        );
+        const document = {
+          command: "icon-set publish",
+          iconSet: {
+            contentHash: iconPackage.contentHash,
+            iconCount: iconPackage.manifest.iconNames.length,
+            logicalId: options.id,
+            packageId: parsed.revision.pin?.packageId ?? null,
+            reference: parsed.revision.reference,
+            totalBytes,
+            version: parsed.revision.version,
+            versionId: parsed.revision.id
+          },
+          publication: parsed.changed ? "changed" : "unchanged",
+          schemaVersion: 1,
+          team: describeTeam(authority)
+        };
+        if (options.json) return emitJson(document);
+        console.log(
+          `${pc2.green("\u2713")} ${parsed.changed ? "Published" : "Unchanged"} ${pc2.bold(parsed.revision.reference)} revision ${parsed.revision.version}.`
+        );
+      } catch (error) {
+        emitFailure(options.json, "icon_set_publish_failed", boundedMessage(error, "publish"));
+      }
+    }
+  );
+  withTeamOptions(
+    iconSet.command("list").description("List Icon Sets owned by one Team").option("--archived", "list archived Icon Sets instead of active ones")
+  ).action(async (options) => {
+    try {
+      const authority = await resolveTeamAuthority(options, ["icons:read"], dependencies);
+      if (!authority) return;
+      const sets = await readAllPages(
+        authority,
+        "/v1/icon-sets",
+        options.archived ? { archived: "true" } : {},
+        catalogListResponseSchema,
+        (page) => page.sets,
+        (set) => set.id
+      );
+      const document = {
+        command: "icon-set list",
+        schemaVersion: 1,
+        sets,
+        team: describeTeam(authority)
+      };
+      if (options.json) return emitJson(document);
+      if (sets.length === 0) return console.log(pc2.gray("No Team Icon Sets."));
+      for (const set of sets) {
+        console.log(
+          `  ${pc2.bold(set.reference)} ${pc2.gray(set.archivedAt ? "archived" : `v${String(set.latestVersion ?? 0)}`)}`
+        );
+      }
+    } catch (error) {
+      emitFailure(options.json, "icon_set_list_failed", boundedMessage(error, "list"));
+    }
+  });
+  withTeamOptions(
+    iconSet.command("status").description("Show one Team Icon Set").argument("<slug>", "Team-local Icon Set slug")
+  ).action(async (slug, options) => {
+    await readCommand(slug, options, "icon-set status", async (authority) => {
+      const response = await authorizedTeamRequest(
+        authority,
+        `/v1/icon-sets/${encodeURIComponent(slug)}`,
+        "GET"
+      );
+      if (!response.ok) return { status: response.status };
+      const parsed = catalogDetailResponseSchema.parse(response.body);
+      return { value: { set: parsed.set } };
+    });
+  });
+  withTeamOptions(
+    iconSet.command("versions").description("List the retained revisions of one Team Icon Set").argument("<slug>", "Team-local Icon Set slug")
+  ).action(async (slug, options) => {
+    await readCommand(slug, options, "icon-set versions", async (authority) => {
+      const versions = await readAllPages(
+        authority,
+        `/v1/icon-sets/${encodeURIComponent(slug)}/versions`,
+        {},
+        versionsResponseSchema,
+        (page) => page.versions,
+        (revision) => revision.id
+      );
+      return { value: { versions: versions.map(describeRevision) } };
+    });
+  });
+  withTeamOptions(
+    iconSet.command("uses").description("List the known hosted deployments that retain one Team Icon Set").argument("<slug>", "Team-local Icon Set slug")
+  ).action(async (slug, options) => {
+    await readCommand(slug, options, "icon-set uses", async (authority) => {
+      const uses = await readAllPages(
+        authority,
+        `/v1/icon-sets/${encodeURIComponent(slug)}/uses`,
+        {},
+        usesResponseSchema,
+        (page) => page.uses,
+        (use) => `${use.deploymentId}\0${use.versionId}\0${String(use.ordinal)}`
+      );
+      return {
+        value: {
+          // Repository locks that were never deployed are unknowable to the catalog.
+          coverage: "known-hosted-deployments",
+          includesUndeployedRepositoryLocks: false,
+          uses
+        }
+      };
+    });
+  });
+  for (const [name, archived] of [
+    ["archive", true],
+    ["unarchive", false]
+  ]) {
+    withTeamOptions(
+      iconSet.command(name).description(
+        archived ? "Archive one Team Icon Set without removing its retained revisions" : "Return one archived Team Icon Set to the active catalog"
+      ).argument("<slug>", "Team-local Icon Set slug")
+    ).action(async (slug, options) => {
+      try {
+        if (!isIconSetSlug(slug)) {
+          return emitFailure(options.json, "invalid_icon_set_id", "Icon Set ID is invalid.");
+        }
+        const authority = await resolveTeamAuthority(options, ["icons:write"], dependencies);
+        if (!authority) return;
+        const response = await authorizedTeamRequest(
+          authority,
+          `/v1/icon-sets/${encodeURIComponent(slug)}`,
+          "PATCH",
+          {
+            body: JSON.stringify({ archived }),
+            headers: { "Content-Type": "application/json" }
+          }
+        );
+        if (!response.ok) return emitHttpFailure(options.json, response.status, name);
+        const parsed = catalogDetailResponseSchema.parse(response.body);
+        const document = {
+          command: `icon-set ${name}`,
+          schemaVersion: 1,
+          set: parsed.set,
+          team: describeTeam(authority)
+        };
+        if (options.json) return emitJson(document);
+        console.log(
+          `${pc2.green("\u2713")} ${archived ? "Archived" : "Restored"} ${pc2.bold(parsed.set.reference)}.`
+        );
+      } catch (error) {
+        emitFailure(options.json, `icon_set_${name}_failed`, boundedMessage(error, name));
+      }
+    });
+  }
+  withTeamOptions(
+    iconSet.command("purge").description("Permanently purge one exact Team Icon Set revision").argument("<slug>", "Team-local Icon Set slug").requiredOption("--version <version>", "exact positive revision to purge").requiredOption("--idempotency-key <key>", "durable retry key for this exact purge").requiredOption("--confirm <reference>", "repeat the exact @team/set@version being purged").option(
+      "--acknowledge-unknown-locks",
+      "acknowledge that undeployed repository locks are not discoverable"
+    )
+  ).action(
+    async (slug, options) => {
+      try {
+        if (!isIconSetSlug(slug)) {
+          return emitFailure(options.json, "invalid_icon_set_id", "Icon Set ID is invalid.");
+        }
+        if (!/^[1-9][0-9]*$/u.test(options.version) || !Number.isSafeInteger(+options.version)) {
+          return emitFailure(
+            options.json,
+            "invalid_icon_set_version",
+            "Purge requires one exact positive revision."
+          );
+        }
+        if (!isIdempotencyKey(options.idempotencyKey)) {
+          return emitFailure(
+            options.json,
+            "invalid_idempotency_key",
+            "Idempotency key must be 8 to 128 characters from A-Z a-z 0-9 . _ : -"
+          );
+        }
+        const confirmation = parsePurgeConfirmation(options.confirm);
+        if (!confirmation || confirmation.slug !== slug || confirmation.version !== Number(options.version)) {
+          return emitFailure(
+            options.json,
+            "purge_confirmation_mismatch",
+            "Purge confirmation must repeat the exact @team/set@version being purged."
+          );
+        }
+        if (options.acknowledgeUnknownLocks !== true) {
+          return emitFailure(
+            options.json,
+            "purge_unknown_locks_unacknowledged",
+            "Purge requires --acknowledge-unknown-locks; undeployed repository locks are not discoverable."
+          );
+        }
+        const authority = await resolveTeamAuthority(options, ["icons:write"], dependencies);
+        if (!authority) return;
+        if (authority.team && `@${authority.team.slug}` !== confirmation.team) {
+          return emitFailure(
+            options.json,
+            "purge_confirmation_mismatch",
+            "Purge confirmation must name the selected Team."
+          );
+        }
+        const response = await authorizedTeamRequest(
+          authority,
+          `/v1/icon-sets/${encodeURIComponent(slug)}/versions/${encodeURIComponent(options.version)}/purge`,
+          "POST",
+          {
+            body: JSON.stringify({
+              acknowledgeUnknownLocks: true,
+              confirmation: options.confirm
+            }),
+            headers: {
+              "Content-Type": "application/json",
+              "Idempotency-Key": options.idempotencyKey
+            }
+          }
+        );
+        if (!response.ok) return emitHttpFailure(options.json, response.status, "purge");
+        const parsed = purgeResponseSchema.parse(response.body);
+        const document = {
+          command: "icon-set purge",
+          result: parsed.result,
+          schemaVersion: 1,
+          team: describeTeam(authority)
+        };
+        if (options.json) return emitJson(document);
+        console.log(`${pc2.green("\u2713")} Purged ${pc2.bold(options.confirm)}.`);
+        console.log(pc2.yellow(`! ${parsed.result.warning}`));
+      } catch (error) {
+        emitFailure(options.json, "icon_set_purge_failed", boundedMessage(error, "purge"));
+      }
+    }
+  );
+  async function readCommand(slug, options, command2, run) {
+    try {
+      if (!isIconSetSlug(slug)) {
+        return emitFailure(options.json, "invalid_icon_set_id", "Icon Set ID is invalid.");
+      }
+      const authority = await resolveTeamAuthority(options, ["icons:read"], dependencies);
+      if (!authority) return;
+      const result = await run(authority);
+      if ("status" in result) return emitHttpFailure(options.json, result.status, command2);
+      const document = {
+        command: command2,
+        schemaVersion: 1,
+        team: describeTeam(authority),
+        ...result.value
+      };
+      if (options.json) return emitJson(document);
+      process.stdout.write(`${JSON.stringify(document, null, 2)}
+`);
+    } catch (error) {
+      emitFailure(
+        options.json,
+        `${command2.replaceAll(/[^a-z]+/gu, "_")}_failed`,
+        boundedMessage(error, command2)
+      );
+    }
+  }
+}
+function withTeamOptions(command2) {
+  return command2.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");
+}
+async function readAllPages(authority, path, query, schema, select, identify) {
+  const items = [];
+  const seenCursors = /* @__PURE__ */ new Set();
+  const seenIds = /* @__PURE__ */ new Set();
+  let cursor = null;
+  for (let page = 0; page < maximumCatalogPages; page += 1) {
+    const parameters = new URLSearchParams({ limit: String(pageSize), ...query });
+    if (cursor) parameters.set("cursor", cursor);
+    const response = await authorizedTeamRequest(
+      authority,
+      `${path}?${parameters.toString()}`,
+      "GET"
+    );
+    if (!response.ok) throw new IconSetTransportError(response.status);
+    const parsed = schema.parse(response.body);
+    for (const item of select(parsed)) {
+      const id = identify(item);
+      if (seenIds.has(id)) throw new Error("Icon Set list returned a duplicate row.");
+      seenIds.add(id);
+      items.push(item);
+    }
+    cursor = parsed.nextCursor ?? null;
+    if (!cursor) return items;
+    if (seenCursors.has(cursor)) throw new Error("Icon Set list repeated a cursor.");
+    seenCursors.add(cursor);
+  }
+  throw new Error("Icon Set list exceeded its safe page limit.");
+}
+var IconSetTransportError = class extends Error {
+  constructor(status) {
+    super(`Icon Set request failed (${status}).`);
+    this.status = status;
+    this.name = "IconSetTransportError";
+  }
+  status;
+};
+function emitHttpFailure(json, status, command2) {
+  emitFailure(json, `http_${status}`, `Icon Set ${command2} failed (${status}).`);
+}
+function boundedMessage(error, command2) {
+  if (error instanceof IconSetTransportError) return error.message;
+  if (error instanceof Error && /limit|cursor|duplicate row/u.test(error.message)) {
+    return error.message;
+  }
+  return `Icon Set ${command2} failed.`;
+}
+function describeTeam(authority) {
+  return authority.team ? { id: authority.team.id, slug: authority.team.slug } : null;
+}
+function describeRevision(revision) {
+  return {
+    iconCount: revision.iconCount,
+    id: revision.id,
+    packageId: revision.packageId,
+    publishedAt: revision.publishedAt,
+    purgedAt: revision.purgedAt,
+    reference: revision.reference,
+    totalBytes: revision.totalBytes,
+    version: revision.version
+  };
+}
+function normalizeLocalDirectory(value) {
+  if (!value || isAbsolute2(value) || value.includes("\\") || /[\p{Cc}]/u.test(value)) return null;
+  const normalized = value.startsWith("./") || value.startsWith("../") ? value : `./${value}`;
+  return normalized.replace(/\/+$/u, "");
+}
+function parsePurgeConfirmation(value) {
+  const separator = value.lastIndexOf("@");
+  if (separator <= 0 || value.length > 160) return null;
+  const reference = value.slice(0, separator);
+  const version = value.slice(separator + 1);
+  if (!tileflowIconSetReferenceSchema.safeParse(reference).success) return null;
+  if (!/^[1-9][0-9]*$/u.test(version) || !Number.isSafeInteger(Number(version))) return null;
+  return { slug: reference.split("/")[1], team: reference.split("/")[0], version: Number(version) };
+}
+function isIconSetSlug(value) {
+  return value.length <= 64 && /^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(value);
+}
+function isIdempotencyKey(value) {
+  return value.length >= 8 && value.length <= 128 && /^[A-Za-z0-9._:-]+$/u.test(value);
+}
+var cursorSchema = z4.string().min(1).max(2048).nullable();
+var isoDateSchema = z4.iso.datetime({ offset: true });
+var setSchema = z4.object({
+  id: z4.string().regex(/^ics_[A-Za-z0-9_-]{16}$/u),
+  reference: tileflowIconSetReferenceSchema,
+  name: z4.string().max(200),
+  description: z4.string().max(2e3),
+  archivedAt: isoDateSchema.nullable(),
+  latestVersion: z4.number().int().positive().max(Number.MAX_SAFE_INTEGER).nullable(),
+  createdAt: isoDateSchema,
+  updatedAt: isoDateSchema
+}).strict();
+var revisionBaseSchema = z4.object({
+  id: z4.string().regex(/^icv_[A-Za-z0-9_-]{16}$/u),
+  reference: tileflowIconSetReferenceSchema,
+  version: z4.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  publishedAt: isoDateSchema,
+  purgedAt: isoDateSchema.nullable(),
+  iconCount: z4.number().int().min(0).max(tileflowIconPackageLimits3.maxIconCount),
+  totalBytes: z4.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  publisher: z4.object({ kind: z4.enum(["credential", "membership"]), id: z4.string().max(200).nullable() }).strict()
+}).strict();
+var revisionSchema = revisionBaseSchema.extend({ pin: tileflowIconSetPinSchema.nullable() }).transform(({ id, reference, version, publishedAt, purgedAt, iconCount, totalBytes, pin }) => ({
+  iconCount,
+  id,
+  pin,
+  publishedAt,
+  purgedAt,
+  reference,
+  totalBytes,
+  version
+}));
+var revisionSummarySchema = revisionBaseSchema.extend({ packageId: tileflowIconSetPackageIdSchema.nullable() }).transform(
+  ({ id, reference, version, publishedAt, purgedAt, iconCount, totalBytes, packageId }) => ({
+    iconCount,
+    id,
+    packageId,
+    publishedAt,
+    purgedAt,
+    reference,
+    totalBytes,
+    version
+  })
+);
+var catalogListResponseSchema = z4.object({
+  schemaVersion: z4.literal(1),
+  sets: z4.array(setSchema).max(pageSize),
+  nextCursor: cursorSchema.optional()
+}).strict();
+var catalogDetailResponseSchema = z4.object({ schemaVersion: z4.literal(1), set: setSchema }).strict();
+var versionsResponseSchema = z4.object({
+  schemaVersion: z4.literal(1),
+  versions: z4.array(revisionSummarySchema).max(pageSize),
+  nextCursor: cursorSchema.optional()
+}).strict();
+var revisionResponseSchema = z4.object({
+  schemaVersion: z4.literal(1),
+  archived: z4.boolean(),
+  revision: revisionSchema
+}).strict();
+var publishResponseSchema = z4.object({ schemaVersion: z4.literal(1), changed: z4.boolean(), revision: revisionSchema }).strict();
+var usesResponseSchema = z4.object({
+  schemaVersion: z4.literal(1),
+  uses: z4.array(
+    z4.object({
+      deploymentId: z4.string().min(1).max(160),
+      deploymentVersion: z4.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+      mapId: z4.string().min(1).max(160),
+      mapName: z4.string().max(200).nullable(),
+      mapState: z4.string().max(64),
+      versionId: z4.string().regex(/^icv_[A-Za-z0-9_-]{16}$/u),
+      version: z4.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+      ordinal: z4.number().int().min(0).max(31),
+      relationship: z4.enum(["active", "retained"])
+    }).strict()
+  ).max(pageSize),
+  nextCursor: cursorSchema.optional(),
+  coverage: z4.literal("known-hosted-deployments"),
+  includesUndeployedRepositoryLocks: z4.literal(false)
+}).strict();
+var purgeResponseSchema = z4.object({
+  schemaVersion: z4.literal(1),
+  result: z4.object({
+    schemaVersion: z4.literal(1),
+    versionId: z4.string().regex(/^icv_[A-Za-z0-9_-]{16}$/u),
+    version: z4.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    purged: z4.boolean(),
+    knownRetainedDeployments: z4.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+    physicalBytesReleased: z4.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+    unknownRepositoryLocks: z4.boolean(),
+    warning: z4.string().max(400)
+  }).strict()
+}).strict();
+
+// src/icon-lock-command.ts
+function registerIconLockCommands(program2, dependencies) {
+  const icons = program2.commands.find((command2) => command2.name() === "icons") ?? program2.command("icons").description("Inspect managed Tileflow icons");
+  withLockOptions(
+    icons.command("install").description("Lock every declared Icon Set reference that has no exact pin yet").argument("[references...]", "declared @team/set references; omit for every declared set"),
+    dependencies
+  ).action(async (references, options) => {
+    await maintainLock("install", references, options);
+  });
+  withLockOptions(
+    icons.command("update").description("Move selected declared Icon Set references to their current latest revision").argument("[references...]", "declared @team/set references; omit for every declared set"),
+    dependencies
+  ).action(async (references, options) => {
+    await maintainLock("update", references, options);
+  });
+  withLockOptions(
+    icons.command("pin").description("Lock one declared Icon Set reference to one exact revision").argument("<reference>", "declared @team/set reference").requiredOption("--version <version>", "exact positive revision"),
+    dependencies
+  ).action(async (reference, options) => {
+    if (!/^[1-9][0-9]*$/u.test(options.version) || !Number.isSafeInteger(+options.version)) {
+      return emitFailure(
+        options.json,
+        "invalid_icon_set_version",
+        "Pin requires one exact positive revision."
+      );
+    }
+    await maintainLock("pin", [reference], options, Number(options.version));
+  });
+  async function maintainLock(operation, requested, options, version) {
+    let declared;
+    let baseDirectory;
+    try {
+      const loaded = await withTileflowConfigSecretsHidden(
+        () => loadValidTileflowConfigWithInputs3(options.config)
+      );
+      baseDirectory = dirname9(loaded.configFile);
+      declared = collectDeclaredReferences(loaded.project);
+    } catch (error) {
+      return emitFailure(
+        options.json,
+        error instanceof TileflowValidationError4 ? "config_invalid" : "config_load_failed",
+        error instanceof TileflowValidationError4 ? "Tileflow config has errors." : "Tileflow config could not be loaded."
+      );
+    }
+    const selection = selectReferences(operation, requested, declared);
+    if ("error" in selection) {
+      return emitFailure(options.json, selection.error.code, selection.error.message);
+    }
+    let expected;
+    let current;
+    try {
+      expected = await readTileflowIconsLockfileText(baseDirectory);
+      current = expected === null ? {} : await readCurrentPins(expected);
+    } catch {
+      return emitFailure(
+        options.json,
+        "icon_lock_unreadable",
+        `Existing ${tileflowIconsLockfileName} is unreadable; repair or remove it explicitly.`
+      );
+    }
+    const targets = operation === "install" ? selection.selected.filter((reference) => !current[reference]) : selection.selected;
+    if (targets.length === 0 && operation !== "install") {
+      return emitFailure(
+        options.json,
+        "icon_set_not_declared",
+        "Select at least one declared @team/set reference."
+      );
+    }
+    const authority = targets.length === 0 ? null : await resolveTeamAuthority(options, ["icons:read"], dependencies);
+    if (targets.length > 0 && !authority) return;
+    const resolved = {};
+    for (const reference of targets) {
+      const result = await resolvePin(authority, reference, version);
+      if ("error" in result) {
+        return emitFailure(options.json, result.error.code, result.error.message);
+      }
+      resolved[reference] = result.pin;
+    }
+    const sets = {};
+    for (const reference of declared.references) {
+      const pin = resolved[reference] ?? current[reference];
+      if (pin) sets[reference] = pin;
+    }
+    if (expected !== null || Object.keys(sets).length > 0) {
+      try {
+        await writeTileflowIconsLockfile(baseDirectory, { lockfileVersion: 1, sets }, expected);
+      } catch (error) {
+        const code = error !== null && typeof error === "object" && "code" in error ? String(error.code) : "icon_lock_write_failed";
+        return emitFailure(
+          options.json,
+          code,
+          code === "ICON_LOCK_CONFLICT" ? "The icon lock changed while this command ran; rerun it without discarding other pins." : "The icon lock could not be written."
+        );
+      }
+    }
+    const missing = declared.references.filter((reference) => !sets[reference]);
+    const document = {
+      command: `icons ${operation}`,
+      lockfile: tileflowIconsLockfileName,
+      missing,
+      schemaVersion: 1,
+      sets: declared.references.filter((reference) => sets[reference]).map((reference) => ({
+        changed: Boolean(resolved[reference]),
+        contentHash: sets[reference].contentHash,
+        packageId: sets[reference].packageId,
+        reference,
+        version: sets[reference].version,
+        versionId: sets[reference].versionId
+      }))
+    };
+    if (options.json) return emitJson(document);
+    if (document.sets.length === 0) return console.log(pc3.gray("No Icon Set references declared."));
+    for (const entry of document.sets) {
+      console.log(
+        `  ${pc3.bold(entry.reference)} ${pc3.gray(`v${String(entry.version)}`)}${entry.changed ? "" : pc3.gray(" (unchanged)")}`
+      );
+    }
+    for (const reference of missing) {
+      console.log(pc3.yellow(`! ${reference} is declared but not locked.`));
+    }
+  }
+  async function resolvePin(authority, reference, version) {
+    const slug = reference.split("/")[1];
+    const selector = version === void 0 ? "latest" : String(version);
+    const response = await authorizedTeamRequest(
+      authority,
+      `/v1/icon-sets/${encodeURIComponent(slug)}/versions/${encodeURIComponent(selector)}`,
+      "GET"
+    );
+    if (!response.ok) {
+      return {
+        error: {
+          code: `http_${response.status}`,
+          message: `Resolving ${reference}@${selector} failed (${response.status}).`
+        }
+      };
+    }
+    const parsed = revisionResponseSchema.safeParse(response.body);
+    if (!parsed.success) {
+      return {
+        error: {
+          code: "icon_set_response_invalid",
+          message: `Resolving ${reference}@${selector} returned an invalid response.`
+        }
+      };
+    }
+    const revision = parsed.data.revision;
+    if (revision.reference !== reference) {
+      return {
+        error: {
+          code: "icon_set_reference_mismatch",
+          message: `Resolving ${reference} returned a different Icon Set.`
+        }
+      };
+    }
+    if (!revision.pin || revision.purgedAt !== null) {
+      return {
+        error: {
+          code: "icon_set_revision_unavailable",
+          message: `${reference}@${selector} has no retained delivery artifact.`
+        }
+      };
+    }
+    if (version !== void 0 && revision.version !== version) {
+      return {
+        error: {
+          code: "icon_set_revision_mismatch",
+          message: `${reference}@${selector} returned revision ${revision.version}.`
+        }
+      };
+    }
+    if (authority.team && revision.pin.teamId !== authority.team.id) {
+      return {
+        error: {
+          code: "icon_set_team_mismatch",
+          message: `${reference} is owned by a different Team.`
+        }
+      };
+    }
+    return { pin: revision.pin };
+  }
+}
+function withLockOptions(command2, dependencies) {
+  return command2.option("-c, --config <path>", "config path", dependencies.defaultConfigPath).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");
+}
+function collectDeclaredReferences(project) {
+  const references = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const mapName of getTileflowMapNames4(project).sort(compareCodeUnits7)) {
+    const sources = parseResolvedTileflowMap3(project.maps[mapName]).icons ?? [];
+    for (const reference of collectTileflowIconSetReferences(sources)) {
+      if (seen.has(reference)) continue;
+      seen.add(reference);
+      references.push(reference);
+    }
+  }
+  return { references: references.sort(compareCodeUnits7) };
+}
+function selectReferences(operation, requested, declared) {
+  if (requested.length === 0) {
+    if (operation === "pin") {
+      return { error: { code: "icon_set_not_selected", message: "Pin one @team/set reference." } };
+    }
+    return { selected: [...declared.references] };
+  }
+  const selected = [];
+  for (const reference of requested) {
+    if (!tileflowIconSetReferenceSchema2.safeParse(reference).success) {
+      return {
+        error: {
+          code: "invalid_icon_set_reference",
+          message: `${reference} is not a canonical @team/set reference.`
+        }
+      };
+    }
+    if (!declared.references.includes(reference)) {
+      return {
+        error: {
+          code: "icon_set_not_declared",
+          message: `${reference} is not declared by any map; add iconSet('${reference}') first.`
+        }
+      };
+    }
+    if (!selected.includes(reference)) {
+      selected.push(reference);
+    }
+  }
+  return { selected: selected.sort(compareCodeUnits7) };
+}
+async function readCurrentPins(contents) {
+  return (await parseTileflowIconsLockfile(contents)).sets;
+}
+
+// src/language-command.ts
+import { readFile as readFile4 } from "fs/promises";
+import { fileURLToPath } from "url";
+import {
+  serializeCanonicalJson as serializeCanonicalJson3,
+  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 failure2 = 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(failure2));
+    else {
+      console.error(`${failure2.message} [${failure2.code}; ${failure2.phase}]`);
+      console.error(`Suggestion: ${failure2.suggestion}`);
+    }
+    process.exitCode = 1;
+  }
+}
+function printManifest(manifest, options) {
+  if (options.json) {
+    process.stdout.write(`${serializeCanonicalJson3(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(`${serializeCanonicalJson3(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/native-preview-command.ts
+import { tileflowNativeProfile } from "@tileflow/core/native-profile";
+import {
+  createTileflowDevRequestHandler
+} from "@tileflow/dev/server";
+var tileflowNativePreviewBasePath = "/native";
+var tileflowNativePreviewProfile = tileflowNativeProfile.id;
+function getTileflowNativePreviewManifestUrl(origin) {
+  return `${origin}${tileflowNativePreviewBasePath}/manifest.json`;
+}
+function resolveTileflowNativePreviewSelection(manifest, options) {
+  const mapNames = Object.keys(manifest.maps).sort();
+  const mapName = options.map ?? (mapNames.length === 1 ? mapNames[0] : void 0);
+  if (!mapName || !Object.hasOwn(manifest.maps, mapName)) {
+    throw new Error(
+      options.map ? "The selected map is not present in the native artifact manifest." : "Select one configured map with --map for native artifact preview."
+    );
+  }
+  const map = manifest.maps[mapName];
+  const themeName = options.theme ?? map.defaultTheme;
+  if (!Object.hasOwn(map.themes, themeName)) {
+    throw new Error("The selected theme is not present in the native artifact manifest.");
+  }
+  return Object.freeze({ mapName, themeName });
+}
+var nativePreviewUnavailablePaths = /* @__PURE__ */ new Set([
+  `${tileflowNativePreviewBasePath}/__events`,
+  `${tileflowNativePreviewBasePath}/__status`
+]);
+function createTileflowNativePreviewRequestHandler(options) {
+  const delegate = createTileflowDevRequestHandler({
+    ...options,
+    basePath: tileflowNativePreviewBasePath
+  });
+  const notFound = () => new Response(JSON.stringify({ error: "Not found" }), {
+    headers: { "Content-Type": "application/json; charset=utf-8" },
+    status: 404
+  });
+  const handler = async (request) => {
+    let pathname;
+    try {
+      pathname = new URL(request.url).pathname;
+    } catch {
+      return notFound();
+    }
+    if (pathname === tileflowNativePreviewBasePath || pathname === `${tileflowNativePreviewBasePath}/` || nativePreviewUnavailablePaths.has(pathname) || pathname.startsWith(`${tileflowNativePreviewBasePath}/__runtime/`) || pathname.startsWith(`${tileflowNativePreviewBasePath}/__inspection/`)) {
+      return notFound();
+    }
+    return delegate(request);
+  };
+  return Object.assign(handler, {
+    close: delegate.close,
+    refresh: delegate.refresh
+  });
+}
+
+// src/open-external.ts
+import { spawn as spawnChild } from "child_process";
+import { platform as hostPlatform } from "os";
+function openTileflowExternal(target, dependencies = {}) {
+  const invocation = resolveTileflowExternalOpenInvocation(
+    target,
+    dependencies.platform ?? hostPlatform()
+  );
+  const spawn2 = dependencies.spawn ?? spawnChild;
+  let child;
+  try {
+    child = spawn2(invocation.command, invocation.args, {
+      detached: true,
+      shell: false,
+      stdio: "ignore",
+      windowsHide: true
+    });
+  } catch (error) {
+    dependencies.onError?.(error);
+    return;
+  }
+  child.once("error", (error) => dependencies.onError?.(error));
+  child.unref();
+}
+function resolveTileflowExternalOpenInvocation(target, platform) {
+  if (!target || target.includes("\0")) throw new Error("The external target is invalid.");
+  if (platform === "darwin") return { command: "open", args: [target] };
+  if (platform === "win32") return { command: "explorer.exe", args: [target] };
   return { command: "xdg-open", args: [target] };
 }
 
 // src/project-commands.ts
-import pc from "picocolors";
+import pc4 from "picocolors";
 function registerProjectCommands(program2, dependencies) {
   const projects = program2.command("projects", { hidden: true }).description("Manage internal application destinations");
   projects.command("list").description("List application destinations accessible to the authenticated Tileflow account").option("--api-url <url>", "Tileflow API URL", process.env.TILEFLOW_API_URL).option("--include-archived", "include archived application destinations").option("--json", "print deterministic schema-version-1 JSON").action(async (options) => {
@@ -3855,14 +5156,14 @@ function registerProjectCommands(program2, dependencies) {
       command: "projects list",
       projects: result.items
     };
-    if (options.json) return emitJson(document);
+    if (options.json) return emitJson2(document);
     if (!result.items.length) {
-      console.log(pc.gray("No managed destinations found."));
+      console.log(pc4.gray("No managed destinations found."));
       return;
     }
     for (const target of result.items) {
       console.log(
-        `  ${target.project.archivedAt ? pc.yellow("\u25CB") : pc.green("\u25CF")} ${pc.bold(target.project.name)} ${pc.gray(target.reference)}${target.project.archivedAt ? pc.gray(" (archived)") : ""}`
+        `  ${target.project.archivedAt ? pc4.yellow("\u25CB") : pc4.green("\u25CF")} ${pc4.bold(target.project.name)} ${pc4.gray(target.reference)}${target.project.archivedAt ? pc4.gray(" (archived)") : ""}`
       );
     }
   });
@@ -3914,9 +5215,9 @@ function registerProjectCommands(program2, dependencies) {
         command: "projects create",
         ...asRecord2(result.body)
       };
-      if (options.json) return emitJson(document);
-      console.log(`${pc.green("\u2713")} Application ${pc.bold(options.name.trim())} is ready.`);
-      console.log(pc.gray(`Its technical selector is --project @${organization.slug}/${slug}.`));
+      if (options.json) return emitJson2(document);
+      console.log(`${pc4.green("\u2713")} Application ${pc4.bold(options.name.trim())} is ready.`);
+      console.log(pc4.gray(`Its technical selector is --project @${organization.slug}/${slug}.`));
     }
   );
   projects.command("show <target>").description("Show one application destination").option("--api-url <url>", "Tileflow API URL", process.env.TILEFLOW_API_URL).option("--json", "print deterministic schema-version-1 JSON").action(async (target, options) => {
@@ -3933,13 +5234,13 @@ function registerProjectCommands(program2, dependencies) {
     );
     if (!result.ok) return emitRemoteFailure(options.json, result);
     const document = { schemaVersion: 1, command: "projects show", ...asRecord2(result.body) };
-    if (options.json) return emitJson(document);
+    if (options.json) return emitJson2(document);
     const project = asRecord2(result.body).project;
     if (!isProjectItem(project)) {
       return emitLocalFailure(false, "invalid_response", "Destination response was invalid.");
     }
-    console.log(`${pc.bold(project.name)} ${pc.gray(target)}`);
-    console.log(project.archivedAt ? pc.yellow("Archived") : pc.green("Active"));
+    console.log(`${pc4.bold(project.name)} ${pc4.gray(target)}`);
+    console.log(project.archivedAt ? pc4.yellow("Archived") : pc4.green("Active"));
   });
   for (const archived of [true, false]) {
     const verb = archived ? "archive" : "unarchive";
@@ -3965,8 +5266,8 @@ function registerProjectCommands(program2, dependencies) {
         command: `projects ${verb}`,
         ...asRecord2(result.body)
       };
-      if (options.json) return emitJson(document);
-      console.log(`${pc.green("\u2713")} Application ${archived ? "archived" : "unarchived"}.`);
+      if (options.json) return emitJson2(document);
+      console.log(`${pc4.green("\u2713")} Application ${archived ? "archived" : "unarchived"}.`);
     });
   }
 }
@@ -4008,7 +5309,7 @@ async function requireCommandSession(options, dependencies) {
   try {
     config = await dependencies.loadAuthConfig();
   } catch (error) {
-    emitLocalFailure(options.json, "auth_state_unavailable", safeMessage(error));
+    emitLocalFailure(options.json, "auth_state_unavailable", safeMessage2(error));
     return null;
   }
   const resolved = resolveAccountSession(config, options.apiUrl ?? dependencies.defaultApiUrl);
@@ -4087,13 +5388,13 @@ function emitRemoteFailure(json, result) {
 function emitLocalFailure(json, code, message, details = {}) {
   if (json) {
     console.error(message);
-    emitJson({ schemaVersion: 1, ok: false, error: { code, ...details } });
+    emitJson2({ schemaVersion: 1, ok: false, error: { code, ...details } });
   } else {
-    console.error(`${pc.red("\u2715")} ${message}`);
+    console.error(`${pc4.red("\u2715")} ${message}`);
   }
   process.exitCode = 1;
 }
-function emitJson(value) {
+function emitJson2(value) {
   process.stdout.write(`${JSON.stringify(value)}
 `);
 }
@@ -4119,21 +5420,130 @@ function validName(value) {
   const normalized = value.trim();
   return normalized.length > 0 && normalized.length <= 200 && !/[\p{Cc}]/u.test(normalized);
 }
-function safeMessage(error) {
+function safeMessage2(error) {
   return error instanceof Error && error.message.length <= 300 ? error.message : "Tileflow auth state is unavailable.";
 }
 
+// src/renderer-artifact-command.ts
+import { resolve as resolve5 } from "path";
+import { auditTileflowMapThemeValues } from "@tileflow/core";
+import {
+  createTileflowNativeDiagnostic,
+  resolveTileflowRenderer,
+  TileflowNativeCompatibilityError
+} from "@tileflow/core/native-profile";
+import {
+  createTileflowBuildArtifacts,
+  disposeTileflowBuildArtifacts,
+  writeTileflowArtifactPlan
+} from "@tileflow/dev/artifacts";
+import {
+  createTileflowCommandFailureDocument as createTileflowCommandFailureDocument4,
+  createTileflowCommandSummary as createTileflowCommandSummary2,
+  createTileflowStructuredDiagnostics as createTileflowStructuredDiagnostics2,
+  serializeTileflowCommandDocument as serializeTileflowCommandDocument4
+} from "@tileflow/dev/validation";
+async function runRendererArtifactCommand(command2, options) {
+  let artifacts;
+  try {
+    const renderer = resolveTileflowRenderer(options.renderer);
+    if (options.target !== "local" && options.target !== "hosted") {
+      throw Object.assign(new Error("Expected a local or hosted target."), {
+        code: "INVALID_TARGET",
+        phase: "command-validation",
+        path: "target"
+      });
+    }
+    if (renderer === "native" && options.target === "hosted") {
+      throw new TileflowNativeCompatibilityError([
+        createTileflowNativeDiagnostic("NATIVE_RENDERER_UNSUPPORTED", "/target")
+      ]);
+    }
+    if (command2 === "build" && options.target === "hosted") {
+      throw Object.assign(
+        new Error("Build prepares local artifacts; Hosted publication uses deploy."),
+        {
+          code: "HOSTED_INCOMPATIBLE",
+          phase: "command-validation",
+          path: "target",
+          suggestion: "Use validate --target hosted for web preflight, or build --target local."
+        }
+      );
+    }
+    artifacts = await withTileflowConfigSecretsHidden(
+      () => createTileflowBuildArtifacts({
+        apiBaseUrl: options.apiBaseUrl,
+        config: options.config,
+        ...options.icons ? { icons: options.icons } : {},
+        renderer,
+        styleBaseUrl: ".",
+        target: "production"
+      })
+    );
+    const outDir = options.out ?? "dist/tileflow";
+    if (command2 === "build") await writeTileflowArtifactPlan(artifacts, { outDir });
+    const summary = createTileflowCommandSummary2({
+      code: command2 === "validate" ? "VALIDATION_OK" : "BUILD_OK",
+      command: command2,
+      message: command2 === "validate" ? "Tileflow artifact validation passed." : "Built Tileflow artifacts.",
+      ok: true,
+      phase: command2 === "validate" ? "validation" : "build",
+      severity: "info",
+      suggestion: renderer === "native" ? "Use the prepared native manifest with a separately qualified native runtime." : "Serve the prepared artifact directory."
+    });
+    const warnings = Object.values(artifacts.project.maps).flatMap(
+      (map) => auditTileflowMapThemeValues(map).filter(({ severity }) => severity === "warning")
+    );
+    const diagnostics = warnings.length ? createTileflowStructuredDiagnostics2({ diagnostics: warnings }, process.cwd(), {
+      code: "VALIDATION_WARNING",
+      phase: "theme-audit"
+    }) : [];
+    const document = {
+      ...summary,
+      target: options.target,
+      renderer,
+      ...artifacts.nativeBuild ? { profile: artifacts.nativeBuild.profile, validation: "static-artifacts" } : {},
+      maps: Object.keys(artifacts.project.maps).sort(),
+      diagnostics
+    };
+    if (options.json) process.stdout.write(serializeTileflowCommandDocument4(document));
+    else {
+      console.log(summary.message);
+      for (const issue of diagnostics) console.warn(`${issue.path}: ${issue.message}`);
+      if (artifacts.nativeBuild)
+        console.log("Profile: native-v1 (static artifacts; no device qualification).");
+      if (command2 === "build")
+        console.log(`Output: ${resolve5(outDir, ...renderer === "native" ? ["native"] : [])}`);
+    }
+  } catch (error) {
+    const document = createTileflowCommandFailureDocument4(command2, error, process.cwd(), {
+      code: command2 === "validate" ? "VALIDATION_FAILED" : "BUILD_FAILED",
+      phase: "artifact-preparation"
+    });
+    if (options.json) process.stderr.write(serializeTileflowCommandDocument4(document));
+    else {
+      for (const issue of document.diagnostics) {
+        console.error(`${issue.code} ${issue.path || "(root)"}: ${issue.message}`);
+        console.error(`Suggestion: ${issue.suggestion}`);
+      }
+    }
+    process.exitCode = 1;
+  } finally {
+    if (artifacts) await disposeTileflowBuildArtifacts(artifacts);
+  }
+}
+
 // src/tileset-command.ts
-import pc2 from "picocolors";
-import { serializeCanonicalJson as serializeCanonicalJson3 } from "@tileflow/core";
-import { inspectTileflowPmtiles } from "@tileflow/dev/tilesets";
+import pc5 from "picocolors";
 import { z as z6 } from "zod";
+import { serializeCanonicalJson as serializeCanonicalJson5 } from "@tileflow/core";
+import { inspectTileflowPmtiles } from "@tileflow/dev/tilesets";
 
 // src/tileset-upload.ts
 import { createHash } from "crypto";
 import { open as open4, stat } from "fs/promises";
 import { z as z5 } from "zod";
-import { serializeCanonicalJson as serializeCanonicalJson2 } from "@tileflow/core";
+import { serializeCanonicalJson as serializeCanonicalJson4 } from "@tileflow/core";
 var teamTilesetPartSize = 16777216;
 var maximumTeamTilesetBytes = 4e9;
 var authorizationBatchSize = 16;
@@ -4273,7 +5683,7 @@ async function prepareTeamTilesetUpload(file) {
   };
   return Object.freeze({
     byteCount: identity.size,
-    contentHash: createHash("sha256").update(serializeCanonicalJson2(contentIdentity)).digest("hex"),
+    contentHash: createHash("sha256").update(serializeCanonicalJson4(contentIdentity)).digest("hex"),
     contentHashAlgorithm: "sha256-fixed-parts-v1",
     identity,
     partSize: teamTilesetPartSize,
@@ -4289,7 +5699,7 @@ function createTeamTilesetUploadIdempotencyKey(tilesetId, upload) {
     );
   }
   return createHash("sha256").update(
-    serializeCanonicalJson2({
+    serializeCanonicalJson4({
       byteCount: upload.byteCount,
       contentHash: upload.contentHash,
       contentHashAlgorithm: upload.contentHashAlgorithm,
@@ -4693,7 +6103,7 @@ function asRecord3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function defaultSleep(milliseconds) {
-  return new Promise((resolve8) => setTimeout(resolve8, milliseconds));
+  return new Promise((resolve9) => setTimeout(resolve9, milliseconds));
 }
 var identifierSchema = z5.string().min(20).max(80).regex(/^[A-Za-z0-9_-]+$/u);
 var uploadPartStatusSchema = z5.object({
@@ -4780,11 +6190,11 @@ function registerTilesetCommands(program2, dependencies) {
           sample: options.sample
         });
         if (options.json) {
-          process.stdout.write(`${serializeCanonicalJson3(inspection)}
+          process.stdout.write(`${serializeCanonicalJson5(inspection)}
 `);
           return;
         }
-        console.log(`${pc2.green("\u2713")} PMTiles archive is valid.`);
+        console.log(`${pc5.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}`);
@@ -4794,7 +6204,7 @@ function registerTilesetCommands(program2, dependencies) {
           );
         }
         for (const warning of inspection.warnings) {
-          console.log(`${pc2.yellow("!")} ${warning.message}`);
+          console.log(`${pc5.yellow("!")} ${warning.message}`);
         }
       } catch (error) {
         const record = asRecord4(error);
@@ -4803,11 +6213,11 @@ function registerTilesetCommands(program2, dependencies) {
         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 })}
+            `${serializeCanonicalJson5({ error: { code, message, path }, ok: false, schemaVersion: 1 })}
 `
           );
         } else {
-          console.error(`${pc2.red("Error:")} ${message}`);
+          console.error(`${pc5.red("Error:")} ${message}`);
         }
         process.exitCode = 1;
       }
@@ -4889,9 +6299,9 @@ function registerTilesetCommands(program2, dependencies) {
             version: { id: publication.versionId, number: publication.version }
           }
         };
-        if (options.json) return emitJson2(document);
+        if (options.json) return emitJson(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"}.`
+          `${pc5.green("\u2713")} ${publication.changed ? "Published" : "Unchanged"} ${pc5.bold(options.id)} in ${authority.team ? `@${authority.team.slug}` : "the Team bound to the data key"}.`
         );
       } catch (error) {
         if (error instanceof TeamTilesetUploadError) {
@@ -4910,10 +6320,10 @@ function registerTilesetCommands(program2, 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."));
+      if (options.json) return emitJson(document);
+      if (items.length === 0) return console.log(pc5.gray("No Team tilesets."));
       for (const item of items) {
-        console.log(`  ${pc2.bold(item.logicalName)} ${pc2.gray(item.status)}`);
+        console.log(`  ${pc5.bold(item.logicalName)} ${pc5.gray(item.status)}`);
       }
     } catch {
       emitFailure(options.json, "tileset_list_failed", "Tileset list failed.");
@@ -4939,9 +6349,9 @@ function registerTilesetCommands(program2, dependencies) {
       }
       const parsed = tilesetDetailResponseSchema.parse(response.body);
       const document = { command: "tileset status", schemaVersion: 1, tileset: parsed.tileset };
-      if (options.json) return emitJson2(document);
+      if (options.json) return emitJson(document);
       const item = parsed.tileset;
-      console.log(`${pc2.bold(item.name)} ${pc2.gray(item.state)}`);
+      console.log(`${pc5.bold(item.name)} ${pc5.gray(item.state)}`);
       console.log(`  ID: ${item.id}`);
       console.log(`  Current version: ${String(item.currentVersion ?? "unpublished")}`);
     } catch {
@@ -4982,97 +6392,20 @@ function registerTilesetCommands(program2, 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 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 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 emitJson(document);
+      console.log(`${pc5.green("\u2713")} Purge ${parsed.reclamation}.`);
+    } catch {
+      emitFailure(options.json, "tileset_purge_failed", "Tileset purge failed.");
     }
-    return { apiOrigin, credential: options.apiKey, team: null };
-  }
-  let config;
-  try {
-    config = await dependencies.loadAuthConfig();
-  } catch (error) {
-    emitFailure(options.json, "auth_state_unavailable", safeMessage2(error));
-    return null;
-  }
-  const selected = resolveAccountSession(config, options.apiUrl ?? dependencies.defaultApiUrl);
-  if (selected.kind !== "selected") {
-    emitFailure(
-      options.json,
-      `account_session_${selected.kind}`,
-      selected.kind === "expired" ? "Account session expired. Run tileflow login." : "Run tileflow login."
-    );
-    return null;
-  }
-  const discovered = await listAccountTeams(selected.session);
-  if (!discovered.ok) {
-    emitFailure(options.json, "team_discovery_failed", discovered.error);
-    return null;
-  }
-  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;
-  }
-  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;
-  }
-  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 authorizedTeamRequest(authority, path, method) {
-  return requestHostedJson(authority.apiOrigin, path, {
-    headers: { Authorization: `Bearer ${authority.credential}` },
-    method
   });
 }
 async function fetchAllTeamTilesets(authority) {
@@ -5111,21 +6444,6 @@ async function fetchAllTeamTilesets(authority) {
   }
   throw new Error("Tileset list exceeded its safe page limit.");
 }
-function emitJson2(value) {
-  process.stdout.write(`${serializeCanonicalJson3(value)}
-`);
-}
-function emitFailure(json, code, message, context = {}) {
-  if (json) {
-    process.stderr.write(
-      `${serializeCanonicalJson3({ error: { code, ...context, message }, ok: false, schemaVersion: 1 })}
-`
-    );
-  } else {
-    console.error(`${pc2.red("Error:")} ${message}`);
-  }
-  process.exitCode = 1;
-}
 function isTilesetId(value) {
   return /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(value) && !["terrain", "world"].includes(value);
 }
@@ -5143,15 +6461,12 @@ function inspectionOptionError(message) {
     path: "includeValues"
   });
 }
-function safeMessage2(error) {
-  return error instanceof Error ? error.message : "Tileset command failed.";
-}
 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 cursorSchema2 = 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(),
@@ -5165,7 +6480,7 @@ var tilesetInventoryItemSchema = z6.object({
   usedByMapCount: z6.number().int().min(0).max(Number.MAX_SAFE_INTEGER)
 }).strict();
 var tilesetListResponseSchema = z6.object({
-  nextCursor: cursorSchema.optional(),
+  nextCursor: cursorSchema2.optional(),
   schemaVersion: z6.literal(1),
   tilesets: z6.array(tilesetInventoryItemSchema).max(100)
 }).strict();
@@ -5183,7 +6498,7 @@ var tilesetDetailResponseSchema = 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,
+    dependencyNextCursor: cursorSchema2,
     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),
@@ -5199,7 +6514,7 @@ 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
+  nextCursor: cursorSchema2
 }).strict();
 var tilesetPurgeResponseSchema = z6.object({
   deliveryFence: z6.enum(["complete", "pending"]),
@@ -5211,7 +6526,7 @@ var tilesetPurgeResponseSchema = z6.object({
 
 // src/visual-command.ts
 import { lstat as lstat4, 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 { dirname as dirname11, isAbsolute as isAbsolute4, parse as parse2, relative as relative4, resolve as resolve7, sep as sep4 } from "path";
 import {
   analyzeTileflowCaptureReference,
   compareTileflowCaptureToBaseline,
@@ -5225,12 +6540,12 @@ import {
   tileflowVisualArtifactLimits,
   validateTileflowVisualReferencePng
 } from "@tileflow/capture";
-import { compareCodeUnits as compareCodeUnits8 } from "@tileflow/core";
+import { compareCodeUnits as compareCodeUnits9 } from "@tileflow/core";
 
 // src/visual-compare-command.ts
 import { createHash as createHash3 } from "crypto";
 import { lstat as lstat3, 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 { basename as basename3, dirname as dirname10, extname, isAbsolute as isAbsolute3, parse, relative as relative3, resolve as resolve6, sep as sep3 } from "path";
 import {
   compareTileflowCapturesForReview,
   createTileflowCaptureSession as createTileflowCaptureSession2,
@@ -5239,16 +6554,16 @@ import {
   tileflowSyntheticAssetOrigin as tileflowSyntheticAssetOrigin2
 } from "@tileflow/capture";
 import {
-  compareCodeUnits as compareCodeUnits7,
+  compareCodeUnits as compareCodeUnits8,
   normalizeTileflowCaptureScene as normalizeTileflowCaptureScene2,
-  parseResolvedTileflowMap as parseResolvedTileflowMap2,
+  parseResolvedTileflowMap as parseResolvedTileflowMap4,
   resolveThemeSelection,
   tileflowCaptureSceneLimits
 } from "@tileflow/core";
 import {
   createTileflowArtifactDiagnostics as createTileflowArtifactDiagnostics2,
   createTileflowArtifactSession as createTileflowArtifactSession2,
-  createTileflowBuildArtifacts
+  createTileflowBuildArtifacts as createTileflowBuildArtifacts2
 } from "@tileflow/dev/artifacts";
 
 // src/visual-compare-report.ts
@@ -5543,15 +6858,15 @@ async function parseVisualComparePlan(options) {
 }
 async function createArtifactPair(plan) {
   const cwd = process.cwd();
-  const leftPath = portablePathIdentity(resolve5(cwd, plan.config));
-  const rightPath = portablePathIdentity(resolve5(cwd, plan.againstConfig));
-  const left = await createTileflowBuildArtifacts({
+  const leftPath = portablePathIdentity(resolve6(cwd, plan.config));
+  const rightPath = portablePathIdentity(resolve6(cwd, plan.againstConfig));
+  const left = await createTileflowBuildArtifacts2({
     assetBaseUrl: tileflowSyntheticAssetOrigin2,
     config: plan.config,
     cwd
   });
   if (leftPath === rightPath) return [left, left];
-  const right = await createTileflowBuildArtifacts({
+  const right = await createTileflowBuildArtifacts2({
     assetBaseUrl: tileflowSyntheticAssetOrigin2,
     config: plan.againstConfig,
     cwd
@@ -5671,7 +6986,7 @@ async function prepareVisualCompareOutput(plan, leftArtifacts, rightArtifacts, c
       documentPath: relativePath(cwd, plan.output.documentPath),
       reportPath: relativePath(cwd, plan.output.reportPath)
     },
-    warnings: [...warnings].sort(compareCodeUnits7)
+    warnings: [...warnings].sort(compareCodeUnits8)
   };
   const report = renderTileflowVisualCompareReport({
     generatedBy: "Tileflow CLI",
@@ -5696,7 +7011,7 @@ async function prepareVisualCompareOutput(plan, leftArtifacts, rightArtifacts, c
     files,
     incompatible,
     nextAssets: inventory.assets.map((asset) => ({
-      path: resolve5(plan.output.assetDirectory, asset.path),
+      path: resolve6(plan.output.assetDirectory, asset.path),
       sha256: asset.sha256
     })),
     removePaths: [...new Set(removePaths)].filter((path) => !filePaths.has(path))
@@ -5715,7 +7030,7 @@ async function writePreparedVisualCompareOutput(output, prepared) {
 async function runVisualCompareWatch(plan, openReport) {
   const cwd = process.cwd();
   const controller = installSignalAbortController();
-  const sameConfig = portablePathIdentity(resolve5(cwd, plan.config)) === portablePathIdentity(resolve5(cwd, plan.againstConfig));
+  const sameConfig = portablePathIdentity(resolve6(cwd, plan.config)) === portablePathIdentity(resolve6(cwd, plan.againstConfig));
   let leftSession;
   let rightSession;
   let captureSession;
@@ -5959,7 +7274,7 @@ async function runVisualCompareWatch(plan, openReport) {
   }
 }
 function resolveVisualCompareSide(artifacts, config, requestedMap, requestedTheme, role) {
-  const availableMaps = Object.keys(artifacts.project.maps).sort(compareCodeUnits7);
+  const availableMaps = Object.keys(artifacts.project.maps).sort(compareCodeUnits8);
   const map = requestedMap ?? (availableMaps.length === 1 ? availableMaps[0] : void 0);
   if (!map) {
     throw new Error(
@@ -5972,7 +7287,7 @@ function resolveVisualCompareSide(artifacts, config, requestedMap, requestedThem
       `Unknown ${role} map "${map}". Available maps: ${availableMaps.join(", ") || "(none)"}.`
     );
   }
-  const resolvedMap = parseResolvedTileflowMap2(candidate);
+  const resolvedMap = parseResolvedTileflowMap4(candidate);
   const theme = resolveThemeSelection(resolvedMap, requestedTheme).name;
   if (!artifacts.styles[map]?.[theme]) {
     throw new Error(`The ${role} map theme "${map}/${theme}" was not compiled.`);
@@ -6024,11 +7339,11 @@ function requireCapture(captures, scene, role) {
   return capture;
 }
 async function resolveVisualCompareOutput(cwd, value, managed, force, watch, zooms) {
-  const reportPath = resolve5(cwd, value);
+  const reportPath = resolve6(cwd, value);
   if (extname(reportPath).toLowerCase() !== ".html") {
     throw new Error("--report must name an .html file.");
   }
-  const reportDirectory = dirname8(reportPath);
+  const reportDirectory = dirname10(reportPath);
   if (reportDirectory === cwd || reportDirectory === parse(reportPath).root) {
     throw new Error("Visual compare output must use a dedicated subdirectory.");
   }
@@ -6038,7 +7353,7 @@ async function resolveVisualCompareOutput(cwd, value, managed, force, watch, zoo
   const stem = reportPath.slice(0, -".html".length);
   const documentPath = `${stem}.json`;
   const assetDirectory = `${stem}.assets`;
-  const inventoryPath = resolve5(assetDirectory, tileflowVisualCompareInventoryFileName);
+  const inventoryPath = resolve6(assetDirectory, tileflowVisualCompareInventoryFileName);
   const boundary = isInside(cwd, reportDirectory) ? cwd : reportDirectory;
   await assertNoSymlinkComponents(reportDirectory, boundary);
   await assertNoSymlinkComponents(assetDirectory, boundary);
@@ -6078,16 +7393,16 @@ async function resolveVisualCompareOutput(cwd, value, managed, force, watch, zoo
 function visualCompareRowPaths(output, index, zoom, includeDiff) {
   const prefix = `${String(index + 1).padStart(2, "0")}-z${zoomSlug(zoom)}`;
   return {
-    leftPath: resolve5(output.assetDirectory, `${prefix}.left.png`),
-    rightPath: resolve5(output.assetDirectory, `${prefix}.right.png`),
-    leftReceiptPath: resolve5(output.assetDirectory, `${prefix}.left.receipt.json`),
-    rightReceiptPath: resolve5(output.assetDirectory, `${prefix}.right.receipt.json`),
-    diffPath: includeDiff ? resolve5(output.assetDirectory, `${prefix}.diff.png`) : void 0
+    leftPath: resolve6(output.assetDirectory, `${prefix}.left.png`),
+    rightPath: resolve6(output.assetDirectory, `${prefix}.right.png`),
+    leftReceiptPath: resolve6(output.assetDirectory, `${prefix}.left.receipt.json`),
+    rightReceiptPath: resolve6(output.assetDirectory, `${prefix}.right.receipt.json`),
+    diffPath: includeDiff ? resolve6(output.assetDirectory, `${prefix}.diff.png`) : void 0
   };
 }
 function sideJson(side, cwd) {
   return {
-    config: relativePath(cwd, resolve5(cwd, side.config)),
+    config: relativePath(cwd, resolve6(cwd, side.config)),
     label: side.label,
     map: side.map,
     theme: side.theme
@@ -6095,13 +7410,13 @@ function sideJson(side, cwd) {
 }
 function watchSideLabel(cwd, config, map, theme) {
   const selection = map ? `${map} / ${theme ?? "default theme"}` : `singular map / ${theme ?? "default theme"}`;
-  return `${relativePath(cwd, resolve5(cwd, config))} (${selection})`;
+  return `${relativePath(cwd, resolve6(cwd, config))} (${selection})`;
 }
 async function assertVisualCompareOutputDoesNotOverlapInputs(plan, leftArtifacts, rightArtifacts) {
   const cwd = process.cwd();
   const inputs = mergeVisualCompareInputPaths([
-    { kind: "file", path: resolve5(cwd, plan.config) },
-    { kind: "file", path: resolve5(cwd, plan.againstConfig) },
+    { kind: "file", path: resolve6(cwd, plan.config) },
+    { kind: "file", path: resolve6(cwd, plan.againstConfig) },
     ...visualCompareArtifactInputPaths(leftArtifacts),
     ...visualCompareArtifactInputPaths(rightArtifacts)
   ]);
@@ -6168,7 +7483,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) => compareCodeUnits7(left.path, right.path))
+    }).sort((left, right) => compareCodeUnits8(left.path, right.path))
   };
 }
 function serializeVisualCompareInventory(inventory) {
@@ -6176,7 +7491,7 @@ function serializeVisualCompareInventory(inventory) {
 `;
 }
 async function readVisualCompareInventory(assetDirectory, inventoryPath, boundary) {
-  await assertNoSymlinkComponents(dirname8(inventoryPath), boundary);
+  await assertNoSymlinkComponents(dirname10(inventoryPath), boundary);
   let info;
   try {
     info = await lstat3(inventoryPath);
@@ -6199,8 +7514,8 @@ async function readVisualCompareInventory(assetDirectory, inventoryPath, boundar
   const inventory = validateVisualCompareInventory(parsed);
   const assets = [];
   for (const asset of inventory.assets) {
-    const path = resolve5(assetDirectory, asset.path);
-    await assertNoSymlinkComponents(dirname8(path), boundary);
+    const path = resolve6(assetDirectory, asset.path);
+    await assertNoSymlinkComponents(dirname10(path), boundary);
     let assetInfo;
     try {
       assetInfo = await lstat3(path);
@@ -6243,7 +7558,7 @@ function validateVisualCompareInventory(input) {
     return { path: asset.path, sha256: asset.sha256 };
   });
   const paths = assets.map((asset) => asset.path);
-  const sortedPaths = [...paths].sort(compareCodeUnits7);
+  const sortedPaths = [...paths].sort(compareCodeUnits8);
   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.");
   }
@@ -6263,25 +7578,25 @@ function isVisualCompareOwnedAssetName(value) {
   return Number.isInteger(row) && row >= 1 && row <= tileflowVisualCompareLimits.maximumRows;
 }
 function hasExactKeys(record, keys) {
-  const actual = Object.keys(record).sort(compareCodeUnits7);
-  const expected = [...keys].sort(compareCodeUnits7);
+  const actual = Object.keys(record).sort(compareCodeUnits8);
+  const expected = [...keys].sort(compareCodeUnits8);
   return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
 }
 function sha256Source(source) {
   return createHash3("sha256").update(typeof source === "string" ? Buffer.from(source, "utf8") : Buffer.from(source)).digest("hex");
 }
 async function canonicalPathIdentity(path) {
-  const absolute = resolve5(path);
+  const absolute = resolve6(path);
   let current = absolute;
   const missingSegments = [];
   while (true) {
     try {
       const existing = await realpath(current);
-      const canonical = resolve5(existing, ...missingSegments.reverse()).normalize("NFC");
+      const canonical = resolve6(existing, ...missingSegments.reverse()).normalize("NFC");
       return process.platform === "win32" ? canonical.toLowerCase() : canonical;
     } catch (error) {
       if (!isMissingPathComponent(error)) throw error;
-      const parent = dirname8(current);
+      const parent = dirname10(current);
       if (parent === current) {
         const canonical = absolute.normalize("NFC");
         return process.platform === "win32" ? canonical.toLowerCase() : canonical;
@@ -6353,12 +7668,12 @@ function formatCoordinate(value) {
   return String(Math.round(value * 1e6) / 1e6);
 }
 function portablePathIdentity(path) {
-  const normalized = resolve5(path).normalize("NFC");
+  const normalized = resolve6(path).normalize("NFC");
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 function isInside(parent, child) {
   const path = relative3(parent, child);
-  return path === "" || path !== ".." && !path.startsWith(`..${sep3}`) && !isAbsolute2(path);
+  return path === "" || path !== ".." && !path.startsWith(`..${sep3}`) && !isAbsolute3(path);
 }
 function pathsOverlap(left, right) {
   return isInside(left, right) || isInside(right, left);
@@ -6438,7 +7753,7 @@ function createTileflowVisualDiffJson(comparisons, cwd) {
   return {
     schemaVersion: 1,
     command: "visual.diff",
-    comparisons: [...comparisons].sort((left, right) => compareCodeUnits8(left.comparison.scene, right.comparison.scene)).map(({ comparison, baselinePath, actualPath, diffPath, reportPath }) => ({
+    comparisons: [...comparisons].sort((left, right) => compareCodeUnits9(left.comparison.scene, right.comparison.scene)).map(({ comparison, baselinePath, actualPath, diffPath, reportPath }) => ({
       ...createTileflowVisualComparisonDocument(comparison),
       baselinePath: relativePath(cwd, baselinePath),
       actualPath: relativePath(cwd, actualPath),
@@ -6466,14 +7781,14 @@ async function runVisualAnalyze(scene, options) {
   validateVisualSelection([scene]);
   const region = options.region === void 0 ? void 0 : parseTileflowVisualRegion(options.region);
   const cwd = process.cwd();
-  const referencePath = resolve6(cwd, options.reference);
+  const referencePath = resolve7(cwd, options.reference);
   const referencePng = await readVisualReference(referencePath);
   const referenceDimensions = validateTileflowVisualReferencePng(referencePng);
   if (region) assertTileflowVisualRegionFits(region, referenceDimensions, "reference PNG");
   const outputDirectory = await resolveVisualDirectory(cwd, options.outputDir, "output");
-  const actualPath = resolve6(outputDirectory.path, `${scene}.actual.png`);
-  const managedDiffPath = resolve6(outputDirectory.path, `${scene}.diff.png`);
-  const reportPath = resolve6(outputDirectory.path, `${scene}.analysis.json`);
+  const actualPath = resolve7(outputDirectory.path, `${scene}.actual.png`);
+  const managedDiffPath = resolve7(outputDirectory.path, `${scene}.diff.png`);
+  const reportPath = resolve7(outputDirectory.path, `${scene}.analysis.json`);
   assertReferenceIsReadOnly(referencePath, [actualPath, managedDiffPath, reportPath]);
   const controller = installSignalAbortController();
   const session = createTileflowCaptureSession3({
@@ -6562,15 +7877,15 @@ async function runVisualDiff(scenes, options) {
         capture,
         files.kind === "complete" ? files.baseline : void 0
       );
-      const actualPath = resolve6(outputDirectory.path, `${capture.scene}.actual.png`);
-      const diffPath = comparison.diffPng ? resolve6(outputDirectory.path, `${capture.scene}.diff.png`) : void 0;
+      const actualPath = resolve7(outputDirectory.path, `${capture.scene}.actual.png`);
+      const diffPath = comparison.diffPng ? resolve7(outputDirectory.path, `${capture.scene}.diff.png`) : void 0;
       prepared.push({
         capture,
         comparison,
         baselinePath: files.pngPath,
         actualPath,
         diffPath,
-        reportPath: resolve6(outputDirectory.path, `${capture.scene}.visual.json`)
+        reportPath: resolve7(outputDirectory.path, `${capture.scene}.visual.json`)
       });
     }
     const document = createTileflowVisualDiffJson(prepared, cwd);
@@ -6590,7 +7905,7 @@ async function runVisualDiff(scenes, options) {
         }
       ]),
       removePaths: prepared.flatMap(
-        (item) => item.diffPath ? [] : [resolve6(outputDirectory.path, `${item.capture.scene}.diff.png`)]
+        (item) => item.diffPath ? [] : [resolve7(outputDirectory.path, `${item.capture.scene}.diff.png`)]
       )
     });
     if (options.json) {
@@ -6653,7 +7968,7 @@ async function runVisualUpdate(scenes, options) {
           renderer: capture.renderer,
           networkDependent: capture.networkDependent
         },
-        warnings: [...capture.warnings].sort(compareCodeUnits8)
+        warnings: [...capture.warnings].sort(compareCodeUnits9)
       });
       outputFiles.push(
         { path: files.pngPath, source: capture.png },
@@ -6670,7 +7985,7 @@ async function runVisualUpdate(scenes, options) {
     const document = {
       schemaVersion: 1,
       command: "visual.update",
-      updates: updates.sort((left, right) => compareCodeUnits8(left.scene, right.scene))
+      updates: updates.sort((left, right) => compareCodeUnits9(left.scene, right.scene))
     };
     if (options.json) {
       process.stdout.write(serializeTileflowVisualCommandJson(document));
@@ -6711,7 +8026,7 @@ async function resolvePreviousBaseline(capture, files) {
   }
 }
 async function readBaselineFiles(directory, scene) {
-  const pngPath = resolve6(directory.path, `${scene}.png`);
+  const pngPath = resolve7(directory.path, `${scene}.png`);
   const receiptPath = captureReceiptPath(pngPath);
   const [png, receipt] = await Promise.all([
     readOptionalArtifact(pngPath, directory.boundary, tileflowVisualArtifactLimits.maximumPngBytes),
@@ -6726,7 +8041,7 @@ async function readBaselineFiles(directory, scene) {
   return { kind: "complete", pngPath, receiptPath, baseline: { png, receipt } };
 }
 async function readOptionalArtifact(path, boundary, maximumBytes) {
-  await assertNoSymlinkComponents(dirname9(path), boundary);
+  await assertNoSymlinkComponents(dirname11(path), boundary);
   let info;
   try {
     info = await lstat4(path);
@@ -6771,12 +8086,12 @@ async function readVisualReference(path) {
   return new Uint8Array(await readFile6(path));
 }
 async function resolveVisualDirectory(cwd, value, kind) {
-  const path = resolve6(cwd, value);
+  const path = resolve7(cwd, value);
   if (path === cwd || path === parse2(path).root) {
     throw new Error(`Visual ${kind} directory must be a dedicated subdirectory.`);
   }
   if (kind === "baseline") {
-    for (const managed of [resolve6(cwd, ".tileflow/captures"), resolve6(cwd, ".tileflow/diffs")]) {
+    for (const managed of [resolve7(cwd, ".tileflow/captures"), resolve7(cwd, ".tileflow/diffs")]) {
       if (pathsOverlap2(path, managed)) {
         throw new Error("Visual baselines must not overlap Tileflow-managed capture/diff outputs.");
       }
@@ -6812,11 +8127,11 @@ function assertReferenceIsReadOnly(referencePath, outputPaths) {
   }
 }
 function portablePathIdentity2(path) {
-  return resolve6(path).normalize("NFC").toLowerCase();
+  return resolve7(path).normalize("NFC").toLowerCase();
 }
 function isInside2(parent, child) {
   const path = relative4(parent, child);
-  return path === "" || path !== ".." && !path.startsWith(`..${sep4}`) && !isAbsolute3(path);
+  return path === "" || path !== ".." && !path.startsWith(`..${sep4}`) && !isAbsolute4(path);
 }
 function isMissingFile5(error) {
   return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
@@ -6831,12 +8146,14 @@ 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(pc3.gray("\nRun tileflow <command> --help for usage.")).showSuggestionAfterError();
+program.name("tileflow").description("Beautiful maps from config.").showHelpAfterError(pc6.gray("\nRun tileflow <command> --help for usage.")).showSuggestionAfterError();
+program.addHelpText("after", "\n  -V, --version  output the version number\n");
 registerLanguageCommand(program);
 registerTilesetCommands(program, { defaultApiUrl, loadAuthConfig });
+registerIconSetCommands(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");
+  const configPath = resolve8(process.cwd(), defaultConfigPath);
+  const ignorePath = resolve8(process.cwd(), ".gitignore");
   if (existsSync(configPath) && !options.force) {
     logWarning(`${pathLabel(defaultConfigPath)} already exists.`);
     printNextSteps([`Run ${command("tileflow init --force")} to replace it.`]);
@@ -6852,9 +8169,9 @@ program.command("init").description("Create a starter tileflow.config.ts").optio
   }
   logSuccess(`Created ${pathLabel(defaultConfigPath)}.`);
   printKeyValue("Path", pathLabel(configPath));
-  printKeyValue("Map", pc3.bold("madrid"));
+  printKeyValue("Map", pc6.bold("madrid"));
   printNextSteps([
-    `Install ${pc3.cyan("@tileflow/core")} and ${pc3.cyan("@tileflow/maps")} in this project if needed.`,
+    `Install ${pc6.cyan("@tileflow/core")} and ${pc6.cyan("@tileflow/maps")} in this project if needed.`,
     `Preview locally with ${command("tileflow preview")}.`,
     `Validate the config with ${command("tileflow validate")}.`
   ]);
@@ -6943,177 +8260,244 @@ program.command("whoami").description("Show the authenticated Tileflow account")
   logSuccess("Tileflow CLI is authenticated.");
   printAccountDetails(selected.session);
 });
-program.command("validate").description("Validate a Tileflow config").option("-c, --config <path>", "config path", defaultConfigPath).option("--target <target>", "validation target: local or hosted", "local").option(
+program.command("validate").description("Validate a Tileflow config").option("-c, --config <path>", "config path", defaultConfigPath).option("--target <target>", "validation target: local or hosted", "local").option("--renderer <renderer>", "artifact renderer: web or native", "web").option(
   "--api-base-url <url>",
   "Tileflow API base URL used to resolve official map assets",
   process.env.TILEFLOW_API_URL ?? defaultApiUrl
-).option("--json", "print deterministic schema-version-1 JSON").action(async (options) => {
-  if (options.target !== "local" && options.target !== "hosted") {
-    if (options.json) {
-      const failure = createTileflowCommandFailureDocument4(
-        "validate",
-        {
-          code: "INVALID_TARGET",
-          issues: [
-            {
-              code: "INVALID_TARGET",
-              message: `Invalid validation target: ${options.target}`,
-              path: "target",
-              phase: "command-validation"
-            }
-          ],
-          phase: "command-validation"
-        },
-        process.cwd(),
-        { code: "INVALID_TARGET", phase: "command-validation" }
-      );
-      process.stderr.write(serializeTileflowCommandDocument4(failure));
-      process.exitCode = 1;
+).option("--cache-dir <path>", "verified Icon Set artifact cache root").option("--offline", "fail a locked Icon Set cache miss instead of hydrating it").option("--json", "print deterministic schema-version-1 JSON").action(
+  async (options) => {
+    if (options.renderer !== "web") {
+      await runRendererArtifactCommand("validate", {
+        ...options,
+        icons: resolveIconOptions(options)
+      });
       return;
     }
-    logError(`Invalid validation target: ${options.target}`);
-    printNextSteps([
-      `Use ${command("tileflow validate --target local")} or ${command("tileflow validate --target hosted")}.`
-    ]);
-    process.exitCode = 1;
-    return;
-  }
-  let failureDefaults = { code: "CONFIG_LOAD_FAILED", phase: "config-load" };
-  try {
-    if (!options.json) logInfo(`Validating ${pathLabel(options.config)}.`);
-    const loaded = await withTileflowConfigSecretsHidden(
-      () => loadTileflowConfigWithInputs3(options.config)
-    );
-    const project = loaded.project;
-    const baseDirectory = dirname10(loaded.configFile);
-    failureDefaults = { code: "CONFIG_INVALID", phase: "config-validation" };
-    assertValidTileflowConfig2(project);
-    const mapNames = getTileflowMapNames3(project).sort();
-    failureDefaults = { code: "ICON_COMPILATION_FAILED", phase: "icon-compilation" };
-    const compiledIcons = await compileTileflowIconPackages2(project, {
-      baseDirectory,
-      cwd: process.cwd(),
-      target: options.target
-    });
-    const mapAssets = createCompiledMapAssets(
-      compiledIcons,
-      (binding) => options.target === "hosted" ? `${normalizeUrl(options.apiBaseUrl)}/sprites/preflight/${binding.packageHash}/sprite` : `/tileflow/icons/${binding.mapName}/sprite`
-    );
-    failureDefaults = { code: "STYLE_INVALID", phase: "style-validation" };
-    const compiledStyles = createTileflowStyles(project, {
-      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, localTilesets.styles, {
-      assetBaseUrl: "/tileflow",
-      baseDirectory,
-      cwd: process.cwd(),
-      target: options.target
-    });
-    failureDefaults = { code: "HOSTED_INCOMPATIBLE", phase: "hosted-validation" };
-    const hostedIssues = options.target === "hosted" ? inspectTileflowHostedCompatibility(project, styles) : [];
-    if (hostedIssues.length > 0) {
-      if (!options.json) {
-        printHostedCompatibilityIssues(hostedIssues);
+    if (options.target !== "local" && options.target !== "hosted") {
+      if (options.json) {
+        const failure2 = createTileflowCommandFailureDocument5(
+          "validate",
+          {
+            code: "INVALID_TARGET",
+            issues: [
+              {
+                code: "INVALID_TARGET",
+                message: `Invalid validation target: ${options.target}`,
+                path: "target",
+                phase: "command-validation"
+              }
+            ],
+            phase: "command-validation"
+          },
+          process.cwd(),
+          { code: "INVALID_TARGET", phase: "command-validation" }
+        );
+        process.stderr.write(serializeTileflowCommandDocument5(failure2));
+        process.exitCode = 1;
         return;
       }
-      throw Object.assign(new Error("Tileflow config is not Hosted-compatible."), {
-        code: "HOSTED_INCOMPATIBLE",
-        issues: hostedIssues.map((issue) => ({
+      logError(`Invalid validation target: ${options.target}`);
+      printNextSteps([
+        `Use ${command("tileflow validate --target local")} or ${command("tileflow validate --target hosted")}.`
+      ]);
+      process.exitCode = 1;
+      return;
+    }
+    let failureDefaults = { code: "CONFIG_LOAD_FAILED", phase: "config-load" };
+    try {
+      if (!options.json) logInfo(`Validating ${pathLabel(options.config)}.`);
+      const loaded = await withTileflowConfigSecretsHidden(
+        () => loadTileflowConfigWithInputs4(options.config)
+      );
+      const project = loaded.project;
+      const baseDirectory = dirname12(loaded.configFile);
+      failureDefaults = { code: "CONFIG_INVALID", phase: "config-validation" };
+      assertValidTileflowConfig3(project);
+      const mapNames = getTileflowMapNames5(project).sort();
+      failureDefaults = { code: "ICON_COMPILATION_FAILED", phase: "icon-compilation" };
+      const compiledIcons = await compileTileflowIconPackages3(project, {
+        baseDirectory,
+        cwd: process.cwd(),
+        icons: resolveIconOptions(options),
+        target: options.target
+      });
+      const mapAssets = createCompiledMapAssets(
+        compiledIcons,
+        (binding) => options.target === "hosted" ? `${normalizeUrl(options.apiBaseUrl)}/sprites/preflight/${binding.packageHash}/sprite` : `/tileflow/icons/${binding.mapName}/sprite`
+      );
+      failureDefaults = { code: "STYLE_INVALID", phase: "style-validation" };
+      const compiledStyles = createTileflowStyles2(project, {
+        apiBaseUrl: options.apiBaseUrl,
+        mapAssets
+      });
+      failureDefaults = { code: "TF_LOCAL_TILESET_INVALID", phase: "local-tileset-resolution" };
+      const localTilesets = await prepareTileflowLocalTilesets2(project, compiledStyles, {
+        assetBaseUrl: "/tileflow",
+        baseDirectory,
+        cwd: process.cwd()
+      });
+      failureDefaults = { code: "FONT_COMPILATION_FAILED", phase: "font-compilation" };
+      const { styles } = await prepareTileflowStyleFonts2(project, localTilesets.styles, {
+        assetBaseUrl: "/tileflow",
+        baseDirectory,
+        cwd: process.cwd(),
+        target: options.target
+      });
+      failureDefaults = { code: "HOSTED_INCOMPATIBLE", phase: "hosted-validation" };
+      const hostedIssues = options.target === "hosted" ? inspectTileflowHostedCompatibility(project, styles) : [];
+      if (hostedIssues.length > 0) {
+        if (!options.json) {
+          printHostedCompatibilityIssues(hostedIssues);
+          return;
+        }
+        throw Object.assign(new Error("Tileflow config is not Hosted-compatible."), {
           code: "HOSTED_INCOMPATIBLE",
-          message: issue.message,
-          path: issue.path,
+          issues: hostedIssues.map((issue) => ({
+            code: "HOSTED_INCOMPATIBLE",
+            message: issue.message,
+            path: issue.path,
+            phase: "hosted-validation"
+          })),
           phase: "hosted-validation"
-        })),
-        phase: "hosted-validation"
-      });
-    }
-    const themeWarnings = mapNames.flatMap(
-      (mapName) => auditTileflowMapThemeValues(project.maps[mapName]).filter(
-        ({ severity }) => severity === "warning"
-      )
-    );
-    const diagnostics = themeWarnings.length === 0 ? [] : createTileflowStructuredDiagnostics2({ diagnostics: themeWarnings }, process.cwd(), {
-      code: "VALIDATION_WARNING",
-      phase: "theme-audit"
-    });
-    const checks = [
-      "Config schema",
-      "Icon asset closure",
-      "Text provider closure",
-      "Named map styles",
-      "MapLibre style semantics",
-      ...options.target === "hosted" ? ["Hosted compatibility"] : []
-    ];
-    if (options.json) {
-      const summary = createTileflowCommandSummary2({
-        code: "VALIDATION_OK",
-        command: "validate",
-        message: `Tileflow config is valid (${plural(mapNames.length, "map")}).`,
-        ok: true,
-        path: "",
-        phase: "validation",
-        severity: "info",
-        suggestion: "No changes are required."
+        });
+      }
+      const themeWarnings = mapNames.flatMap(
+        (mapName) => auditTileflowMapThemeValues2(project.maps[mapName]).filter(
+          ({ severity }) => severity === "warning"
+        )
+      );
+      const diagnostics = themeWarnings.length === 0 ? [] : createTileflowStructuredDiagnostics3({ diagnostics: themeWarnings }, process.cwd(), {
+        code: "VALIDATION_WARNING",
+        phase: "theme-audit"
       });
-      process.stdout.write(
-        serializeTileflowCommandDocument4({
-          ...summary,
-          target: options.target,
-          maps: mapNames,
-          checks,
-          diagnostics
-        })
+      const sharedIconMaps = Object.keys(compiledIcons.compositions).sort();
+      const checks = [
+        "Config schema",
+        "Icon asset closure",
+        ...sharedIconMaps.length > 0 ? ["Locked Icon Set composition"] : [],
+        "Text provider closure",
+        "Named map styles",
+        "MapLibre style semantics",
+        ...options.target === "hosted" ? ["Hosted compatibility"] : []
+      ];
+      if (options.json) {
+        const summary = createTileflowCommandSummary3({
+          code: "VALIDATION_OK",
+          command: "validate",
+          message: `Tileflow config is valid (${plural(mapNames.length, "map")}).`,
+          ok: true,
+          path: "",
+          phase: "validation",
+          severity: "info",
+          suggestion: "No changes are required."
+        });
+        process.stdout.write(
+          serializeTileflowCommandDocument5({
+            ...summary,
+            target: options.target,
+            maps: mapNames,
+            checks,
+            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 failure2 = createTileflowCommandFailureDocument5(
+        "validate",
+        error,
+        process.cwd(),
+        failureDefaults
       );
-      return;
-    }
-    logSuccess(`Config is valid (${plural(mapNames.length, "map")}).`);
-    printChecks(checks);
-    for (const diagnostic of diagnostics) {
-      logWarning(`${diagnostic.path || "(root)"}: ${diagnostic.message}`);
+      process.stderr.write(serializeTileflowCommandDocument5(failure2));
+      process.exitCode = 1;
     }
-  } catch (error) {
-    if (!options.json) throw error;
-    const failure = createTileflowCommandFailureDocument4(
-      "validate",
-      error,
-      process.cwd(),
-      failureDefaults
-    );
-    process.stderr.write(serializeTileflowCommandDocument4(failure));
-    process.exitCode = 1;
   }
-});
-program.command("build").description("Generate static Tileflow styles").option("-c, --config <path>", "config path", defaultConfigPath).option("-o, --out <path>", "output directory", "dist/tileflow").option(
+);
+program.command("build").description("Generate static Tileflow styles").option("-c, --config <path>", "config path", defaultConfigPath).option("-o, --out <path>", "output directory", "dist/tileflow").option("--renderer <renderer>", "artifact renderer: web or native", "web").option("--target <target>", "artifact target: local or hosted (build supports local)", "local").option("--json", "print deterministic schema-version-1 JSON").option(
   "--api-base-url <url>",
   "Tileflow API base URL used to resolve official map assets",
   process.env.TILEFLOW_API_URL ?? defaultApiUrl
-).action(async (options) => {
-  logInfo(`Building ${pathLabel(options.config)}.`);
-  await withTileflowConfigSecretsHidden(
-    () => writeTileflowBuildArtifacts({
-      config: options.config,
-      outDir: options.out,
-      styleBaseUrl: ".",
-      apiBaseUrl: options.apiBaseUrl
-    })
-  );
-  logSuccess("Built Tileflow artifacts.");
-  printKeyValue("Output", pathLabel(resolve7(process.cwd(), options.out)));
-});
-program.command("preview").alias("dev").description("Run a local map preview").option("-c, --config <path>", "config path", defaultConfigPath).option("--against-config <path>", "second config for the comparison workbench").option("--against-map <name>", "map on the right; defaults to --map").option("--against-scene <name>", "committed standalone scene on the right").option("--against-theme <name>", "concrete theme on the right; defaults to --theme").option("--host <host>", "bind host: an explicit IP address or localhost", defaultTileflowDevHost).option("--map <name>", "preview one configured map").option("--theme <name>", "preview one concrete theme; defaults to the map default").option("-p, --port <port>", "preview port", "3333").option("--scene <name>", "preview one committed standalone map scene").option(
+).option("--cache-dir <path>", "verified Icon Set artifact cache root").option("--offline", "fail a locked Icon Set cache miss instead of hydrating it").action(
+  async (options) => {
+    const icons = resolveIconOptions(options);
+    if (options.renderer !== "web" || options.target !== "local" || options.json) {
+      await runRendererArtifactCommand("build", { ...options, icons });
+      return;
+    }
+    logInfo(`Building ${pathLabel(options.config)}.`);
+    await withTileflowConfigSecretsHidden(
+      () => writeTileflowBuildArtifacts({
+        config: options.config,
+        outDir: options.out,
+        styleBaseUrl: ".",
+        apiBaseUrl: options.apiBaseUrl,
+        ...icons ? { icons } : {}
+      })
+    );
+    logSuccess("Built Tileflow artifacts.");
+    printKeyValue("Output", pathLabel(resolve8(process.cwd(), options.out)));
+  }
+);
+program.command("preview").alias("dev").description("Run a local map preview").option("-c, --config <path>", "config path", defaultConfigPath).option("--against-config <path>", "second config for the comparison workbench").option("--against-map <name>", "map on the right; defaults to --map").option("--against-scene <name>", "committed standalone scene on the right").option("--against-theme <name>", "concrete theme on the right; defaults to --theme").option("--host <host>", "bind host: an explicit IP address or localhost", defaultTileflowDevHost).option("--map <name>", "preview one configured map").option("--theme <name>", "preview one concrete theme; defaults to the map default").option("--renderer <renderer>", "artifact renderer: web or native", "web").option("-p, --port <port>", "preview port", "3333").option("--scene <name>", "preview one committed standalone map scene").option(
   "--api-base-url <url>",
   "Tileflow API base URL used to resolve official map assets",
   process.env.TILEFLOW_API_URL ?? defaultApiUrl
-).option("--json", "emit schema-version-1 NDJSON lifecycle events").action(
+).option("--cache-dir <path>", "verified Icon Set artifact cache root").option("--offline", "fail a locked Icon Set cache miss instead of hydrating it").option("--json", "emit schema-version-1 NDJSON lifecycle events").action(
   async (options) => {
+    let renderer;
+    try {
+      renderer = resolveTileflowRenderer2(options.renderer);
+    } catch (error) {
+      const diagnostics = createTileflowArtifactDiagnostics3(error, process.cwd());
+      if (options.json) {
+        const first = diagnostics[0];
+        process.stdout.write(
+          `${JSON.stringify({
+            schemaVersion: 1,
+            command: "dev",
+            event: "error",
+            code: first?.code ?? "NATIVE_RENDERER_UNSUPPORTED",
+            phase: first?.phase ?? "command-validation",
+            diagnostics
+          })}
+`
+        );
+      } else {
+        logError(diagnostics[0]?.message ?? "Unsupported artifact renderer.");
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const comparisonRequested = options.againstConfig !== void 0 || options.againstMap !== void 0 || options.againstScene !== void 0 || options.againstTheme !== void 0;
+    if (renderer === "native" && (options.scene !== void 0 || comparisonRequested)) {
+      if (options.json) {
+        process.stdout.write(
+          `${JSON.stringify({
+            schemaVersion: 1,
+            command: "dev",
+            event: "error",
+            code: "NATIVE_RENDERER_UNSUPPORTED",
+            phase: "command-validation",
+            renderer: "native",
+            profile: tileflowNativePreviewProfile
+          })}
+`
+        );
+      } else {
+        logError(
+          "Native preview serves assets only; scenes and comparison workbench options are unavailable."
+        );
+      }
+      process.exitCode = 1;
+      return;
+    }
     const port = parsePort(options.port);
     if (port === null) {
       logError(`Invalid port: ${options.port}`);
@@ -7158,28 +8542,45 @@ program.command("preview").alias("dev").description("Run a local map preview").o
       process.exitCode = 1;
       return;
     }
-    const comparisonRequested = options.againstConfig !== void 0 || options.againstMap !== void 0 || options.againstScene !== void 0 || options.againstTheme !== void 0;
     if (comparisonRequested) {
       await runTileflowComparisonPreview(options, { host, port });
       return;
     }
     await withTileflowConfigSecretsHidden(async () => {
       const origin = tileflowDevOrigin(host, port);
+      const manifestUrl = renderer === "native" ? getTileflowNativePreviewManifestUrl(origin) : void 0;
+      const nativeLifecycleFields = manifestUrl ? {
+        renderer: "native",
+        profile: tileflowNativePreviewProfile,
+        manifest: manifestUrl,
+        assetsOnly: true
+      } : {};
+      const icons = resolveIconOptions(options);
       const session = await createTileflowArtifactSession3({
         assetBaseUrl: origin,
         apiBaseUrl: options.apiBaseUrl,
         config: options.config,
+        ...icons ? { icons } : {},
+        ...renderer === "native" ? { renderer: "native" } : {},
         styleBaseUrl: origin,
         watch: true
       });
       const initialArtifacts = session.getLastGoodArtifacts();
+      let nativeSelection;
       try {
         if (initialArtifacts) {
-          resolveTileflowPreview(initialArtifacts.project, {
-            map: options.map,
-            scene: options.scene,
-            theme: options.theme
-          });
+          if (renderer === "native") {
+            nativeSelection = resolveTileflowNativePreviewSelection(initialArtifacts.manifest, {
+              map: options.map,
+              theme: options.theme
+            });
+          } else {
+            resolveTileflowPreview(initialArtifacts.project, {
+              map: options.map,
+              scene: options.scene,
+              theme: options.theme
+            });
+          }
         }
       } catch (error) {
         await session.close();
@@ -7187,7 +8588,12 @@ program.command("preview").alias("dev").description("Run a local map preview").o
         process.exitCode = 1;
         return;
       }
-      const fetch2 = createTileflowDevRequestHandler({
+      const fetch2 = renderer === "native" ? createTileflowNativePreviewRequestHandler({
+        config: options.config,
+        apiBaseUrl: options.apiBaseUrl,
+        onError: printTileflowPreviewError,
+        session
+      }) : createTileflowDevRequestHandler2({
         config: options.config,
         apiBaseUrl: options.apiBaseUrl,
         map: options.map,
@@ -7212,7 +8618,8 @@ program.command("preview").alias("dev").description("Run a local map preview").o
               ..."lastGoodGeneration" in state && state.lastGoodGeneration !== void 0 ? { lastGoodGeneration: state.lastGoodGeneration } : {},
               ...firstDiagnostic?.code ? { code: firstDiagnostic.code } : {},
               ...firstDiagnostic?.phase ? { phase: firstDiagnostic.phase } : {},
-              ...state.status === "invalid" ? { diagnostics: state.diagnostics } : {}
+              ...state.status === "invalid" ? { diagnostics: state.diagnostics } : {},
+              ...nativeLifecycleFields
             })}
 `
           );
@@ -7221,14 +8628,16 @@ program.command("preview").alias("dev").description("Run a local map preview").o
         if (state.status === "invalid") {
           console.error(
             [
-              `Tileflow generation ${state.generation} is invalid; preserving the last valid preview.`,
+              renderer === "native" ? `Tileflow generation ${state.generation} is invalid; preserving the last valid native artifact family.` : `Tileflow generation ${state.generation} is invalid; preserving the last valid preview.`,
               ...state.diagnostics.map(
                 (diagnostic) => `- ${diagnostic.path || "(root)"}: ${diagnostic.message}`
               )
             ].join("\n")
           );
         } else if (recovered) {
-          logSuccess(`Tileflow preview recovered at generation ${state.generation}.`);
+          logSuccess(
+            renderer === "native" ? `Tileflow native artifact preview recovered at generation ${state.generation}.` : `Tileflow preview recovered at generation ${state.generation}.`
+          );
         }
       };
       emitState(session.getState());
@@ -7241,13 +8650,26 @@ program.command("preview").alias("dev").description("Run a local map preview").o
           server = createdServer;
         });
         if (!options.json) {
-          logSuccess("Tileflow preview is running and watching for changes.");
-          printKeyValue("Local", link(origin));
-          printKeyValue("Config", pathLabel(options.config));
-          if (options.map) printKeyValue("Map", options.map);
-          if (options.theme) printKeyValue("Theme", options.theme);
-          if (options.scene) printKeyValue("Scene", options.scene);
-          logMuted("Press Ctrl+C to stop.");
+          if (renderer === "native") {
+            logSuccess("Tileflow native artifact preview is running and watching for changes.");
+            printKeyValue("Manifest", link(manifestUrl));
+            printKeyValue("Profile", tileflowNativePreviewProfile);
+            printKeyValue("Endpoint", "assets-only");
+            printKeyValue("Config", pathLabel(options.config));
+            if (nativeSelection) {
+              printKeyValue("Map", nativeSelection.mapName);
+              printKeyValue("Theme", nativeSelection.themeName);
+            }
+            logMuted("Metro remains the JavaScript development server. Press Ctrl+C to stop.");
+          } else {
+            logSuccess("Tileflow preview is running and watching for changes.");
+            printKeyValue("Local", link(origin));
+            printKeyValue("Config", pathLabel(options.config));
+            if (options.map) printKeyValue("Map", options.map);
+            if (options.theme) printKeyValue("Theme", options.theme);
+            if (options.scene) printKeyValue("Scene", options.scene);
+            logMuted("Press Ctrl+C to stop.");
+          }
         }
         await waitForTerminationSignal(server);
       } finally {
@@ -7257,7 +8679,13 @@ program.command("preview").alias("dev").description("Run a local map preview").o
         await session.close();
         if (options.json) {
           process.stdout.write(
-            `${JSON.stringify({ schemaVersion: 1, command: "dev", event: "stopped", generation })}
+            `${JSON.stringify({
+              schemaVersion: 1,
+              command: "dev",
+              event: "stopped",
+              generation,
+              ...nativeLifecycleFields
+            })}
 `
           );
         }
@@ -7265,10 +8693,10 @@ 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("--map-id <id>", "managed Map destination").option("--map <name>", "configured map to connect when the repository 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("--with-native", "publish web and native-v1 together for the selected managed Map").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(
+).option("--cache-dir <path>", "verified Icon Set artifact cache root").option("--offline", "fail a locked Icon Set cache miss instead of hydrating it").action(
   async (options) => {
     const source = resolveDeploySource(process.env);
     const resolveApi = (selectedMap) => requireApiOptions(options, {
@@ -7286,19 +8714,39 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
         options.apiUrl ?? defaultApiUrl,
         ...options.overwriteSelfHostedManifest ? ["--overwrite-self-hosted-manifest"] : [],
         ...options.mapId ? ["--map-id", options.mapId] : [],
-        ...options.map && selectedMap ? ["--map", selectedMap] : []
+        ...options.map && selectedMap ? ["--map", selectedMap] : [],
+        ...options.withNative ? ["--with-native"] : []
       ])
     });
     const apiUrl = normalizeApiOrigin(options.apiUrl ?? defaultApiUrl);
     delete process.env.TILEFLOW_API_KEY;
+    if (options.withNative) {
+      const result = await runHostedNativeDeploy(
+        { ...options, apiUrl },
+        {
+          source,
+          resolveApi,
+          loadManifest: loadExistingDeployManifest,
+          writeManifest: writeDeployManifest
+        }
+      );
+      if (result) {
+        logSuccess(
+          `${result.changed ? "Published" : "Unchanged"} ${pc6.bold(result.mapName)} web + native-v1 (v${result.version}).`
+        );
+        printKeyValue("Manifest", pathLabel(result.manifestPath));
+        printKeyValue("Native", link(result.nativeManifestUrl));
+      }
+      return;
+    }
     logInfo(`Deploying ${pathLabel(options.config)}.`);
     const loaded = await withTileflowConfigSecretsHidden(
-      () => loadTileflowConfigWithInputs3(options.config)
+      () => loadTileflowConfigWithInputs4(options.config)
     );
     const project = loaded.project;
-    const baseDirectory = dirname10(loaded.configFile);
-    assertValidTileflowConfig2(project);
-    const configuredMapNames = getTileflowMapNames3(project);
+    const baseDirectory = dirname12(loaded.configFile);
+    assertValidTileflowConfig3(project);
+    const configuredMapNames = getTileflowMapNames5(project);
     const mapNames = selectManagedDeployMaps(configuredMapNames, options);
     if (!mapNames) return;
     if (!validateDeployTarget(options)) return;
@@ -7309,9 +8757,10 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
         mapNames.map((mapName) => [mapName, project.maps[mapName]])
       )
     };
-    const compiledIcons = await compileTileflowIconPackages2(deploymentProject, {
+    const compiledIcons = await compileTileflowIconPackages3(deploymentProject, {
       baseDirectory,
       cwd: process.cwd(),
+      icons: resolveIconOptions(options),
       target: "hosted"
     });
     const bindingsByMap = new Map(
@@ -7324,16 +8773,16 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
       compiledIcons,
       (binding) => `${apiUrl}/sprites/preflight/${binding.packageHash}/sprite`
     );
-    const compiledPreflightStyles = createTileflowStyles(deploymentProject, {
+    const compiledPreflightStyles = createTileflowStyles2(deploymentProject, {
       apiBaseUrl: apiUrl,
       mapAssets: preflightMapAssets
     });
-    const preflightLocalTilesets = await prepareTileflowLocalTilesets(
+    const preflightLocalTilesets = await prepareTileflowLocalTilesets2(
       deploymentProject,
       compiledPreflightStyles,
       { assetBaseUrl: apiUrl, baseDirectory, cwd: process.cwd() }
     );
-    const preflightFonts = await prepareTileflowStyleFonts(
+    const preflightFonts = await prepareTileflowStyleFonts2(
       deploymentProject,
       preflightLocalTilesets.styles,
       {
@@ -7392,7 +8841,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 ${pc3.bold(binding?.label ?? "Icons")} (${plural(iconPackage.manifest.iconNames.length, "icon")}, ${formatBytes3(totalBytes)}, ${iconPackage.contentHash.slice(0, 12)}).`
+        `${action} icon package ${pc6.bold(binding?.label ?? "Icons")} (${plural(iconPackage.manifest.iconNames.length, "icon")}, ${formatBytes3(totalBytes)}, ${iconPackage.contentHash.slice(0, 12)}).`
       );
       hostedSpriteByPackageHash.set(iconPackage.contentHash, uploaded.value.spriteUrl);
     }
@@ -7401,16 +8850,16 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
       if (!sprite) throw new Error(`Missing hosted sprite URL for map ${binding.mapName}`);
       return sprite;
     });
-    const compiledHostedStyles = createTileflowStyles(deploymentProject, {
+    const compiledHostedStyles = createTileflowStyles2(deploymentProject, {
       apiBaseUrl: api.apiUrl,
       mapAssets: hostedMapAssets
     });
-    const hostedLocalTilesets = await prepareTileflowLocalTilesets(
+    const hostedLocalTilesets = await prepareTileflowLocalTilesets2(
       deploymentProject,
       compiledHostedStyles,
       { assetBaseUrl: api.apiUrl, baseDirectory, cwd: process.cwd() }
     );
-    const hostedFonts = await prepareTileflowStyleFonts(
+    const hostedFonts = await prepareTileflowStyleFonts2(
       deploymentProject,
       hostedLocalTilesets.styles,
       {
@@ -7475,7 +8924,7 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
     const styles = Object.fromEntries(
       Object.entries(hostedThemeFamilies).map(([mapName, family]) => [mapName, family.styles])
     );
-    const buildManifest = await createTileflowMapBuildManifest(
+    const buildManifest = await createTileflowMapBuildManifest2(
       Object.fromEntries(
         mapNames.map((mapName) => {
           const map = deploymentProject.maps[mapName];
@@ -7498,14 +8947,15 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
               map,
               sourceAssets: {
                 fonts: hostedFonts.sourceIdentities[mapName] ?? [],
-                icons: compiledIcons.sourceIdentities[mapName] ?? []
+                icons: compiledIcons.sourceIdentities[mapName] ?? [],
+                ...compiledIcons.compositions[mapName] ? { iconComposition: compiledIcons.compositions[mapName] } : {}
               },
               styles: styles[mapName]
             }
           ];
         })
       ),
-      { provenance: await createTileflowBuildProvenance(process.cwd()) }
+      { provenance: await createTileflowBuildProvenance2(process.cwd()) }
     );
     const deployments = mapNames.map((mapName) => {
       const iconBinding = bindingsByMap.get(mapName);
@@ -7513,6 +8963,7 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
       const fontBundle = hostedFonts.bundles[mapName];
       return {
         iconBinding,
+        iconComposition: compiledIcons.compositions[mapName],
         iconPackage,
         fontBundle,
         mapName,
@@ -7531,14 +8982,20 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
         buildManifest: buildManifest2,
         fontBundle,
         iconBinding,
+        iconComposition,
         iconPackage,
         mapName,
         teamSources,
         styles: themeStyles
       } = deployment;
+      if (iconComposition && iconComposition.packageHash !== iconPackage?.contentHash) {
+        logError(`Icon composition does not match the effective package for ${mapName}.`);
+        process.exitCode = 1;
+        return;
+      }
       const themeNames = Object.keys(themeStyles).sort();
       logInfo(
-        `Deploying compiled map ${pc3.bold(mapName)} (${plural(themeNames.length, "theme")}).`
+        `Deploying compiled map ${pc6.bold(mapName)} (${plural(themeNames.length, "theme")}).`
       );
       const response = await publishHostedStyle(
         api,
@@ -7560,6 +9017,7 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
               label: iconBinding.label
             }
           } : {},
+          ...iconComposition ? { iconComposition } : {},
           ...fontBundle ? { fontBundle: { contentHash: fontBundle.contentHash } } : {},
           source
         },
@@ -7588,7 +9046,7 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
         process.exitCode = 1;
         return;
       }
-      const resolvedMap = parseResolvedTileflowMap3(deploymentProject.maps[mapName]);
+      const resolvedMap = parseResolvedTileflowMap5(deploymentProject.maps[mapName]);
       const mapBuild = buildManifest2.maps[mapName];
       deployedMaps[mapName] = {
         defaultTheme: resolvedMap.defaultTheme,
@@ -7598,7 +9056,7 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
         themes: Object.fromEntries(
           themeNames.map((themeName) => {
             const deployedTheme = body.themes[themeName];
-            const fontFaces = getTileflowStyleFontFaces(themeStyles[themeName]);
+            const fontFaces = getTileflowStyleFontFaces2(themeStyles[themeName]);
             return [
               themeName,
               {
@@ -7617,9 +9075,9 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
       };
       const versionLabel = Number.isInteger(body.version) ? ` (v${body.version})` : "";
       if (body.changed === false) {
-        logSuccess(`Unchanged ${pc3.bold(mapName)}${versionLabel}.`);
+        logSuccess(`Unchanged ${pc6.bold(mapName)}${versionLabel}.`);
       } else {
-        logSuccess(`Published ${pc3.bold(mapName)}${versionLabel}.`);
+        logSuccess(`Published ${pc6.bold(mapName)}${versionLabel}.`);
       }
     }
     const manifestPath = await writeDeployManifest(options.manifest, {
@@ -7693,6 +9151,7 @@ program.command("status").description("Show deployed compiled styles").option("-
   printMapStatus(status, api.apiUrl);
 });
 var iconsCommand = program.command("icons").description("Inspect managed Tileflow icons");
+registerIconLockCommands(program, { defaultApiUrl, defaultConfigPath, loadAuthConfig });
 registerIconListCommand(iconsCommand, { defaultConfigPath });
 registerIconDiffCommand(iconsCommand, {
   defaultApiUrl,
@@ -7734,10 +9193,15 @@ registerProjectCommands(program, {
   defaultApiUrl,
   loadAuthConfig
 });
-program.parseAsync().catch((error) => {
-  printCliError(error);
-  process.exitCode = 1;
-});
+if (isRootCliVersionRequest(process.argv.slice(2))) {
+  process.stdout.write(`${packageJson.version}
+`);
+} else {
+  program.parseAsync().catch((error) => {
+    printCliError(error);
+    process.exitCode = 1;
+  });
+}
 async function runTileflowComparisonPreview(options, address) {
   await withTileflowConfigSecretsHidden(async () => {
     const origin = tileflowDevOrigin(address.host, address.port);
@@ -7782,10 +9246,12 @@ async function runTileflowComparisonPreview(options, address) {
     try {
       const leftCaptureConfig = comparisonCaptureConfigArgument(options.config);
       const rightCaptureConfig = comparisonCaptureConfigArgument(rightConfig);
+      const comparisonIcons = resolveIconOptions(options);
       leftSession = await createTileflowArtifactSession3({
         apiBaseUrl: options.apiBaseUrl,
         assetBaseUrl: `${origin}${leftBasePath}`,
         config: options.config,
+        ...comparisonIcons ? { icons: comparisonIcons } : {},
         inspection: true,
         styleBaseUrl: `${origin}${leftBasePath}`,
         watch: true
@@ -7794,6 +9260,7 @@ async function runTileflowComparisonPreview(options, address) {
         apiBaseUrl: options.apiBaseUrl,
         assetBaseUrl: `${origin}${rightBasePath}`,
         config: rightConfig,
+        ...comparisonIcons ? { icons: comparisonIcons } : {},
         inspection: true,
         styleBaseUrl: `${origin}${rightBasePath}`,
         watch: true
@@ -7838,7 +9305,7 @@ async function runTileflowComparisonPreview(options, address) {
         scene: rightScene,
         theme: rightTheme
       });
-      const leftHandler = createTileflowDevRequestHandler({
+      const leftHandler = createTileflowDevRequestHandler2({
         apiBaseUrl: options.apiBaseUrl,
         basePath: leftBasePath,
         config: options.config,
@@ -7848,7 +9315,7 @@ async function runTileflowComparisonPreview(options, address) {
         session: leftSession,
         theme: options.theme
       });
-      const rightHandler = createTileflowDevRequestHandler({
+      const rightHandler = createTileflowDevRequestHandler2({
         apiBaseUrl: options.apiBaseUrl,
         basePath: rightBasePath,
         config: rightConfig,
@@ -7919,13 +9386,13 @@ async function runTileflowComparisonPreview(options, address) {
 }
 function comparisonCaptureConfigArgument(configPath) {
   const cwd = realpathSync(process.cwd());
-  const requestedConfigPath = resolve7(process.cwd(), configPath);
-  const defaultRequestedPath = resolve7(process.cwd(), defaultConfigPath);
+  const requestedConfigPath = resolve8(process.cwd(), configPath);
+  const defaultRequestedPath = resolve8(process.cwd(), defaultConfigPath);
   const absoluteConfigPath = existsSync(requestedConfigPath) ? realpathSync(requestedConfigPath) : requestedConfigPath;
   const absoluteDefaultPath = existsSync(defaultRequestedPath) ? realpathSync(defaultRequestedPath) : defaultRequestedPath;
   if (absoluteConfigPath === absoluteDefaultPath) return void 0;
   const relativeConfigPath = relative5(cwd, absoluteConfigPath);
-  if (relativeConfigPath === "" || relativeConfigPath === ".." || relativeConfigPath.startsWith(`..${sep5}`) || isAbsolute4(relativeConfigPath)) {
+  if (relativeConfigPath === "" || relativeConfigPath === ".." || relativeConfigPath.startsWith(`..${sep5}`) || isAbsolute5(relativeConfigPath)) {
     throw new Error(
       "Comparison configs must be inside the current working directory so Copy command can remain reproducible."
     );
@@ -7964,7 +9431,7 @@ async function loginWithDeviceFlow(options) {
     codeChallenge,
     deviceName: hostname()
   });
-  printKeyValue("Code", pc3.bold(authorization.userCode));
+  printKeyValue("Code", pc6.bold(authorization.userCode));
   printKeyValue("URL", link(authorization.verificationUriComplete));
   if (options.noBrowser) {
     logMuted("Open the URL above to continue.");
@@ -7974,7 +9441,7 @@ async function loginWithDeviceFlow(options) {
       output: process.stdout
     });
     try {
-      await readline.question(`${pc3.cyan("?")} Press Enter to open Tileflow Dashboard...`);
+      await readline.question(`${pc6.cyan("?")} Press Enter to open Tileflow Dashboard...`);
       openBrowser(authorization.verificationUriComplete);
     } finally {
       readline.close();
@@ -8025,9 +9492,9 @@ function openBrowser(url, errorsToStderr = false) {
   });
 }
 async function writeDeployManifest(manifestPath, manifest) {
-  const outputPath = resolve7(process.cwd(), manifestPath);
+  const outputPath = resolve8(process.cwd(), manifestPath);
   await writeAtomicFile({
-    boundaryPath: dirname10(outputPath),
+    boundaryPath: dirname12(outputPath),
     force: true,
     label: "Deploy manifest",
     managed: true,
@@ -8037,11 +9504,24 @@ async function writeDeployManifest(manifestPath, manifest) {
   });
   return manifestPath;
 }
+function resolveIconOptions(options) {
+  const icons = {
+    ...options.cacheDir ? { cacheRoot: options.cacheDir } : {},
+    ...options.offline ? { offline: true } : {}
+  };
+  return Object.keys(icons).length > 0 ? icons : void 0;
+}
 function createCompiledMapAssets(compiled, resolveSprite) {
   return Object.fromEntries(
     compiled.bindings.map((binding) => [
       binding.mapName,
-      { icons: { ids: binding.iconIds, sprite: resolveSprite(binding) } }
+      {
+        icons: {
+          ids: binding.iconIds,
+          sprite: resolveSprite(binding),
+          ...binding.appearances ? { appearances: binding.appearances } : {}
+        }
+      }
     ])
   );
 }
@@ -8098,7 +9578,7 @@ function validateDeployManifestMapNames(mapNames) {
 async function loadExistingDeployManifest(manifestPath, options) {
   let source;
   try {
-    source = await readFile7(resolve7(process.cwd(), manifestPath), "utf8");
+    source = await readFile7(resolve8(process.cwd(), manifestPath), "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw new Error("Existing Tileflow manifest could not be read.");
@@ -8112,7 +9592,7 @@ async function loadExistingDeployManifest(manifestPath, options) {
   }
   let manifest;
   try {
-    manifest = parseTileflowRuntimeManifest(value);
+    manifest = parseTileflowRuntimeManifest2(value);
   } catch {
     throw new Error(
       "Existing Tileflow manifest does not match the strict theme manifest contract."
@@ -8190,7 +9670,7 @@ async function requireApiOptions(options, behavior = {}) {
     if (!behavior.silent) {
       logError("CI requires an explicit Tileflow credential with access to the target Map.");
       printNextSteps([
-        `Set ${pc3.cyan("TILEFLOW_API_KEY")} from the CI secret store.`,
+        `Set ${pc6.cyan("TILEFLOW_API_KEY")} from the CI secret store.`,
         "The saved personal account session is never used in CI."
       ]);
     }
@@ -8270,7 +9750,7 @@ function printTileflowPreviewError(error) {
     printValidationErrors(error.issues);
     return;
   }
-  if (error instanceof TileflowValidationError4) {
+  if (error instanceof TileflowValidationError5) {
     printValidationErrors(error.messages);
     return;
   }
@@ -8282,7 +9762,7 @@ function printCliError(error) {
     printValidationErrors(error.issues);
     return;
   }
-  if (error instanceof TileflowValidationError4) {
+  if (error instanceof TileflowValidationError5) {
     printValidationErrors(error.messages);
     return;
   }
@@ -8296,17 +9776,17 @@ function printCliError(error) {
   }
   const message = error instanceof Error ? error.message : "Command failed.";
   if (message.includes("Cannot find module '@tileflow/core'")) {
-    logError(`Cannot load ${pc3.cyan("@tileflow/core")} from this project.`);
+    logError(`Cannot load ${pc6.cyan("@tileflow/core")} from this project.`);
     printNextSteps([
-      `Install ${pc3.cyan("@tileflow/core")} in this project.`,
+      `Install ${pc6.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 ${pc3.cyan("@tileflow/maps")} from this project.`);
+    logError(`Cannot load ${pc6.cyan("@tileflow/maps")} from this project.`);
     printNextSteps([
-      `Install ${pc3.cyan("@tileflow/maps")} in this project.`,
+      `Install ${pc6.cyan("@tileflow/maps")} in this project.`,
       `Run the command again from the project root.`
     ]);
     return;
@@ -8317,51 +9797,51 @@ function printCliError(error) {
   }
 }
 function logSuccess(message) {
-  console.log(`${pc3.green("\u2713")} ${message}`);
+  console.log(`${pc6.green("\u2713")} ${message}`);
 }
 function logError(message) {
-  console.log(`${pc3.red("\u2715")} ${message}`);
+  console.log(`${pc6.red("\u2715")} ${message}`);
 }
 function logWarning(message) {
-  console.log(`${pc3.yellow("!")} ${message}`);
+  console.log(`${pc6.yellow("!")} ${message}`);
 }
 function logInfo(message) {
-  console.log(`${pc3.cyan("i")} ${message}`);
+  console.log(`${pc6.cyan("i")} ${message}`);
 }
 function logMuted(message) {
-  console.log(pc3.gray(message));
+  console.log(pc6.gray(message));
 }
 function printTitle(title, subtitle) {
-  console.log(pc3.bold(title));
+  console.log(pc6.bold(title));
   if (subtitle) {
-    console.log(pc3.gray(subtitle));
+    console.log(pc6.gray(subtitle));
   }
 }
 function printKeyValue(label, value) {
-  console.log(`${pc3.gray(`${label}:`.padEnd(13))} ${value}`);
+  console.log(`${pc6.gray(`${label}:`.padEnd(13))} ${value}`);
 }
 function printChecks(items) {
   for (const item of items) {
-    console.log(`  ${pc3.green("\u2713")} ${item}`);
+    console.log(`  ${pc6.green("\u2713")} ${item}`);
   }
 }
 function printNextSteps(steps) {
   if (steps.length === 0) return;
   console.log(`
-${pc3.bold("Next steps")}`);
+${pc6.bold("Next steps")}`);
   for (const step of steps) {
-    console.log(`  ${pc3.cyan("\u2022")} ${step}`);
+    console.log(`  ${pc6.cyan("\u2022")} ${step}`);
   }
 }
 function printValidationErrors(messages) {
   logError("Tileflow config has errors.");
   for (const message of messages) {
-    const path = message.path ? pc3.cyan(message.path) : pc3.cyan("(root)");
-    console.log(`  ${pc3.red("\u2715")} ${path} ${pc3.gray("-")} ${message.message}`);
+    const path = message.path ? pc6.cyan(message.path) : pc6.cyan("(root)");
+    console.log(`  ${pc6.red("\u2715")} ${path} ${pc6.gray("-")} ${message.message}`);
   }
 }
 function printAccountDetails(session) {
-  printKeyValue("Account", pc3.bold(session.account.name));
+  printKeyValue("Account", pc6.bold(session.account.name));
   printKeyValue("Email", session.account.email);
   printKeyValue("API", link(session.apiOrigin));
   printKeyValue("Expires", formatDate(session.expiresAt));
@@ -8390,11 +9870,11 @@ function printDeployedMaps(maps) {
   const entries = Object.entries(maps);
   if (entries.length === 0) return;
   console.log(`
-${pc3.bold("Maps")}`);
+${pc6.bold("Maps")}`);
   for (const [name, map] of entries) {
     for (const [themeName, theme] of Object.entries(map.themes)) {
       const label = `${name}/${themeName}`;
-      console.log(`  ${pc3.green("\u2713")} ${label.padEnd(24)} ${link(theme.styleUrl)}`);
+      console.log(`  ${pc6.green("\u2713")} ${label.padEnd(24)} ${link(theme.styleUrl)}`);
     }
   }
 }
@@ -8412,7 +9892,7 @@ function plural(count, singular, pluralForm = `${singular}s`) {
   return `${count} ${count === 1 ? singular : pluralForm}`;
 }
 function command(value) {
-  return pc3.cyan(value);
+  return pc6.cyan(value);
 }
 function cliInvocation(parts) {
   return parts.map(quoteCliArgument).join(" ");
@@ -8421,10 +9901,10 @@ function quoteCliArgument(value) {
   return /^[A-Za-z0-9_./:@%+=,-]+$/u.test(value) ? value : `'${value.replaceAll("'", `'"'"'`)}'`;
 }
 function link(value) {
-  return pc3.cyan(value);
+  return pc6.cyan(value);
 }
 function pathLabel(value) {
-  return pc3.cyan(value);
+  return pc6.cyan(value);
 }
 function starterConfig() {
   return `import { defineMap, defineTheme, labels, poi } from "@tileflow/core";
@@ -8470,15 +9950,15 @@ function printHostedCompatibilityIssues(issues) {
 }
 function printMapStatus(status, apiUrl) {
   printTitle("Tileflow status");
-  printKeyValue("Map", pc3.bold(status.mapId));
+  printKeyValue("Map", pc6.bold(status.mapId));
   console.log(`
-${pc3.bold("Styles")}`);
+${pc6.bold("Styles")}`);
   if (status.styles.length === 0) {
     logMuted("  No styles deployed.");
   }
   for (const style of status.styles) {
     console.log(
-      `  ${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))}`
+      `  ${pc6.green("\u2713")} ${style.environment.padEnd(16)} ${link(`${apiUrl}/maps/${style.mapId}/style.json`).padEnd(36)} ${formatBytes3(style.size).padStart(10)}  ${pc6.gray(formatDate(style.uploaded))}`
     );
   }
 }