tileflow 0.1.0-alpha.7 → 0.1.0-alpha.8

package/dist/index.js

@@ -7,58 +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 dirname11, isAbsolute as isAbsolute5, 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 pc6 from "picocolors";
 import { createLocalCoordinates, setupCoordinates } from "@tileflow/coordinates-runtime";
 import {
-  auditTileflowMapThemeValues,
-  getTileflowStyleFontFaces,
-  parseResolvedTileflowMap as parseResolvedTileflowMap4,
+  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 getTileflowMapNames4,
-  loadTileflowConfigWithInputs as loadTileflowConfigWithInputs3,
+  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,
+  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";
 
@@ -385,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
@@ -422,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;
   }
 }
@@ -471,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;
   }
 }
@@ -1215,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 } : {}
       });
     }
   };
@@ -1548,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 {
@@ -1566,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;
     }
@@ -1657,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,
@@ -1768,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 {
@@ -1815,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);
@@ -1837,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();
@@ -1895,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) {
@@ -2220,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;
@@ -2255,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 })
@@ -2346,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(
@@ -2676,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();
@@ -2686,7 +2690,7 @@ function raceWithAbort(operation, signal) {
     operation.then(
       (value) => {
         cleanup();
-        resolve8(value);
+        resolve9(value);
       },
       (error) => {
         cleanup();
@@ -2804,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,
@@ -2868,46 +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
+  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,
@@ -2945,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
   };
@@ -2968,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");
   }
@@ -3363,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 {
@@ -3394,56 +3693,56 @@ 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("--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) => {
@@ -3467,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)"}`
@@ -3486,8 +3785,8 @@ async function runIconDiff(options, dependencies) {
     ...options.cacheDir ? { cacheRoot: options.cacheDir } : {},
     ...options.offline ? { offline: true } : {}
   };
-  const compiled = await compileTileflowIconPackages(selectedProject, {
-    baseDirectory: dirname6(loaded.configFile),
+  const compiled = await compileTileflowIconPackages2(selectedProject, {
+    baseDirectory: dirname7(loaded.configFile),
     cwd: process.cwd(),
     ...Object.keys(icons).length > 0 ? { icons } : {},
     target: "hosted"
@@ -3631,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";
@@ -3675,7 +3974,7 @@ 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)"}`
@@ -3686,7 +3985,7 @@ async function runIconList(options) {
     ...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] } : {}
@@ -3710,6 +4009,18 @@ function createMapJson(map, catalogs) {
       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,
@@ -3773,18 +4084,18 @@ function printIssues(heading, issues) {
 }
 
 // src/icon-lock-command.ts
-import { dirname as dirname8 } from "path";
+import { dirname as dirname9 } from "path";
 import pc3 from "picocolors";
 import {
   collectTileflowIconSetReferences,
   compareCodeUnits as compareCodeUnits7,
-  parseResolvedTileflowMap as parseResolvedTileflowMap2,
+  parseResolvedTileflowMap as parseResolvedTileflowMap3,
   parseTileflowIconsLockfile,
   tileflowIconSetReferenceSchema as tileflowIconSetReferenceSchema2,
   tileflowIconsLockfileName
 } from "@tileflow/core";
 import {
-  getTileflowMapNames as getTileflowMapNames3,
+  getTileflowMapNames as getTileflowMapNames4,
   loadValidTileflowConfigWithInputs as loadValidTileflowConfigWithInputs3,
   TileflowValidationError as TileflowValidationError4
 } from "@tileflow/dev/config";
@@ -3792,7 +4103,7 @@ import { readTileflowIconsLockfileText, writeTileflowIconsLockfile } from "@tile
 
 // src/hosted-team.ts
 import pc from "picocolors";
-import { serializeCanonicalJson } from "@tileflow/core";
+import { serializeCanonicalJson as serializeCanonicalJson2 } from "@tileflow/core";
 async function resolveTeamAuthority(options, scopes, dependencies) {
   let apiOrigin;
   try {
@@ -3872,13 +4183,13 @@ function authorizedTeamRequest(authority, path, method, init = {}) {
   });
 }
 function emitJson(value) {
-  process.stdout.write(`${serializeCanonicalJson(value)}
+  process.stdout.write(`${serializeCanonicalJson2(value)}
 `);
 }
 function emitFailure(json, code, message, context = {}) {
   if (json) {
     process.stderr.write(
-      `${serializeCanonicalJson({ error: { code, ...context, message }, ok: false, schemaVersion: 1 })}
+      `${serializeCanonicalJson2({ error: { code, ...context, message }, ok: false, schemaVersion: 1 })}
 `
     );
   } else {
@@ -3893,8 +4204,9 @@ function safeMessage(error) {
 // src/icon-set-command.ts
 import { isAbsolute as isAbsolute2 } from "path";
 import pc2 from "picocolors";
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 import {
+  tileflowIconPackageLimits as tileflowIconPackageLimits3,
   tileflowIconSetPackageIdSchema,
   tileflowIconSetPinSchema,
   tileflowIconSetReferenceSchema
@@ -4338,27 +4650,27 @@ function isIconSetSlug(value) {
 function isIdempotencyKey(value) {
   return value.length >= 8 && value.length <= 128 && /^[A-Za-z0-9._:-]+$/u.test(value);
 }
-var cursorSchema = z5.string().min(1).max(2048).nullable();
-var isoDateSchema = z5.iso.datetime({ offset: true });
-var setSchema = z5.object({
-  id: z5.string().regex(/^ics_[A-Za-z0-9_-]{16}$/u),
+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: z5.string().max(200),
-  description: z5.string().max(2e3),
+  name: z4.string().max(200),
+  description: z4.string().max(2e3),
   archivedAt: isoDateSchema.nullable(),
-  latestVersion: z5.number().int().positive().max(Number.MAX_SAFE_INTEGER).nullable(),
+  latestVersion: z4.number().int().positive().max(Number.MAX_SAFE_INTEGER).nullable(),
   createdAt: isoDateSchema,
   updatedAt: isoDateSchema
 }).strict();
-var revisionBaseSchema = z5.object({
-  id: z5.string().regex(/^icv_[A-Za-z0-9_-]{16}$/u),
+var revisionBaseSchema = z4.object({
+  id: z4.string().regex(/^icv_[A-Za-z0-9_-]{16}$/u),
   reference: tileflowIconSetReferenceSchema,
-  version: z5.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  version: z4.number().int().positive().max(Number.MAX_SAFE_INTEGER),
   publishedAt: isoDateSchema,
   purgedAt: isoDateSchema.nullable(),
-  iconCount: z5.number().int().min(0).max(256),
-  totalBytes: z5.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-  publisher: z5.object({ kind: z5.enum(["credential", "membership"]), id: z5.string().max(200).nullable() }).strict()
+  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,
@@ -4382,53 +4694,53 @@ var revisionSummarySchema = revisionBaseSchema.extend({ packageId: tileflowIconS
     version
   })
 );
-var catalogListResponseSchema = z5.object({
-  schemaVersion: z5.literal(1),
-  sets: z5.array(setSchema).max(pageSize),
+var catalogListResponseSchema = z4.object({
+  schemaVersion: z4.literal(1),
+  sets: z4.array(setSchema).max(pageSize),
   nextCursor: cursorSchema.optional()
 }).strict();
-var catalogDetailResponseSchema = z5.object({ schemaVersion: z5.literal(1), set: setSchema }).strict();
-var versionsResponseSchema = z5.object({
-  schemaVersion: z5.literal(1),
-  versions: z5.array(revisionSummarySchema).max(pageSize),
+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 = z5.object({
-  schemaVersion: z5.literal(1),
-  archived: z5.boolean(),
+var revisionResponseSchema = z4.object({
+  schemaVersion: z4.literal(1),
+  archived: z4.boolean(),
   revision: revisionSchema
 }).strict();
-var publishResponseSchema = z5.object({ schemaVersion: z5.literal(1), changed: z5.boolean(), revision: revisionSchema }).strict();
-var usesResponseSchema = z5.object({
-  schemaVersion: z5.literal(1),
-  uses: z5.array(
-    z5.object({
-      deploymentId: z5.string().min(1).max(160),
-      deploymentVersion: z5.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-      mapId: z5.string().min(1).max(160),
-      mapName: z5.string().max(200).nullable(),
-      mapState: z5.string().max(64),
-      versionId: z5.string().regex(/^icv_[A-Za-z0-9_-]{16}$/u),
-      version: z5.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-      ordinal: z5.number().int().min(0).max(31),
-      relationship: z5.enum(["active", "retained"])
+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: z5.literal("known-hosted-deployments"),
-  includesUndeployedRepositoryLocks: z5.literal(false)
+  coverage: z4.literal("known-hosted-deployments"),
+  includesUndeployedRepositoryLocks: z4.literal(false)
 }).strict();
-var purgeResponseSchema = z5.object({
-  schemaVersion: z5.literal(1),
-  result: z5.object({
-    schemaVersion: z5.literal(1),
-    versionId: z5.string().regex(/^icv_[A-Za-z0-9_-]{16}$/u),
-    version: z5.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-    purged: z5.boolean(),
-    knownRetainedDeployments: z5.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-    physicalBytesReleased: z5.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-    unknownRepositoryLocks: z5.boolean(),
-    warning: z5.string().max(400)
+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();
 
@@ -4467,7 +4779,7 @@ function registerIconLockCommands(program2, dependencies) {
       const loaded = await withTileflowConfigSecretsHidden(
         () => loadValidTileflowConfigWithInputs3(options.config)
       );
-      baseDirectory = dirname8(loaded.configFile);
+      baseDirectory = dirname9(loaded.configFile);
       declared = collectDeclaredReferences(loaded.project);
     } catch (error) {
       return emitFailure(
@@ -4620,8 +4932,8 @@ function withLockOptions(command2, dependencies) {
 function collectDeclaredReferences(project) {
   const references = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const mapName of getTileflowMapNames3(project).sort(compareCodeUnits7)) {
-    const sources = parseResolvedTileflowMap2(project.maps[mapName]).icons ?? [];
+  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);
@@ -4669,7 +4981,7 @@ async function readCurrentPins(contents) {
 import { readFile as readFile4 } from "fs/promises";
 import { fileURLToPath } from "url";
 import {
-  serializeCanonicalJson as serializeCanonicalJson2,
+  serializeCanonicalJson as serializeCanonicalJson3,
   tileflowAuthoringManifest
 } from "@tileflow/core";
 import {
@@ -4697,21 +5009,21 @@ async function runLanguageCommand(command2, options, operation) {
   try {
     await operation();
   } catch (error) {
-    const failure = createTileflowCommandFailureDocument3(command2, error, process.cwd(), {
+    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(failure));
+    if (options.json) process.stderr.write(serializeTileflowCommandDocument3(failure2));
     else {
-      console.error(`${failure.message} [${failure.code}; ${failure.phase}]`);
-      console.error(`Suggestion: ${failure.suggestion}`);
+      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(`${serializeCanonicalJson2(manifest)}
+    process.stdout.write(`${serializeCanonicalJson3(manifest)}
 `);
     return;
   }
@@ -4722,7 +5034,7 @@ function printManifest(manifest, options) {
 }
 function printSchema(schema, options) {
   if (options.json) {
-    process.stdout.write(`${serializeCanonicalJson2(schema)}
+    process.stdout.write(`${serializeCanonicalJson3(schema)}
 `);
     return;
   }
@@ -4742,6 +5054,62 @@ 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";
@@ -5056,17 +5424,126 @@ 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 pc5 from "picocolors";
-import { serializeCanonicalJson as serializeCanonicalJson4 } from "@tileflow/core";
+import { z as z6 } from "zod";
+import { serializeCanonicalJson as serializeCanonicalJson5 } from "@tileflow/core";
 import { inspectTileflowPmtiles } from "@tileflow/dev/tilesets";
-import { z as z7 } from "zod";
 
 // src/tileset-upload.ts
 import { createHash } from "crypto";
 import { open as open4, stat } from "fs/promises";
-import { z as z6 } from "zod";
-import { serializeCanonicalJson as serializeCanonicalJson3 } from "@tileflow/core";
+import { z as z5 } from "zod";
+import { serializeCanonicalJson as serializeCanonicalJson4 } from "@tileflow/core";
 var teamTilesetPartSize = 16777216;
 var maximumTeamTilesetBytes = 4e9;
 var authorizationBatchSize = 16;
@@ -5206,7 +5683,7 @@ async function prepareTeamTilesetUpload(file) {
   };
   return Object.freeze({
     byteCount: identity.size,
-    contentHash: createHash("sha256").update(serializeCanonicalJson3(contentIdentity)).digest("hex"),
+    contentHash: createHash("sha256").update(serializeCanonicalJson4(contentIdentity)).digest("hex"),
     contentHashAlgorithm: "sha256-fixed-parts-v1",
     identity,
     partSize: teamTilesetPartSize,
@@ -5222,7 +5699,7 @@ function createTeamTilesetUploadIdempotencyKey(tilesetId, upload) {
     );
   }
   return createHash("sha256").update(
-    serializeCanonicalJson3({
+    serializeCanonicalJson4({
       byteCount: upload.byteCount,
       contentHash: upload.contentHash,
       contentHashAlgorithm: upload.contentHashAlgorithm,
@@ -5626,36 +6103,36 @@ function asRecord3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function defaultSleep(milliseconds) {
-  return new Promise((resolve8) => setTimeout(resolve8, milliseconds));
-}
-var identifierSchema = z6.string().min(20).max(80).regex(/^[A-Za-z0-9_-]+$/u);
-var uploadPartStatusSchema = z6.object({
-  byteCount: z6.number().int().min(1).max(teamTilesetPartSize),
-  partNumber: z6.number().int().min(1).max(239),
-  uploaded: z6.boolean(),
-  validationState: z6.enum(["mismatch", "pending", "processing", "valid"])
+  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({
+  byteCount: z5.number().int().min(1).max(teamTilesetPartSize),
+  partNumber: z5.number().int().min(1).max(239),
+  uploaded: z5.boolean(),
+  validationState: z5.enum(["mismatch", "pending", "processing", "valid"])
 }).strict();
-var publishedVersionSchema = z6.object({
-  byteCount: z6.number().int().min(1).max(maximumTeamTilesetBytes),
-  contentHash: z6.string().regex(/^[0-9a-f]{64}$/u),
-  contentHashAlgorithm: z6.literal("sha256-fixed-parts-v1"),
-  publishedVersion: z6.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  schemaVersion: z6.literal(1),
-  state: z6.literal("published"),
+var publishedVersionSchema = z5.object({
+  byteCount: z5.number().int().min(1).max(maximumTeamTilesetBytes),
+  contentHash: z5.string().regex(/^[0-9a-f]{64}$/u),
+  contentHashAlgorithm: z5.literal("sha256-fixed-parts-v1"),
+  publishedVersion: z5.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  schemaVersion: z5.literal(1),
+  state: z5.literal("published"),
   versionId: identifierSchema.regex(/^tsv_[A-Za-z0-9_-]+$/u)
 }).strict();
-var uploadControlSchema = z6.object({
-  byteCount: z6.number().int().min(1).max(maximumTeamTilesetBytes),
-  contentHash: z6.string().regex(/^[0-9a-f]{64}$/u),
-  contentHashAlgorithm: z6.literal("sha256-fixed-parts-v1"),
-  expiresAt: z6.iso.datetime({ offset: true }),
-  failure: z6.object({ code: z6.string().regex(/^TF_[A-Z0-9_]{1,96}$/u) }).strict().nullable(),
-  partCount: z6.number().int().min(1).max(239),
-  parts: z6.array(uploadPartStatusSchema).max(239),
-  partSize: z6.literal(teamTilesetPartSize),
-  publishedVersion: z6.null(),
-  schemaVersion: z6.literal(1),
-  state: z6.enum([
+var uploadControlSchema = z5.object({
+  byteCount: z5.number().int().min(1).max(maximumTeamTilesetBytes),
+  contentHash: z5.string().regex(/^[0-9a-f]{64}$/u),
+  contentHashAlgorithm: z5.literal("sha256-fixed-parts-v1"),
+  expiresAt: z5.iso.datetime({ offset: true }),
+  failure: z5.object({ code: z5.string().regex(/^TF_[A-Z0-9_]{1,96}$/u) }).strict().nullable(),
+  partCount: z5.number().int().min(1).max(239),
+  parts: z5.array(uploadPartStatusSchema).max(239),
+  partSize: z5.literal(teamTilesetPartSize),
+  publishedVersion: z5.null(),
+  schemaVersion: z5.literal(1),
+  state: z5.enum([
     "aborted",
     "aborting",
     "expired",
@@ -5668,32 +6145,32 @@ var uploadControlSchema = z6.object({
     "uploading",
     "validating"
   ]),
-  uploadId: z6.string().min(20).max(80).regex(/^tsu_[A-Za-z0-9_-]+$/u),
-  versionId: z6.null()
+  uploadId: z5.string().min(20).max(80).regex(/^tsu_[A-Za-z0-9_-]+$/u),
+  versionId: z5.null()
 }).strict();
-var uploadSessionSchema = z6.union([publishedVersionSchema, uploadControlSchema]);
-var authorizationSchema = z6.object({
-  expiresAt: z6.iso.datetime({ offset: true }),
-  headers: z6.object({
-    "Content-Length": z6.string().regex(/^[1-9][0-9]{0,9}$/u),
-    "Content-MD5": z6.string().regex(/^[A-Za-z0-9+/]{22}==$/u)
+var uploadSessionSchema = z5.union([publishedVersionSchema, uploadControlSchema]);
+var authorizationSchema = z5.object({
+  expiresAt: z5.iso.datetime({ offset: true }),
+  headers: z5.object({
+    "Content-Length": z5.string().regex(/^[1-9][0-9]{0,9}$/u),
+    "Content-MD5": z5.string().regex(/^[A-Za-z0-9+/]{22}==$/u)
   }).strict(),
-  method: z6.literal("PUT"),
-  partNumber: z6.number().int().min(1).max(239),
-  url: z6.url().max(8192).refine((value) => {
+  method: z5.literal("PUT"),
+  partNumber: z5.number().int().min(1).max(239),
+  url: z5.url().max(8192).refine((value) => {
     const url = new URL(value);
     return url.protocol === "https:" && !url.username && !url.password && !url.hash;
   })
 }).strict();
-var authorizationResponseSchema = z6.object({
-  authorizations: z6.array(authorizationSchema).min(1).max(16),
-  schemaVersion: z6.literal(1)
+var authorizationResponseSchema = z5.object({
+  authorizations: z5.array(authorizationSchema).min(1).max(16),
+  schemaVersion: z5.literal(1)
 }).strict();
-var partReceiptResponseSchema = z6.object({
-  changed: z6.boolean(),
-  etag: z6.string().regex(/^[0-9a-f]{32}$/u),
-  partNumber: z6.number().int().min(1).max(239),
-  schemaVersion: z6.literal(1)
+var partReceiptResponseSchema = z5.object({
+  changed: z5.boolean(),
+  etag: z5.string().regex(/^[0-9a-f]{32}$/u),
+  partNumber: z5.number().int().min(1).max(239),
+  schemaVersion: z5.literal(1)
 }).strict();
 
 // src/tileset-command.ts
@@ -5713,7 +6190,7 @@ function registerTilesetCommands(program2, dependencies) {
           sample: options.sample
         });
         if (options.json) {
-          process.stdout.write(`${serializeCanonicalJson4(inspection)}
+          process.stdout.write(`${serializeCanonicalJson5(inspection)}
 `);
           return;
         }
@@ -5736,7 +6213,7 @@ function registerTilesetCommands(program2, dependencies) {
         const message = error instanceof Error ? error.message : "Tileset inspection failed.";
         if (options.json) {
           process.stderr.write(
-            `${serializeCanonicalJson4({ error: { code, message, path }, ok: false, schemaVersion: 1 })}
+            `${serializeCanonicalJson5({ error: { code, message, path }, ok: false, schemaVersion: 1 })}
 `
           );
         } else {
@@ -5987,69 +6464,69 @@ function inspectionOptionError(message) {
 function asRecord4(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-var safeIdentifierSchema2 = z7.string().min(1).max(160).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u);
-var physicalTilesetIdSchema = z7.string().min(20).max(80).regex(/^tls_[A-Za-z0-9_-]+$/u);
-var cursorSchema2 = z7.string().min(1).max(2048).nullable();
-var tilesetInventoryItemSchema = z7.object({
-  currentVersion: z7.number().int().positive().max(Number.MAX_SAFE_INTEGER).nullable(),
-  hasCurrent: z7.boolean(),
+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 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(),
   id: physicalTilesetIdSchema,
-  logicalName: z7.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
-  name: z7.string().min(1).max(200),
-  retainedBytes: z7.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-  retainedDeploymentCount: z7.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-  status: z7.enum(["active", "purging", "retired"]),
-  updatedAt: z7.iso.datetime({ offset: true }),
-  usedByMapCount: z7.number().int().min(0).max(Number.MAX_SAFE_INTEGER)
+  logicalName: z6.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
+  name: z6.string().min(1).max(200),
+  retainedBytes: z6.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  retainedDeploymentCount: z6.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  status: z6.enum(["active", "purging", "retired"]),
+  updatedAt: z6.iso.datetime({ offset: true }),
+  usedByMapCount: z6.number().int().min(0).max(Number.MAX_SAFE_INTEGER)
 }).strict();
-var tilesetListResponseSchema = z7.object({
+var tilesetListResponseSchema = z6.object({
   nextCursor: cursorSchema2.optional(),
-  schemaVersion: z7.literal(1),
-  tilesets: z7.array(tilesetInventoryItemSchema).max(100)
+  schemaVersion: z6.literal(1),
+  tilesets: z6.array(tilesetInventoryItemSchema).max(100)
 }).strict();
-var tilesetDependencySchema = z7.object({
-  active: z7.boolean(),
+var tilesetDependencySchema = z6.object({
+  active: z6.boolean(),
   deploymentId: safeIdentifierSchema2,
-  deploymentVersion: z7.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  environment: z7.string().min(1).max(64),
+  deploymentVersion: z6.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  environment: z6.string().min(1).max(64),
   mapId: safeIdentifierSchema2,
   sourceId: safeIdentifierSchema2
 }).strict();
-var tilesetDetailResponseSchema = z7.object({
-  schemaVersion: z7.literal(1),
-  tileset: z7.object({
-    attribution: z7.string().max(4096).nullable(),
-    currentVersion: z7.number().int().positive().max(Number.MAX_SAFE_INTEGER).nullable(),
-    dependencies: z7.array(tilesetDependencySchema).max(25),
+var tilesetDetailResponseSchema = z6.object({
+  schemaVersion: z6.literal(1),
+  tileset: z6.object({
+    attribution: z6.string().max(4096).nullable(),
+    currentVersion: z6.number().int().positive().max(Number.MAX_SAFE_INTEGER).nullable(),
+    dependencies: z6.array(tilesetDependencySchema).max(25),
     dependencyNextCursor: cursorSchema2,
     id: physicalTilesetIdSchema,
-    name: z7.string().min(1).max(200),
-    slug: z7.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
-    state: z7.enum(["active", "purging", "purged"])
+    name: z6.string().min(1).max(200),
+    slug: z6.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
+    state: z6.enum(["active", "purging", "purged"])
   }).strict()
 }).strict();
-var purgeDependencySchema = z7.object({
+var purgeDependencySchema = z6.object({
   deploymentId: safeIdentifierSchema2,
   mapId: safeIdentifierSchema2,
   sourceId: safeIdentifierSchema2
 }).strict();
-var tilesetInUseResponseSchema = z7.object({
-  code: z7.literal("TF_TILESET_IN_USE"),
-  dependencies: z7.array(purgeDependencySchema).max(32),
-  error: z7.literal("Tileset is used by retained Map deployments"),
+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: cursorSchema2
 }).strict();
-var tilesetPurgeResponseSchema = z7.object({
-  deliveryFence: z7.enum(["complete", "pending"]),
-  pendingVersions: z7.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-  reclamation: z7.enum(["complete", "pending"]),
-  state: z7.enum(["purged", "purging"]),
+var tilesetPurgeResponseSchema = z6.object({
+  deliveryFence: z6.enum(["complete", "pending"]),
+  pendingVersions: z6.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  reclamation: z6.enum(["complete", "pending"]),
+  state: z6.enum(["purged", "purging"]),
   tilesetId: physicalTilesetIdSchema
 }).strict();
 
 // src/visual-command.ts
 import { lstat as lstat4, readFile as readFile6 } from "fs/promises";
-import { dirname as dirname10, isAbsolute as isAbsolute4, 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,
@@ -6068,7 +6545,7 @@ 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 dirname9, extname, isAbsolute as isAbsolute3, 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,
@@ -6079,14 +6556,14 @@ import {
 import {
   compareCodeUnits as compareCodeUnits8,
   normalizeTileflowCaptureScene as normalizeTileflowCaptureScene2,
-  parseResolvedTileflowMap as parseResolvedTileflowMap3,
+  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
@@ -6381,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
@@ -6534,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))
@@ -6553,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;
@@ -6810,7 +7287,7 @@ function resolveVisualCompareSide(artifacts, config, requestedMap, requestedThem
       `Unknown ${role} map "${map}". Available maps: ${availableMaps.join(", ") || "(none)"}.`
     );
   }
-  const resolvedMap = parseResolvedTileflowMap3(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.`);
@@ -6862,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 = dirname9(reportPath);
+  const reportDirectory = dirname10(reportPath);
   if (reportDirectory === cwd || reportDirectory === parse(reportPath).root) {
     throw new Error("Visual compare output must use a dedicated subdirectory.");
   }
@@ -6876,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);
@@ -6916,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
@@ -6933,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)
   ]);
@@ -7014,7 +7491,7 @@ function serializeVisualCompareInventory(inventory) {
 `;
 }
 async function readVisualCompareInventory(assetDirectory, inventoryPath, boundary) {
-  await assertNoSymlinkComponents(dirname9(inventoryPath), boundary);
+  await assertNoSymlinkComponents(dirname10(inventoryPath), boundary);
   let info;
   try {
     info = await lstat3(inventoryPath);
@@ -7037,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(dirname9(path), boundary);
+    const path = resolve6(assetDirectory, asset.path);
+    await assertNoSymlinkComponents(dirname10(path), boundary);
     let assetInfo;
     try {
       assetInfo = await lstat3(path);
@@ -7109,17 +7586,17 @@ 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 = dirname9(current);
+      const parent = dirname10(current);
       if (parent === current) {
         const canonical = absolute.normalize("NFC");
         return process.platform === "win32" ? canonical.toLowerCase() : canonical;
@@ -7191,7 +7668,7 @@ 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) {
@@ -7304,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({
@@ -7400,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);
@@ -7428,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) {
@@ -7549,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),
@@ -7564,7 +8041,7 @@ async function readBaselineFiles(directory, scene) {
   return { kind: "complete", pngPath, receiptPath, baseline: { png, receipt } };
 }
 async function readOptionalArtifact(path, boundary, maximumBytes) {
-  await assertNoSymlinkComponents(dirname10(path), boundary);
+  await assertNoSymlinkComponents(dirname11(path), boundary);
   let info;
   try {
     info = await lstat4(path);
@@ -7609,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.");
       }
@@ -7650,7 +8127,7 @@ 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);
@@ -7669,13 +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(pc6.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.`]);
@@ -7782,15 +8260,22 @@ 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("--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;
+    }
     if (options.target !== "local" && options.target !== "hosted") {
       if (options.json) {
-        const failure = createTileflowCommandFailureDocument4(
+        const failure2 = createTileflowCommandFailureDocument5(
           "validate",
           {
             code: "INVALID_TARGET",
@@ -7807,7 +8292,7 @@ program.command("validate").description("Validate a Tileflow config").option("-c
           process.cwd(),
           { code: "INVALID_TARGET", phase: "command-validation" }
         );
-        process.stderr.write(serializeTileflowCommandDocument4(failure));
+        process.stderr.write(serializeTileflowCommandDocument5(failure2));
         process.exitCode = 1;
         return;
       }
@@ -7822,15 +8307,15 @@ program.command("validate").description("Validate a Tileflow config").option("-c
     try {
       if (!options.json) logInfo(`Validating ${pathLabel(options.config)}.`);
       const loaded = await withTileflowConfigSecretsHidden(
-        () => loadTileflowConfigWithInputs3(options.config)
+        () => loadTileflowConfigWithInputs4(options.config)
       );
       const project = loaded.project;
-      const baseDirectory = dirname11(loaded.configFile);
+      const baseDirectory = dirname12(loaded.configFile);
       failureDefaults = { code: "CONFIG_INVALID", phase: "config-validation" };
-      assertValidTileflowConfig2(project);
-      const mapNames = getTileflowMapNames4(project).sort();
+      assertValidTileflowConfig3(project);
+      const mapNames = getTileflowMapNames5(project).sort();
       failureDefaults = { code: "ICON_COMPILATION_FAILED", phase: "icon-compilation" };
-      const compiledIcons = await compileTileflowIconPackages2(project, {
+      const compiledIcons = await compileTileflowIconPackages3(project, {
         baseDirectory,
         cwd: process.cwd(),
         icons: resolveIconOptions(options),
@@ -7841,18 +8326,18 @@ program.command("validate").description("Validate a Tileflow config").option("-c
         (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, {
+      const compiledStyles = createTileflowStyles2(project, {
         apiBaseUrl: options.apiBaseUrl,
         mapAssets
       });
       failureDefaults = { code: "TF_LOCAL_TILESET_INVALID", phase: "local-tileset-resolution" };
-      const localTilesets = await prepareTileflowLocalTilesets(project, compiledStyles, {
+      const localTilesets = await prepareTileflowLocalTilesets2(project, compiledStyles, {
         assetBaseUrl: "/tileflow",
         baseDirectory,
         cwd: process.cwd()
       });
       failureDefaults = { code: "FONT_COMPILATION_FAILED", phase: "font-compilation" };
-      const { styles } = await prepareTileflowStyleFonts(project, localTilesets.styles, {
+      const { styles } = await prepareTileflowStyleFonts2(project, localTilesets.styles, {
         assetBaseUrl: "/tileflow",
         baseDirectory,
         cwd: process.cwd(),
@@ -7877,11 +8362,11 @@ program.command("validate").description("Validate a Tileflow config").option("-c
         });
       }
       const themeWarnings = mapNames.flatMap(
-        (mapName) => auditTileflowMapThemeValues(project.maps[mapName]).filter(
+        (mapName) => auditTileflowMapThemeValues2(project.maps[mapName]).filter(
           ({ severity }) => severity === "warning"
         )
       );
-      const diagnostics = themeWarnings.length === 0 ? [] : createTileflowStructuredDiagnostics2({ diagnostics: themeWarnings }, process.cwd(), {
+      const diagnostics = themeWarnings.length === 0 ? [] : createTileflowStructuredDiagnostics3({ diagnostics: themeWarnings }, process.cwd(), {
         code: "VALIDATION_WARNING",
         phase: "theme-audit"
       });
@@ -7896,7 +8381,7 @@ program.command("validate").description("Validate a Tileflow config").option("-c
         ...options.target === "hosted" ? ["Hosted compatibility"] : []
       ];
       if (options.json) {
-        const summary = createTileflowCommandSummary2({
+        const summary = createTileflowCommandSummary3({
           code: "VALIDATION_OK",
           command: "validate",
           message: `Tileflow config is valid (${plural(mapNames.length, "map")}).`,
@@ -7907,7 +8392,7 @@ program.command("validate").description("Validate a Tileflow config").option("-c
           suggestion: "No changes are required."
         });
         process.stdout.write(
-          serializeTileflowCommandDocument4({
+          serializeTileflowCommandDocument5({
             ...summary,
             target: options.target,
             maps: mapNames,
@@ -7924,25 +8409,29 @@ program.command("validate").description("Validate a Tileflow config").option("-c
       }
     } catch (error) {
       if (!options.json) throw error;
-      const failure = createTileflowCommandFailureDocument4(
+      const failure2 = createTileflowCommandFailureDocument5(
         "validate",
         error,
         process.cwd(),
         failureDefaults
       );
-      process.stderr.write(serializeTileflowCommandDocument4(failure));
+      process.stderr.write(serializeTileflowCommandDocument5(failure2));
       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
 ).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) => {
-    logInfo(`Building ${pathLabel(options.config)}.`);
     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,
@@ -7953,15 +8442,62 @@ program.command("build").description("Generate static Tileflow styles").option("
       })
     );
     logSuccess("Built Tileflow artifacts.");
-    printKeyValue("Output", pathLabel(resolve7(process.cwd(), options.out)));
+    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("-p, --port <port>", "preview port", "3333").option("--scene <name>", "preview one committed standalone map scene").option(
+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("--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}`);
@@ -8006,30 +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();
@@ -8037,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,
@@ -8062,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
             })}
 `
           );
@@ -8071,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());
@@ -8091,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 {
@@ -8107,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
+            })}
 `
           );
         }
@@ -8115,7 +8693,7 @@ program.command("preview").alias("dev").description("Run a local map preview").o
     });
   }
 );
-program.command("deploy").description("Deploy maps to Tileflow and write the frontend manifest").option("-c, --config <path>", "config path", defaultConfigPath).option("--manifest <path>", "manifest path written for frontend bundlers", defaultManifestPath).option("--api-url <url>", "Tileflow API URL", process.env.TILEFLOW_API_URL).option("--api-key <key>", "Tileflow API key", process.env.TILEFLOW_API_KEY).option("--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"
 ).option("--cache-dir <path>", "verified Icon Set artifact cache root").option("--offline", "fail a locked Icon Set cache miss instead of hydrating it").action(
@@ -8136,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 = dirname11(loaded.configFile);
-    assertValidTileflowConfig2(project);
-    const configuredMapNames = getTileflowMapNames4(project);
+    const baseDirectory = dirname12(loaded.configFile);
+    assertValidTileflowConfig3(project);
+    const configuredMapNames = getTileflowMapNames5(project);
     const mapNames = selectManagedDeployMaps(configuredMapNames, options);
     if (!mapNames) return;
     if (!validateDeployTarget(options)) return;
@@ -8159,7 +8757,7 @@ 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),
@@ -8175,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,
       {
@@ -8252,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,
       {
@@ -8326,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];
@@ -8357,7 +8955,7 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
           ];
         })
       ),
-      { provenance: await createTileflowBuildProvenance(process.cwd()) }
+      { provenance: await createTileflowBuildProvenance2(process.cwd()) }
     );
     const deployments = mapNames.map((mapName) => {
       const iconBinding = bindingsByMap.get(mapName);
@@ -8448,7 +9046,7 @@ program.command("deploy").description("Deploy maps to Tileflow and write the fro
         process.exitCode = 1;
         return;
       }
-      const resolvedMap = parseResolvedTileflowMap4(deploymentProject.maps[mapName]);
+      const resolvedMap = parseResolvedTileflowMap5(deploymentProject.maps[mapName]);
       const mapBuild = buildManifest2.maps[mapName];
       deployedMaps[mapName] = {
         defaultTheme: resolvedMap.defaultTheme,
@@ -8458,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,
               {
@@ -8595,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);
@@ -8702,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,
@@ -8712,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,
@@ -8783,8 +9386,8 @@ 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;
@@ -8889,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: dirname11(outputPath),
+    boundaryPath: dirname12(outputPath),
     force: true,
     label: "Deploy manifest",
     managed: true,
@@ -8912,7 +9515,13 @@ 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 } : {}
+        }
+      }
     ])
   );
 }
@@ -8969,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.");
@@ -8983,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."