@tileflow/dev 0.1.0-alpha.26 → 0.1.0-alpha.28

package/README.md

@@ -73,6 +73,12 @@ manifest pointer, tracks its own files, and refuses to replace a hosted manifest
 Production rejects unresolved local PMTiles; publish data explicitly or provide an application-owned
 production source. Local development snapshots do not publish or redistribute the original dataset.
 
+Maps whose labels use a line-fitted `text.background` draw text with derived glyph stacks. Local
+previews and captures route such a map's glyph URL through `__glyphs/<map>/…`. Ordinary stacks pass
+through from the declared provider; derived ranges are computed from their source ranges, which are
+cached under `.tileflow/cache/glyphs/v1`. Production output keeps the declared provider, which must
+serve derived stacks.
+
 ## Keep a watched request handler
 
 Use one session for repeated work and close it when the owning server stops:
@@ -137,8 +143,9 @@ This is the one normal icon-preparation path. `compileTileflowIconPackages`,
 `prepareTileflowCatalogIcons`, `inspectTileflowIconCatalogs` and `getTileflowIconWatchPaths` all use
 it, so `createTileflowBuildArtifacts`, `createTileflowArtifactSession`, and every adapter that
 enters them accept the same explicit `icons` resolution options: `cacheRoot`, `offline`,
-`deliveryOrigins`, `fetch` and `signal`. Nothing selects a cache, an origin, or a transport from
-implicit process state, and no build or watch polls a catalog head. `prepareTileflowCatalogIcons`
+`deliveryOrigins`, `fetch` and `signal`. An explicit `cacheRoot` takes precedence over
+`TILEFLOW_ICON_CACHE_DIR`, then the OS cache default. Origins and transport use their documented
+defaults unless supplied explicitly; no build or watch polls a catalog head. `prepareTileflowCatalogIcons`
 returns `mapIconCompositions` alongside `mapIconSources`, and build-manifest entries carry the
 receipt as `sourceAssets.iconComposition` with `mapRevisionSchemaVersion: 2`.
 
@@ -159,8 +166,8 @@ Applications may explicitly configure trusted `deliveryOrigins`; locks cannot ad
 forbids all fetches and fails on missing or corrupt entries. Complete-map offline rendering still
 depends on unrelated tiles, glyphs, and other external resources.
 
-The cache lives under the OS user cache with `tileflow/icons/v1/<contentHash>`. `cacheRoot` or
-`TILEFLOW_ICON_CACHE_DIR` overrides its parent. Atomic directory installation and exact-entry
+The cache lives under the OS user cache with `tileflow/icons/v1/<contentHash>`. `cacheRoot`, then
+`TILEFLOW_ICON_CACHE_DIR`, overrides its parent. Atomic directory installation and exact-entry
 retirement support concurrent writers and corruption repair. Symlink entries are rejected. This is
 a disposable cache, not a security sandbox against another process controlling the same user
 account. Incomplete temporary entries are never accepted as published cache entries.

package/THIRD_PARTY_NOTICES.md

@@ -34,15 +34,10 @@ The generic font preparation pipeline reads map-owned TTF, OTF, and WOFF2 direct
 embed fonts in `@tileflow/dev`. Each source directory must carry its own `LICENSE.txt`, which is
 copied into the deterministic build artifacts whenever that directory contributes a selected face.
 
-The Cyberpunk map in `@tileflow/maps` currently owns unmodified Oxanium Medium and SemiBold TTFs.
-Oxanium is copyright 2019 The Oxanium Project Authors and is distributed under the SIL Open Font
-License 1.1. The source and binaries are pinned to upstream commit
-`a8f39e0c71186190027a093e9001459410192d1e`; the complete license accompanies the files at
-`@tileflow/maps/assets/cyberpunk/fonts/LICENSE.txt`.
-
-- Source: <https://github.com/sevmeyer/oxanium/tree/a8f39e0c71186190027a093e9001459410192d1e>
-- Google Fonts specimen: <https://fonts.google.com/specimen/Oxanium>
-- License: <https://github.com/sevmeyer/oxanium/blob/a8f39e0c71186190027a093e9001459410192d1e/OFL.txt>
+The source repository's generic font tests retain pinned Oxanium fixtures and their complete
+SIL Open Font License 1.1 notice under `test/fixtures/fonts/oxanium/`. These fixtures are not
+included in the published package. Community map fonts are owned by
+[Community Maps](https://github.com/tileflow/community-maps).
 
 ## fontkit 2.0.4
 

package/dist/artifacts.d.ts

@@ -5,6 +5,38 @@ import { TileflowRenderer, TileflowNativeBuildRecord } from '@tileflow/core/nati
 import { TileflowBuildAsset, TileflowIconResolutionOptions, PreparedTileflowBuildCatalog, TileflowSourceCatalog, PreparedTileflowCatalog } from './icons.js';
 export { defaultTileflowConfigPath } from './config.js';
 
+/**
+ * Local glyph serving for line-fitted text backgrounds.
+ *
+ * A style whose text uses a derived `<stack> lines-v1-…` font stack needs a glyph provider that
+ * derives those ranges. Local previews and captures route such a map's glyph URL through
+ * `__glyphs/<map>/…`: ordinary stacks pass through from the map's declared provider unchanged, and
+ * derived stacks are computed from their source stack's range. Production output keeps the
+ * declared provider, which must serve derived stacks itself.
+ */
+declare const tileflowLineBackgroundGlyphRoute = "__glyphs";
+/** Map name to the upstream glyph URL template its styles declared. Local only; never serialized. */
+type TileflowLineBackgroundGlyphProviders = Readonly<Record<string, string>>;
+type TileflowLineBackgroundGlyphResponderOptions = {
+    /** Project root; ranges are cached under `.tileflow/cache/glyphs/v1`. */
+    cwd: string;
+    fetch?: typeof globalThis.fetch;
+};
+type TileflowLineBackgroundGlyphResponder = (upstream: string, fontStack: string, range: string) => Promise<Response>;
+/** Whether a compiled style draws text with a derived line-background stack. */
+declare function usesTileflowLineBackgroundGlyphs(style: MapLibreStyle): boolean;
+/** Parses `/__glyphs/<map>/<fontstack>/<range>.pbf` from a decoded route path. */
+declare function parseTileflowLineBackgroundGlyphPath(path: string): {
+    fontStack: string;
+    mapName: string;
+    range: string;
+} | undefined;
+/**
+ * Serves one glyph range for a declared upstream template. Upstream ranges are cached on disk;
+ * derived ranges are recomputed from them and kept in a bounded in-memory cache.
+ */
+declare function createTileflowLineBackgroundGlyphResponder(options: TileflowLineBackgroundGlyphResponderOptions): TileflowLineBackgroundGlyphResponder;
+
 type TileflowLocalTilesetFile = Readonly<{
     byteLength: number;
     etag: string;
@@ -149,6 +181,8 @@ type TileflowBuildArtifacts = {
     project: TileflowBuildCatalog;
     /** Local-only archive ports. Paths never enter serialized build artifacts. */
     localTilesets?: TileflowLocalTilesetFile[];
+    /** Local-only upstream glyph templates for maps whose text uses line-fitted backgrounds. */
+    lineBackgroundGlyphs?: TileflowLineBackgroundGlyphProviders;
     /** Optional local-only provenance. It is never serialized as a build artifact. */
     styleInspections?: TileflowBuildStyleInspections;
     styles: TileflowBuildStyles;
@@ -222,4 +256,4 @@ declare function assertTileflowSelfHostedManifestTarget(manifestPath: string, op
     overwriteHostedManifest?: boolean;
 }): Promise<void>;
 
-export { type CreateTileflowArtifactPlanOptions, PreparedTileflowBuildCatalog, PreparedTileflowCatalog, type TileflowArtifactAcquisition, type TileflowArtifactDiagnostic, type TileflowArtifactFile, type TileflowArtifactInputGraph, type TileflowArtifactPlan, type TileflowArtifactSession, type TileflowArtifactSessionOptions, type TileflowArtifactSessionState, type TileflowBuildArtifacts, type TileflowBuildArtifactsOptions, TileflowBuildAsset, type TileflowBuildStyleInspections, TileflowHostedManifestOverwriteError, TileflowIconResolutionOptions, type TileflowLocalTilesetFile, TileflowLocalTilesetProductionError, type TileflowManifestOptions, TileflowSourceCatalog, type WriteTileflowArtifactPlanOptions, type WriteTileflowBuildArtifactsOptions, assertNoLocalTilesetsForProduction, assertTileflowSelfHostedManifestTarget, createTileflowArtifactDiagnostics, createTileflowArtifactPlan, createTileflowArtifactSession, createTileflowBuildArtifacts, createTileflowBuildProvenance, createTileflowManifest, createTileflowStyle, createTileflowStyles, disposeTileflowBuildArtifacts, getTileflowArtifactFiles, getTileflowAssetBasePath, getTileflowAssetFileName, getTileflowWatchPaths, isTileflowArtifactInputPath, joinTileflowPublicUrl, normalizeTileflowBasePath, prepareTileflowHostedNativeDeployment, prepareTileflowLocalTilesets, refreshTileflowArtifactSession, resolveTileflowArtifactPublicUrls, tileflowArtifactInventoryFileName, tileflowArtifactPlanSchemaVersion, tileflowArtifactSessionSchemaVersion, writeTileflowArtifactPlan, writeTileflowBuildArtifacts };
+export { type CreateTileflowArtifactPlanOptions, PreparedTileflowBuildCatalog, PreparedTileflowCatalog, type TileflowArtifactAcquisition, type TileflowArtifactDiagnostic, type TileflowArtifactFile, type TileflowArtifactInputGraph, type TileflowArtifactPlan, type TileflowArtifactSession, type TileflowArtifactSessionOptions, type TileflowArtifactSessionState, type TileflowBuildArtifacts, type TileflowBuildArtifactsOptions, TileflowBuildAsset, type TileflowBuildStyleInspections, TileflowHostedManifestOverwriteError, TileflowIconResolutionOptions, type TileflowLineBackgroundGlyphProviders, type TileflowLineBackgroundGlyphResponder, type TileflowLocalTilesetFile, TileflowLocalTilesetProductionError, type TileflowManifestOptions, TileflowSourceCatalog, type WriteTileflowArtifactPlanOptions, type WriteTileflowBuildArtifactsOptions, assertNoLocalTilesetsForProduction, assertTileflowSelfHostedManifestTarget, createTileflowArtifactDiagnostics, createTileflowArtifactPlan, createTileflowArtifactSession, createTileflowBuildArtifacts, createTileflowBuildProvenance, createTileflowLineBackgroundGlyphResponder, createTileflowManifest, createTileflowStyle, createTileflowStyles, disposeTileflowBuildArtifacts, getTileflowArtifactFiles, getTileflowAssetBasePath, getTileflowAssetFileName, getTileflowWatchPaths, isTileflowArtifactInputPath, joinTileflowPublicUrl, normalizeTileflowBasePath, parseTileflowLineBackgroundGlyphPath, prepareTileflowHostedNativeDeployment, prepareTileflowLocalTilesets, refreshTileflowArtifactSession, resolveTileflowArtifactPublicUrls, tileflowArtifactInventoryFileName, tileflowArtifactPlanSchemaVersion, tileflowArtifactSessionSchemaVersion, tileflowLineBackgroundGlyphRoute, usesTileflowLineBackgroundGlyphs, writeTileflowArtifactPlan, writeTileflowBuildArtifacts };

package/dist/artifacts.js

@@ -8,6 +8,7 @@ import {
   createTileflowArtifactSession,
   createTileflowBuildArtifacts,
   createTileflowBuildProvenance,
+  createTileflowLineBackgroundGlyphResponder,
   createTileflowManifest,
   createTileflowStyle,
   createTileflowStyles,
@@ -15,15 +16,18 @@ import {
   getTileflowArtifactFiles,
   getTileflowWatchPaths,
   isTileflowArtifactInputPath,
+  parseTileflowLineBackgroundGlyphPath,
   prepareTileflowHostedNativeDeployment,
   prepareTileflowLocalTilesets,
   refreshTileflowArtifactSession,
   tileflowArtifactInventoryFileName,
   tileflowArtifactPlanSchemaVersion,
   tileflowArtifactSessionSchemaVersion,
+  tileflowLineBackgroundGlyphRoute,
+  usesTileflowLineBackgroundGlyphs,
   writeTileflowArtifactPlan,
   writeTileflowBuildArtifacts
-} from "./chunk-QAMFAM3S.js";
+} from "./chunk-4HVIEMKM.js";
 import "./chunk-ONYQNLNA.js";
 import {
   getTileflowAssetBasePath,
@@ -49,6 +53,7 @@ export {
   createTileflowArtifactSession,
   createTileflowBuildArtifacts,
   createTileflowBuildProvenance,
+  createTileflowLineBackgroundGlyphResponder,
   createTileflowManifest,
   createTileflowStyle,
   createTileflowStyles,
@@ -61,6 +66,7 @@ export {
   isTileflowArtifactInputPath,
   joinTileflowPublicUrl,
   normalizeTileflowBasePath,
+  parseTileflowLineBackgroundGlyphPath,
   prepareTileflowHostedNativeDeployment,
   prepareTileflowLocalTilesets,
   refreshTileflowArtifactSession,
@@ -68,6 +74,8 @@ export {
   tileflowArtifactInventoryFileName,
   tileflowArtifactPlanSchemaVersion,
   tileflowArtifactSessionSchemaVersion,
+  tileflowLineBackgroundGlyphRoute,
+  usesTileflowLineBackgroundGlyphs,
   writeTileflowArtifactPlan,
   writeTileflowBuildArtifacts
 };

package/dist/{chunk-QAMFAM3S.js → chunk-4HVIEMKM.js}

@@ -28,22 +28,22 @@ import {
 } from "./chunk-D4OE4ITL.js";
 
 // src/artifacts.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { realpathSync as realpathSync2 } from "fs";
 import {
   copyFile as copyFile2,
-  lstat as lstat2,
-  mkdir as mkdir2,
+  lstat as lstat3,
+  mkdir as mkdir3,
   mkdtemp,
   open as open2,
-  readFile,
+  readFile as readFile2,
   realpath as realpath2,
-  rename,
-  rm as rm2,
+  rename as rename2,
+  rm as rm3,
   unlink
 } from "fs/promises";
 import { createRequire } from "module";
-import { dirname as dirname2, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
+import { dirname as dirname2, relative as relative2, resolve as resolve4, sep as sep2 } from "path";
 import {
   compareCodeUnits as compareCodeUnits2,
   getTileflowStyleFontFaces as getTileflowStyleFontFaces2,
@@ -68,11 +68,194 @@ import {
   TileflowNativeCompatibilityError as TileflowNativeCompatibilityError5
 } from "@tileflow/core/native-profile";
 
+// src/line-background-glyphs.ts
+import { createHash, randomUUID } from "crypto";
+import { lstat, mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { resolve } from "path";
+import {
+  deriveTileflowLineBackgroundGlyphs,
+  parseTileflowLineBackgroundFontStack
+} from "@tileflow/core";
+var tileflowLineBackgroundGlyphRoute = "__glyphs";
+var RANGE = /^\d{1,6}-\d{1,6}$/u;
+var FONT_STACK = /^[\p{L}\p{N} _.,-]{1,256}$/u;
+var MAP_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+var MAX_RANGE_BYTES = 8 * 1024 * 1024;
+var MAX_DERIVED_ENTRIES = 512;
+var CACHE_SEGMENTS = [".tileflow", "cache", "glyphs", "v1"];
+function usesTileflowLineBackgroundGlyphs(style) {
+  return style.layers.some((layer) => {
+    const layout = layer.layout;
+    const font = layout?.["text-font"];
+    return Array.isArray(font) && font.length === 1 && typeof font[0] === "string" && parseTileflowLineBackgroundFontStack(font[0]) !== void 0;
+  });
+}
+function prepareTileflowLineBackgroundGlyphs(styles, options) {
+  const base = absoluteHttpUrl(options.assetBaseUrl);
+  if (!base) return { providers: {}, styles };
+  const providers = {};
+  const output = {};
+  for (const [mapName, themes] of Object.entries(styles)) {
+    const family = Object.values(themes);
+    const upstream = family.find((style) => typeof style.glyphs === "string")?.glyphs;
+    if (!MAP_NAME.test(mapName) || !upstream || !absoluteHttpUrl(upstream) || !family.some(usesTileflowLineBackgroundGlyphs) || family.some((style) => style.glyphs !== upstream)) {
+      output[mapName] = themes;
+      continue;
+    }
+    providers[mapName] = upstream;
+    const glyphs = `${base.replace(/\/+$/u, "")}/${tileflowLineBackgroundGlyphRoute}/${mapName}/{fontstack}/{range}.pbf`;
+    output[mapName] = Object.fromEntries(
+      Object.entries(themes).map(([themeName, style]) => [themeName, { ...style, glyphs }])
+    );
+  }
+  return { providers, styles: output };
+}
+function parseTileflowLineBackgroundGlyphPath(path) {
+  const match = /^\/__glyphs\/([^/]+)\/([^/]+)\/([^/]+)\.pbf$/u.exec(path);
+  if (!match) return void 0;
+  let fontStack;
+  try {
+    fontStack = decodeURIComponent(match[2]);
+  } catch {
+    return void 0;
+  }
+  if (!MAP_NAME.test(match[1]) || !FONT_STACK.test(fontStack) || !RANGE.test(match[3])) {
+    return void 0;
+  }
+  return { fontStack, mapName: match[1], range: match[3] };
+}
+function createTileflowLineBackgroundGlyphResponder(options) {
+  const fetchRange = options.fetch ?? globalThis.fetch;
+  const derived = /* @__PURE__ */ new Map();
+  const upstreamRanges = /* @__PURE__ */ new Map();
+  const readUpstream = (upstream, fontStack, range) => {
+    const key2 = `${upstream}
+${fontStack}
+${range}`;
+    let pending = upstreamRanges.get(key2);
+    if (!pending) {
+      pending = loadUpstreamRange(options.cwd, fetchRange, upstream, fontStack, range).finally(
+        () => upstreamRanges.delete(key2)
+      );
+      upstreamRanges.set(key2, pending);
+    }
+    return pending;
+  };
+  return async (upstream, fontStack, range) => {
+    if (!absoluteHttpUrl(upstream) || !FONT_STACK.test(fontStack) || !RANGE.test(range)) {
+      return notFound();
+    }
+    const backed = parseTileflowLineBackgroundFontStack(fontStack);
+    if (!backed) {
+      if (fontStack.split(",").some((stack) => parseTileflowLineBackgroundFontStack(stack))) {
+        return notFound();
+      }
+      return glyphResponse(await readUpstream(upstream, fontStack, range));
+    }
+    const key2 = `${upstream}
+${fontStack}
+${range}`;
+    let pending = derived.get(key2);
+    if (!pending) {
+      pending = readUpstream(upstream, backed.source, range).then(
+        (source) => source ? deriveTileflowLineBackgroundGlyphs(source, backed.metrics) : void 0
+      );
+      pending.catch(() => derived.delete(key2));
+      derived.set(key2, pending);
+      if (derived.size > MAX_DERIVED_ENTRIES) derived.delete(derived.keys().next().value);
+    }
+    return glyphResponse(await pending);
+  };
+}
+async function loadUpstreamRange(cwd, fetchRange, upstream, fontStack, range) {
+  const directory = await cacheDirectory(cwd, upstream);
+  const file = resolve(directory, `${digest(fontStack)}-${range}.pbf`);
+  const cached = await readFile(file).catch((error) => {
+    if (hasCode(error, "ENOENT")) return void 0;
+    throw error;
+  });
+  if (cached) return new Uint8Array(cached);
+  const url = upstream.replace("{fontstack}", encodeURIComponent(fontStack)).replace("{range}", range);
+  const response = await fetchRange(url, {
+    credentials: "omit",
+    headers: { Accept: "application/x-protobuf" },
+    redirect: "error",
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (response.status === 404) return void 0;
+  if (response.status !== 200) {
+    throw new Error(`Glyph provider responded ${response.status} for ${fontStack} ${range}.`);
+  }
+  const length = Number(response.headers.get("content-length") ?? 0);
+  if (length > MAX_RANGE_BYTES) throw new Error(`Glyph range ${range} exceeds the size limit.`);
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  if (bytes.byteLength > MAX_RANGE_BYTES)
+    throw new Error(`Glyph range ${range} exceeds the size limit.`);
+  const temporary = `${file}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, bytes, { flag: "wx" });
+    await rename(temporary, file);
+  } catch {
+    await rm(temporary, { force: true }).catch(() => void 0);
+  }
+  return bytes;
+}
+async function cacheDirectory(cwd, upstream) {
+  let current = resolve(cwd);
+  for (const segment of [...CACHE_SEGMENTS, digest(upstream)]) {
+    current = resolve(current, segment);
+    try {
+      const stats = await lstat(current);
+      if (!stats.isDirectory() || stats.isSymbolicLink()) {
+        throw new Error(`Glyph cache path is unsafe: ${current}`);
+      }
+    } catch (error) {
+      if (!hasCode(error, "ENOENT")) throw error;
+      await mkdir(current).catch((mkdirError) => {
+        if (!hasCode(mkdirError, "EEXIST")) throw mkdirError;
+      });
+    }
+  }
+  return current;
+}
+function glyphResponse(bytes) {
+  if (!bytes) return notFound();
+  return new Response(new Uint8Array(bytes), {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Cache-Control": "no-cache",
+      "Content-Type": "application/x-protobuf"
+    },
+    status: 200
+  });
+}
+function notFound() {
+  return new Response(JSON.stringify({ error: "Unknown glyph range." }), {
+    headers: { "Content-Type": "application/json; charset=utf-8" },
+    status: 404
+  });
+}
+function absoluteHttpUrl(value) {
+  if (!value) return void 0;
+  try {
+    const url = new URL(value.replace("{fontstack}", "stack").replace("{range}", "0-255"));
+    return url.protocol === "http:" || url.protocol === "https:" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function digest(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 32);
+}
+function hasCode(error, code) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
+}
+
 // src/local-tilesets.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { constants } from "fs";
-import { chmod, copyFile, lstat, mkdir, open, readdir, realpath, rm, stat } from "fs/promises";
-import { basename, resolve } from "path";
+import { chmod, copyFile, lstat as lstat2, mkdir as mkdir2, open, readdir, realpath, rm as rm2, stat } from "fs/promises";
+import { basename, resolve as resolve2 } from "path";
 import { compareCodeUnits } from "@tileflow/core";
 var minimumLocalPmtilesBytes = 127n;
 var maximumLocalPmtilesBytes = 8000000000n;
@@ -83,14 +266,14 @@ async function prepareTileflowLocalTilesets(project, styles, options) {
   if (!hasSources) {
     return { dispose: async () => void 0, files: [], styles, watchPaths: [] };
   }
-  const logicalProjectRoot = resolve(options.cwd);
+  const logicalProjectRoot = resolve2(options.cwd);
   const projectRoot = await realpath(logicalProjectRoot).catch(() => logicalProjectRoot);
-  const snapshotStore = resolve(logicalProjectRoot, ".tileflow/cache/pmtiles-snapshots/v1");
+  const snapshotStore = resolve2(logicalProjectRoot, ".tileflow/cache/pmtiles-snapshots/v1");
   await assertSafeSnapshotStore(logicalProjectRoot, snapshotStore);
   await collectAbandonedSnapshotGenerations(snapshotStore);
-  const generationId = `snapshot-${process.pid}-${randomUUID().replaceAll("-", "")}`;
-  const generationDirectory = resolve(snapshotStore, generationId);
-  await mkdir(generationDirectory);
+  const generationId = `snapshot-${process.pid}-${randomUUID2().replaceAll("-", "")}`;
+  const generationDirectory = resolve2(snapshotStore, generationId);
+  await mkdir2(generationDirectory);
   const bindings = /* @__PURE__ */ new Map();
   const files = /* @__PURE__ */ new Map();
   const snapshots = /* @__PURE__ */ new Map();
@@ -109,7 +292,7 @@ async function prepareTileflowLocalTilesets(project, styles, options) {
     if (!isPathWithin(snapshotStore, generationDirectory)) {
       throw new Error("Local PMTiles snapshot generation escaped its store.");
     }
-    await rm(generationDirectory, { force: true, recursive: true });
+    await rm2(generationDirectory, { force: true, recursive: true });
   };
   try {
     for (const mapName of Object.keys(project.maps).sort(compareCodeUnits)) {
@@ -117,7 +300,7 @@ async function prepareTileflowLocalTilesets(project, styles, options) {
       for (const [sourceId, source] of Object.entries(map.sources ?? {}).sort(
         ([left], [right]) => compareCodeUnits(left, right)
       )) {
-        const requestedPath = resolve(options.baseDirectory, source.local);
+        const requestedPath = resolve2(options.baseDirectory, source.local);
         const sourcePath = await realpath(requestedPath).catch(() => requestedPath);
         if (!isPathWithin(projectRoot, sourcePath)) {
           throw localTilesetError(
@@ -126,7 +309,7 @@ async function prepareTileflowLocalTilesets(project, styles, options) {
             "Local hosted tileset must stay inside the project root."
           );
         }
-        const sourceStat = await lstat(sourcePath).catch(() => null);
+        const sourceStat = await lstat2(sourcePath).catch(() => null);
         if (!sourceStat?.isFile() || sourceStat.isSymbolicLink()) {
           throw localTilesetError(
             "TF_LOCAL_TILESET_NOT_FOUND",
@@ -197,7 +380,7 @@ async function prepareTileflowLocalTilesets(project, styles, options) {
 }
 async function createLocalTilesetSnapshot(sourcePath, generationDirectory, index) {
   const sourceHandle = await open(sourcePath, "r");
-  const snapshotPath = resolve(generationDirectory, `${index}.pmtiles`);
+  const snapshotPath = resolve2(generationDirectory, `${index}.pmtiles`);
   try {
     const before = sourceIdentity(await sourceHandle.stat({ bigint: true }));
     if (before.size < minimumLocalPmtilesBytes || before.size > maximumLocalPmtilesBytes) {
@@ -325,32 +508,32 @@ async function collectAbandonedSnapshotGenerations(store) {
     if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
     const match = /^snapshot-(\d+)-[a-f0-9]{32}$/u.exec(entry.name);
     if (!match?.[1] || processIsAlive(Number(match[1]))) continue;
-    const path = resolve(store, entry.name);
-    if (isPathWithin(store, path)) await rm(path, { force: true, recursive: true });
+    const path = resolve2(store, entry.name);
+    if (isPathWithin(store, path)) await rm2(path, { force: true, recursive: true });
   }
 }
 async function assertSafeSnapshotStore(projectRoot, store) {
   const segments = [".tileflow", "cache", "pmtiles-snapshots", "v1"];
   let current = projectRoot;
   for (const segment of segments) {
-    current = resolve(current, segment);
+    current = resolve2(current, segment);
     try {
-      const value = await lstat(current);
+      const value = await lstat2(current);
       if (!value.isDirectory() || value.isSymbolicLink()) {
         throw new Error(`Local PMTiles snapshot path is unsafe: ${current}`);
       }
     } catch (error) {
       if (!hasErrorCode(error, "ENOENT")) throw error;
-      await mkdir(current).catch((mkdirError) => {
+      await mkdir2(current).catch((mkdirError) => {
         if (!hasErrorCode(mkdirError, "EEXIST")) throw mkdirError;
       });
-      const created = await lstat(current);
+      const created = await lstat2(current);
       if (!created.isDirectory() || created.isSymbolicLink()) {
         throw new Error(`Local PMTiles snapshot path is unsafe: ${current}`);
       }
     }
   }
-  if (resolve(current) !== resolve(store)) {
+  if (resolve2(current) !== resolve2(store)) {
     throw new Error("Local PMTiles snapshot path escaped its project root.");
   }
 }
@@ -384,7 +567,7 @@ function hasErrorCode(error, code) {
 }
 
 // src/native-artifacts.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import {
   convertFilter,
   validateStyleMin
@@ -982,8 +1165,8 @@ function lowerTileflowNativeCompiledStyles(input) {
         transformations.push({
           map,
           theme,
-          inputStyleSha256: createHash("sha256").update(serializeCanonicalJson(original)).digest("hex"),
-          loweredStyleSha256: createHash("sha256").update(serializeCanonicalJson(lowered.style)).digest("hex"),
+          inputStyleSha256: createHash2("sha256").update(serializeCanonicalJson(original)).digest("hex"),
+          loweredStyleSha256: createHash2("sha256").update(serializeCanonicalJson(lowered.style)).digest("hex"),
           inputLayers: lowered.inputLayers,
           outputLayers: lowered.outputLayers,
           projection: lowered.projection,
@@ -1097,7 +1280,7 @@ function isNativeFontAsset(asset) {
   if (!/\.(?:ttf|otf)$/u.test(asset.fileName) || !["00010000", "4f54544f"].includes(signature))
     return false;
   const expectedHash = /-([a-f0-9]{64})\.(?:ttf|otf)$/u.exec(asset.fileName)?.[1];
-  return expectedHash === createHash("sha256").update(bytes).digest("hex");
+  return expectedHash === createHash2("sha256").update(bytes).digest("hex");
 }
 function assertTileflowNativeGeneratedStyle(style, map, theme) {
   const issues = validateTileflowNativePreparedStyle(style, { documentUrl: documentUrl(map, theme) });
@@ -1171,7 +1354,7 @@ function validNativeSprites(map, assets) {
 // src/session.ts
 import { watch } from "chokidar";
 import { realpathSync, statSync } from "fs";
-import { basename as basename2, dirname, extname, isAbsolute, relative, resolve as resolve2, sep, win32 } from "path";
+import { basename as basename2, dirname, extname, isAbsolute, relative, resolve as resolve3, sep, win32 } from "path";
 import { tileflowIconMetadataFileName } from "@tileflow/core";
 import { TileflowNativeCompatibilityError as TileflowNativeCompatibilityError2 } from "@tileflow/core/native-profile";
 var tileflowArtifactSessionSchemaVersion = 1;
@@ -1224,13 +1407,13 @@ var TileflowArtifactSessionImpl = class {
   #watchedArtifactDirectories = /* @__PURE__ */ new Map();
   #watchedArtifactPaths = /* @__PURE__ */ new Set();
   constructor(options, buildArtifacts, discoverWatchPaths) {
-    this.#cwd = resolve2(options.cwd ?? process.cwd());
-    const configPath = resolve2(this.#cwd, options.config ?? "tileflow.config.ts");
-    this.#configPath = resolve2(canonicalWatchPath(dirname(configPath)), basename2(configPath));
+    this.#cwd = resolve3(options.cwd ?? process.cwd());
+    const configPath = resolve3(this.#cwd, options.config ?? "tileflow.config.ts");
+    this.#configPath = resolve3(canonicalWatchPath(dirname(configPath)), basename2(configPath));
     this.#debounceMs = Math.max(0, Math.min(options.debounceMs ?? 75, 1e3));
     this.#watchEnabled = options.watch ?? false;
     this.#ignoredPaths = (options.ignoredPaths ?? []).map(
-      (path) => canonicalWatchPath(resolve2(this.#cwd, path))
+      (path) => canonicalWatchPath(resolve3(this.#cwd, path))
     );
     this.#buildArtifacts = buildArtifacts;
     this.#discoverWatchPaths = discoverWatchPaths;
@@ -1463,7 +1646,7 @@ var TileflowArtifactSessionImpl = class {
   }
   #updateArtifactWatchPaths(paths) {
     if (!this.#watcher) return;
-    const next = new Set(paths.map((path) => canonicalWatchPath(resolve2(this.#cwd, path))));
+    const next = new Set(paths.map((path) => canonicalWatchPath(resolve3(this.#cwd, path))));
     const previous = this.#watchedArtifactPaths;
     this.#watchedArtifactPaths = next;
     const previousDirectories = this.#watchedArtifactDirectories;
@@ -1528,7 +1711,7 @@ async function disposeArtifacts(artifacts) {
   await dispose?.();
 }
 function isSameOrInside(root, candidate) {
-  const path = relative(resolve2(root), resolve2(candidate));
+  const path = relative(resolve3(root), resolve3(candidate));
   return path === "" || !isAbsolute(path) && path !== ".." && !path.startsWith(`..${sep}`);
 }
 function directoryModificationTime(path) {
@@ -1546,15 +1729,15 @@ function resolveRawWatchPath(path, details) {
   const watchedPath = details.watchedPath;
   if (typeof watchedPath !== "string" || !isAbsolute(watchedPath)) return void 0;
   return canonicalWatchPath(
-    basename2(watchedPath) === path ? watchedPath : resolve2(watchedPath, path)
+    basename2(watchedPath) === path ? watchedPath : resolve3(watchedPath, path)
   );
 }
 function canonicalWatchPath(path) {
-  const resolved = resolve2(path);
+  const resolved = resolve3(path);
   let ancestor = resolved;
   while (true) {
     try {
-      return resolve2(realpathSync.native(ancestor), relative(ancestor, resolved));
+      return resolve3(realpathSync.native(ancestor), relative(ancestor, resolved));
     } catch {
       const parent = dirname(ancestor);
       if (parent === ancestor) return resolved;
@@ -1661,15 +1844,15 @@ function removeSemanticResolutionPath(message, path) {
   return message.replace(` at ${path}:`, ":");
 }
 function localPathAliases(path) {
-  return [.../* @__PURE__ */ new Set([resolve2(path), canonicalPath(path)])].sort(
+  return [.../* @__PURE__ */ new Set([resolve3(path), canonicalPath(path)])].sort(
     (left, right) => right.length - left.length
   );
 }
 function canonicalPath(path) {
   try {
-    return realpathSync.native(resolve2(path));
+    return realpathSync.native(resolve3(path));
   } catch {
-    return resolve2(path);
+    return resolve3(path);
   }
 }
 function normalizeDiagnostics(diagnostics) {
@@ -1705,7 +1888,7 @@ function boundDiagnosticText(value, limit) {
 }
 
 // src/hosted-native-artifacts.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { serializeCanonicalJson as serializeCanonicalJson3 } from "@tileflow/core";
 import {
   inferTileflowDataRequirements,
@@ -1835,7 +2018,7 @@ function finalizeNativeHostedProvenance(input, lowered, changes) {
 }
 
 // src/hosted-native-artifacts.ts
-var digest = (value) => createHash2("sha256").update(serializeCanonicalJson3(value)).digest("hex");
+var digest2 = (value) => createHash3("sha256").update(serializeCanonicalJson3(value)).digest("hex");
 var invalidSource = () => new TileflowNativeCompatibilityError4([
   createTileflowNativeDiagnostic3("NATIVE_UNSUPPORTED_SOURCE", "/sources")
 ]);
@@ -1881,15 +2064,15 @@ async function prepareTileflowHostedNativeDeployment(input) {
     if (!theme) throw invalidSource();
     mapBuild.themes[name] = {
       ...theme,
-      styleSha256: digest(style),
+      styleSha256: digest2(style),
       dataRequirements: inferTileflowDataRequirements(style),
       sourceRequirements: inferTileflowSourceRequirements(style)
     };
   }
   const transformations = lowered.transformations.map((item) => ({
     ...item,
-    inputStyleSha256: digest(webStyles[item.theme]),
-    loweredStyleSha256: digest({
+    inputStyleSha256: digest2(webStyles[item.theme]),
+    loweredStyleSha256: digest2({
       ...lowered.styles[input.mapId][item.theme],
       sources: webStyles[item.theme].sources
     })
@@ -1904,7 +2087,7 @@ async function prepareTileflowHostedNativeDeployment(input) {
       web: { buildManifest: input.buildManifest, styles: webStyles },
       native: {
         buildManifest: nativeBuild,
-        buildRecord: createTileflowNativeBuildRecord(digest(nativeBuild), transformations),
+        buildRecord: createTileflowNativeBuildRecord(digest2(nativeBuild), transformations),
         styles: projected
       }
     }
@@ -2032,7 +2215,10 @@ async function createTileflowArtifactPlan(prepared, options = {}) {
       throw error;
     });
     const assets = [...prepared.assets, ...preparedFonts.assets];
-    const styles = renderer === "native" ? prepareTileflowNativeStyles(preparedFonts.styles, assets) : preparedFonts.styles;
+    const lineBackgroundGlyphs = renderer === "native" || options.target === "production" ? { providers: {}, styles: preparedFonts.styles } : prepareTileflowLineBackgroundGlyphs(preparedFonts.styles, {
+      assetBaseUrl: resolveRendererAssetBaseUrl(options)
+    });
+    const styles = renderer === "native" ? prepareTileflowNativeStyles(preparedFonts.styles, assets) : lineBackgroundGlyphs.styles;
     const provenance = await createTileflowBuildProvenance(prepared.cwd);
     const buildManifest = await createTileflowMapBuildManifest(
       Object.fromEntries(
@@ -2092,6 +2278,7 @@ async function createTileflowArtifactPlan(prepared, options = {}) {
       manifest: stableManifest,
       project: prepared.project,
       ...localTilesets.files.length > 0 ? { localTilesets: localTilesets.files } : {},
+      ...Object.keys(lineBackgroundGlyphs.providers).length > 0 ? { lineBackgroundGlyphs: lineBackgroundGlyphs.providers } : {},
       ...inspected ? { styleInspections: inspected.inspections } : {},
       styles,
       watchPaths: uniqueStrings([...inputs.files, ...inputs.directories])
@@ -2292,12 +2479,12 @@ function getMapBuildAssets(mapName, assets, fontAssets) {
   );
 }
 function hashBytes(source) {
-  return createHash3("sha256").update(typeof source === "string" ? Buffer.from(source, "utf8") : Buffer.from(source)).digest("hex");
+  return createHash4("sha256").update(typeof source === "string" ? Buffer.from(source, "utf8") : Buffer.from(source)).digest("hex");
 }
 async function createTileflowBuildProvenance(cwd) {
-  const projectDirectory = resolve3(cwd);
+  const projectDirectory = resolve4(cwd);
   const projectRequire = createRequire(
-    resolve3(projectDirectory, "__tileflow_build_provenance__.cjs")
+    resolve4(projectDirectory, "__tileflow_build_provenance__.cjs")
   );
   const toolRequire = createRequire(import.meta.url);
   const packages = {};
@@ -2331,7 +2518,7 @@ async function readPackageVersion(expectedName, path) {
   if (!path) throw new Error(`Unable to resolve build package provenance for ${expectedName}.`);
   let parsed;
   try {
-    parsed = JSON.parse(await readFile(path, "utf8"));
+    parsed = JSON.parse(await readFile2(path, "utf8"));
   } catch {
     throw new Error(`Unable to read build package provenance for ${expectedName}.`);
   }
@@ -2354,7 +2541,7 @@ async function findNearestLockfile(cwd) {
       try {
         return {
           format: candidate.format,
-          source: await readFile(resolve3(directory, candidate.fileName))
+          source: await readFile2(resolve4(directory, candidate.fileName))
         };
       } catch (error) {
         if (!hasErrorCode2(error, "ENOENT")) throw error;
@@ -2430,7 +2617,7 @@ async function writeTileflowArtifactPlan(artifacts, options) {
   const outDir = artifacts.nativeBuild ? `${options.outDir.replace(/[\\/]$/u, "")}/native` : options.outDir;
   const output = await prepareTileflowOutputDirectory(cwd, outDir);
   const files = getTileflowArtifactFiles(artifacts);
-  await assertTileflowSelfHostedManifestTarget(resolve3(output.outDir, "manifest.json"), options);
+  await assertTileflowSelfHostedManifestTarget(resolve4(output.outDir, "manifest.json"), options);
   await commitTileflowArtifactFiles(output, files);
 }
 function assertNoLocalTilesetsForProduction(artifacts) {
@@ -2443,7 +2630,7 @@ async function assertTileflowSelfHostedManifestTarget(manifestPath, options = {}
   if (options.overwriteHostedManifest) return;
   let source;
   try {
-    source = await readFile(resolve3(manifestPath), "utf8");
+    source = await readFile2(resolve4(manifestPath), "utf8");
   } catch (error) {
     if (hasErrorCode2(error, "ENOENT")) return;
     throw error;
@@ -2451,7 +2638,7 @@ async function assertTileflowSelfHostedManifestTarget(manifestPath, options = {}
   try {
     const manifest = parseTileflowRuntimeManifest(JSON.parse(source));
     if (isHostedRuntimeManifest(manifest)) {
-      throw new TileflowHostedManifestOverwriteError(resolve3(manifestPath));
+      throw new TileflowHostedManifestOverwriteError(resolve4(manifestPath));
     }
   } catch (error) {
     if (error instanceof TileflowHostedManifestOverwriteError) throw error;
@@ -2499,15 +2686,15 @@ async function commitTileflowArtifactFiles(output, files) {
     ...staleNames,
     tileflowArtifactInventoryFileName
   ]);
-  const stageDir = await mkdtemp(resolve3(outDir, ".tileflow-stage-"));
-  const newDir = resolve3(stageDir, "new");
-  const backupDir = resolve3(stageDir, "backup");
+  const stageDir = await mkdtemp(resolve4(outDir, ".tileflow-stage-"));
+  const newDir = resolve4(stageDir, "new");
+  const backupDir = resolve4(stageDir, "backup");
   const backedUp = /* @__PURE__ */ new Set();
   const installed = /* @__PURE__ */ new Set();
   try {
     for (const file of stagedFiles) {
       const stagePath = managedPath(newDir, file.fileName);
-      await mkdir2(dirname2(stagePath), { recursive: true });
+      await mkdir3(dirname2(stagePath), { recursive: true });
       await writeFileDurably(stagePath, file.source);
     }
     for (const name of affectedNames) {
@@ -2515,7 +2702,7 @@ async function commitTileflowArtifactFiles(output, files) {
       const targetPath = managedPath(outDir, name);
       if (!await isFile(targetPath)) continue;
       const backupPath = managedPath(backupDir, name);
-      await mkdir2(dirname2(backupPath), { recursive: true });
+      await mkdir3(dirname2(backupPath), { recursive: true });
       await copyFile2(targetPath, backupPath);
       backedUp.add(name);
     }
@@ -2529,8 +2716,8 @@ async function commitTileflowArtifactFiles(output, files) {
     )) {
       const sourcePath = managedPath(newDir, name);
       const targetPath = managedPath(outDir, name);
-      await mkdir2(dirname2(targetPath), { recursive: true });
-      await rename(sourcePath, targetPath);
+      await mkdir3(dirname2(targetPath), { recursive: true });
+      await rename2(sourcePath, targetPath);
       installed.add(name);
     }
     for (const name of staleNames) {
@@ -2538,13 +2725,13 @@ async function commitTileflowArtifactFiles(output, files) {
     }
     const stagedInventoryPath = managedPath(newDir, tileflowArtifactInventoryFileName);
     const inventoryPath = managedPath(outDir, tileflowArtifactInventoryFileName);
-    await rename(stagedInventoryPath, inventoryPath);
+    await rename2(stagedInventoryPath, inventoryPath);
     installed.add(tileflowArtifactInventoryFileName);
   } catch (error) {
     await rollbackManagedFiles(outDir, backupDir, affectedNames, backedUp, installed);
     throw error;
   } finally {
-    await rm2(stageDir, { force: true, recursive: true });
+    await rm3(stageDir, { force: true, recursive: true });
   }
 }
 function getArtifactGeneration(files) {
@@ -2576,7 +2763,7 @@ async function rollbackManagedFiles(outDir, backupDir, affectedNames, backedUp,
         await removeManagedFile(targetPath);
       }
       if (backedUp.has(name)) {
-        await mkdir2(dirname2(targetPath), { recursive: true });
+        await mkdir3(dirname2(targetPath), { recursive: true });
         await copyFile2(managedPath(backupDir, name), targetPath);
       }
     } catch (error) {
@@ -2591,7 +2778,7 @@ async function readTileflowArtifactInventory(outDir) {
   const inventoryPath = managedPath(outDir, tileflowArtifactInventoryFileName);
   let source;
   try {
-    source = await readFile(inventoryPath, "utf8");
+    source = await readFile2(inventoryPath, "utf8");
   } catch (error) {
     if (hasErrorCode2(error, "ENOENT")) return void 0;
     throw error;
@@ -2625,7 +2812,7 @@ async function readTileflowArtifactInventory(outDir) {
 }
 async function assertManagedTargetIsSafe(outDir, fileName) {
   assertSafeManagedFileName(fileName);
-  const rootStats = await lstat2(outDir);
+  const rootStats = await lstat3(outDir);
   if (rootStats.isSymbolicLink()) {
     throw new Error(`Tileflow refuses to write through a symbolic link: ${outDir}`);
   }
@@ -2635,9 +2822,9 @@ async function assertManagedTargetIsSafe(outDir, fileName) {
   const segments = fileName.split("/");
   let current = outDir;
   for (let index = 0; index < segments.length; index += 1) {
-    current = resolve3(current, segments[index]);
+    current = resolve4(current, segments[index]);
     try {
-      const stats = await lstat2(current);
+      const stats = await lstat3(current);
       if (stats.isSymbolicLink()) {
         throw new Error(`Tileflow refuses to write through a symbolic link: ${fileName}`);
       }
@@ -2654,12 +2841,12 @@ async function assertManagedTargetIsSafe(outDir, fileName) {
   }
 }
 async function prepareTileflowOutputDirectory(cwd, requestedOutDir) {
-  const logicalRoot = resolve3(cwd);
-  const logicalOutDir = resolve3(logicalRoot, requestedOutDir);
+  const logicalRoot = resolve4(cwd);
+  const logicalOutDir = resolve4(logicalRoot, requestedOutDir);
   if (!isPathWithin(logicalRoot, logicalOutDir)) {
     throw new Error(`Tileflow artifact output escapes its working directory: ${logicalOutDir}`);
   }
-  const rootStats = await lstat2(logicalRoot);
+  const rootStats = await lstat3(logicalRoot);
   if (!rootStats.isDirectory()) {
     throw new Error(`Tileflow artifact working directory is not a directory: ${logicalRoot}`);
   }
@@ -2668,14 +2855,14 @@ async function prepareTileflowOutputDirectory(cwd, requestedOutDir) {
   const segments = relativeOutDir ? relativeOutDir.split(sep2) : [];
   let current = rootDir;
   for (const segment of segments) {
-    current = resolve3(current, segment);
+    current = resolve4(current, segment);
     let stats;
     try {
-      stats = await lstat2(current);
+      stats = await lstat3(current);
     } catch (error) {
       if (!hasErrorCode2(error, "ENOENT")) throw error;
-      await mkdir2(current);
-      stats = await lstat2(current);
+      await mkdir3(current);
+      stats = await lstat3(current);
     }
     if (stats.isSymbolicLink()) {
       throw new Error(`Tileflow refuses to write through a symbolic link: ${current}`);
@@ -2693,7 +2880,7 @@ async function assertTileflowOutputDirectoryIsSafe(output) {
   if (!isPathWithin(output.rootDir, output.outDir)) {
     throw new Error(`Tileflow artifact output escapes its working directory: ${output.outDir}`);
   }
-  const stats = await lstat2(output.outDir);
+  const stats = await lstat3(output.outDir);
   if (stats.isSymbolicLink()) {
     throw new Error(`Tileflow refuses to write through a symbolic link: ${output.outDir}`);
   }
@@ -2722,7 +2909,7 @@ function assertTileflowArtifactFileName(fileName) {
 }
 function managedPath(root, fileName) {
   assertSafeManagedFileName(fileName);
-  const path = resolve3(root, ...fileName.split("/"));
+  const path = resolve4(root, ...fileName.split("/"));
   if (!isPathWithin(root, path)) {
     throw new Error(`Unsafe Tileflow artifact file name: ${fileName}`);
   }
@@ -2739,7 +2926,7 @@ async function writeFileDurably(path, source) {
 }
 async function isFile(path) {
   try {
-    return (await lstat2(path)).isFile();
+    return (await lstat3(path)).isFile();
   } catch (error) {
     if (hasErrorCode2(error, "ENOENT")) return false;
     throw error;
@@ -2747,7 +2934,7 @@ async function isFile(path) {
 }
 async function removeManagedFile(path) {
   try {
-    const stats = await lstat2(path);
+    const stats = await lstat3(path);
     if (!stats.isFile()) throw new Error(`Refusing to remove non-file artifact target: ${path}`);
     await unlink(path);
   } catch (error) {
@@ -2755,7 +2942,7 @@ async function removeManagedFile(path) {
   }
 }
 function hashArtifactGeneration(files) {
-  const hash = createHash3("sha256");
+  const hash = createHash4("sha256");
   for (const file of files) {
     const source = typeof file.source === "string" ? Buffer.from(file.source, "utf8") : Buffer.from(file.source);
     hash.update(`${file.fileName}\0${file.contentType}\0${source.byteLength}\0`, "utf8");
@@ -2787,12 +2974,12 @@ function hasErrorCode2(error, code) {
   return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
 }
 function canonicalInputPath(path) {
-  const resolved = resolve3(path);
+  const resolved = resolve4(path);
   try {
     return realpathSync2.native(resolved);
   } catch {
     try {
-      return resolve3(realpathSync2.native(dirname2(resolved)), resolved.split(/[\\/]/).at(-1));
+      return resolve4(realpathSync2.native(dirname2(resolved)), resolved.split(/[\\/]/).at(-1));
     } catch {
       return resolved;
     }
@@ -2800,6 +2987,10 @@ function canonicalInputPath(path) {
 }
 
 export {
+  tileflowLineBackgroundGlyphRoute,
+  usesTileflowLineBackgroundGlyphs,
+  parseTileflowLineBackgroundGlyphPath,
+  createTileflowLineBackgroundGlyphResponder,
   prepareTileflowLocalTilesets,
   tileflowArtifactSessionSchemaVersion,
   createTileflowArtifactDiagnostics,

package/dist/{chunk-6OJICHB3.js → chunk-CJGM6HTT.js}

@@ -168,7 +168,7 @@ function renderTileflowPreviewHtml(preview, basePath, initialStatus, isSemanticP
       body { font-family: ui-sans-serif, system-ui, sans-serif; }
       #map {
         --tileflow-globe-radius: 220px;
-        background-color: #2F5070;
+        background-color: var(--tileflow-space, #2F5070);
         background-image:
           radial-gradient(circle at 18% 24%, rgba(225, 240, 250, 0.34) 0 1px, transparent 1.4px),
           radial-gradient(circle at 72% 62%, rgba(225, 240, 250, 0.22) 0 1px, transparent 1.3px),
@@ -191,12 +191,12 @@ function renderTileflowPreviewHtml(preview, basePath, initialStatus, isSemanticP
         top: 50%;
         width: calc(var(--tileflow-globe-radius) * 2);
         height: calc(var(--tileflow-globe-radius) * 2);
-        border: 1px solid rgba(248, 252, 255, 0.88);
+        border: 1px solid var(--tileflow-rim-line, rgba(248, 252, 255, 0.88));
         border-radius: 50%;
         box-shadow:
-          0 0 9px 3px rgba(248, 252, 255, 0.9),
-          0 0 28px 10px rgba(176, 220, 246, 0.52),
-          0 0 58px 20px rgba(132, 195, 232, 0.2);
+          0 0 9px 3px var(--tileflow-rim-core, rgba(248, 252, 255, 0.9)),
+          0 0 28px 10px var(--tileflow-rim-glow, rgba(176, 220, 246, 0.52)),
+          0 0 58px 20px var(--tileflow-rim-haze, rgba(132, 195, 232, 0.2));
         pointer-events: none;
         transform: translate(-50%, -50%);
       }
@@ -233,7 +233,8 @@ function renderTileflowPreviewHtml(preview, basePath, initialStatus, isSemanticP
         white-space: pre-wrap;
       }
       .maplibregl-ctrl-group .tileflow-3d-toggle,
-      .maplibregl-ctrl-group .tileflow-tree-toggle {
+      .maplibregl-ctrl-group .tileflow-tree-toggle,
+      .maplibregl-ctrl-group .tileflow-theme-toggle {
         width: auto;
         min-width: 58px;
         padding: 0 9px;
@@ -247,7 +248,8 @@ function renderTileflowPreviewHtml(preview, basePath, initialStatus, isSemanticP
         color: #174EA6;
       }
       .maplibregl-ctrl-group .tileflow-3d-toggle:hover,
-      .maplibregl-ctrl-group .tileflow-tree-toggle:hover {
+      .maplibregl-ctrl-group .tileflow-tree-toggle:hover,
+      .maplibregl-ctrl-group .tileflow-theme-toggle:hover {
         background-color: #F1F3F4;
       }
     </style>
@@ -275,6 +277,8 @@ function renderTileflowPreviewHtml(preview, basePath, initialStatus, isSemanticP
       const previewLabel = ${JSON.stringify(preview?.label)};
       const styleUrl = ${JSON.stringify(styleUrl)};
       const previewMapOptions = ${JSON.stringify(mapOptions)};
+      const previewTheme = ${serializeInlineJson(preview?.themeName ?? null)};
+      const previewThemes = ${serializeInlineJson(preview?.themeNames ?? [])};
       const isSemanticPreview = ${JSON.stringify(isSemanticPreview)};
       const previewFontFaces = ${serializeInlineJson(fontFaces)};
       const treeSearchParameters = new URL(location.href).searchParams;
@@ -985,6 +989,30 @@ function renderTileflowPreviewHtml(preview, basePath, initialStatus, isSemanticP
         );
         container.classList.add("tileflow-globe");
         container.style.setProperty("--tileflow-globe-radius", radius.toFixed(2) + "px");
+        applyAtmosphereBackdrop(map, container);
+      }
+
+      // Uses the map's declared atmosphere for the preview's space and rim, so a themed globe shows
+      // its own colours; maps without one keep the default backdrop.
+      function applyAtmosphereBackdrop(map, container) {
+        const atmosphere = map.getStyle?.()?.metadata?.["tileflow:atmosphere"];
+        const rgba = (hex, alpha) => {
+          const match = /^#([0-9a-f]{6})$/i.exec(String(hex ?? ""));
+          if (!match) return undefined;
+          const value = Number.parseInt(match[1], 16);
+          return "rgba(" + (value >> 16) + ", " + ((value >> 8) & 255) + ", " + (value & 255) + ", " + alpha + ")";
+        };
+        const properties = {
+          "--tileflow-space": rgba(atmosphere?.spaceColor, 1),
+          "--tileflow-rim-line": rgba(atmosphere?.horizonColor, 0.88),
+          "--tileflow-rim-core": rgba(atmosphere?.horizonColor, 0.9),
+          "--tileflow-rim-glow": rgba(atmosphere?.horizonColor, 0.52),
+          "--tileflow-rim-haze": rgba(atmosphere?.skyColor, 0.35),
+        };
+        for (const [name, value] of Object.entries(properties)) {
+          if (value) container.style.setProperty(name, value);
+          else container.style.removeProperty(name);
+        }
       }
 
       function createBuildingWireframeLayer(map, styleLayer) {
@@ -3777,6 +3805,38 @@ function renderTileflowPreviewHtml(preview, basePath, initialStatus, isSemanticP
         }
       }
 
+      // Switches a map preview between its themes. The preview reloads with the next theme and keeps
+      // the camera and toggles already written to the URL; scene previews own their theme.
+      class ThemeControl {
+        onAdd(map) {
+          this.map = map;
+          this.container = document.createElement("div");
+          this.container.className = "maplibregl-ctrl maplibregl-ctrl-group";
+          this.button = document.createElement("button");
+          this.button.type = "button";
+          this.button.className = "tileflow-theme-toggle";
+          const next = previewThemes[(previewThemes.indexOf(previewTheme) + 1) % previewThemes.length];
+          this.button.textContent = String(previewTheme).toUpperCase();
+          this.button.title = "Switch to the " + next + " theme";
+          this.button.setAttribute("aria-label", "Switch to the " + next + " theme");
+          this.handleClick = () => {
+            writeCameraToUrl(map);
+            const url = new URL(location.href);
+            url.searchParams.set("theme", next);
+            location.assign(url.href);
+          };
+          this.button.addEventListener("click", this.handleClick);
+          this.container.appendChild(this.button);
+          return this.container;
+        }
+
+        onRemove() {
+          this.button?.removeEventListener("click", this.handleClick);
+          this.container?.remove();
+          this.map = undefined;
+        }
+      }
+
       const previewLayerGroupIds = [
         "labels", "pois", "roads", "transit", "buildings", "landuse", "water"
       ];
@@ -3913,6 +3973,7 @@ function renderTileflowPreviewHtml(preview, basePath, initialStatus, isSemanticP
           map.addControl(threeDimensionalControl, "top-right");
           map.addControl(treeControl, "top-right");
         }
+        if (previewThemes.length > 1) map.addControl(new ThemeControl(), "top-right");
         let ensuringThreeDimensionalLayers;
         const treeRuntimeMinimumZoom = 16;
         const ensureThreeDimensionalLayers = () => {
@@ -4200,7 +4261,8 @@ function resolveTileflowPreview(project, selection = {}) {
     },
     label: `${mapName} / ${selectedTheme.name}`,
     mapName,
-    themeName: selectedTheme.name
+    themeName: selectedTheme.name,
+    themeNames: Object.keys(resolvedMap.themes)
   };
 }
 function resolvePreviewTheme(map, requested) {

package/dist/{chunk-UCBGTEQV.js → chunk-YOTMY5XT.js}

@@ -1,7 +1,10 @@
 import {
   createTileflowArtifactSession,
-  tileflowArtifactSessionSchemaVersion
-} from "./chunk-QAMFAM3S.js";
+  createTileflowLineBackgroundGlyphResponder,
+  parseTileflowLineBackgroundGlyphPath,
+  tileflowArtifactSessionSchemaVersion,
+  tileflowLineBackgroundGlyphRoute
+} from "./chunk-4HVIEMKM.js";
 import {
   normalizeTileflowBasePath
 } from "./chunk-UTRO4IBQ.js";
@@ -1709,6 +1712,7 @@ function createTileflowDevRequestHandler(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const apiBaseUrl = options.apiBaseUrl ?? defaultTileflowApiUrl;
   let ownedSessionPromise;
+  const lineBackgroundGlyphs = createTileflowLineBackgroundGlyphResponder({ cwd });
   let closed = false;
   let lastOrigin;
   const loadOwnedSession = (origin) => {
@@ -1783,6 +1787,12 @@ function createTileflowDevRequestHandler(options = {}) {
         );
       }
       if (!artifacts) return unavailableArtifactsResponse(state);
+      if (path.startsWith(`/${tileflowLineBackgroundGlyphRoute}/`)) {
+        const glyphRequest = parseTileflowLineBackgroundGlyphPath(path);
+        const upstream = glyphRequest ? artifacts.lineBackgroundGlyphs?.[glyphRequest.mapName] : void 0;
+        if (!glyphRequest || !upstream) return jsonResponse2({ error: "Unknown glyph range." }, 404);
+        return await lineBackgroundGlyphs(upstream, glyphRequest.fontStack, glyphRequest.range);
+      }
       if (path.startsWith("/tilesets/")) {
         const fileName = path.replace(/^\/+/, "");
         const localTileset = artifacts.localTilesets?.find(
@@ -1985,7 +1995,7 @@ function getRequestPathname(url) {
   }
 }
 function isOwnedTileflowRequestPath(path) {
-  return path === "/" || path === "/build-manifest.json" || path === "/manifest.json" || path === "/__events" || path === "/__status" || getTileflowStyleInspectionSelection(path) !== void 0 || path.startsWith("/generations/") || path.startsWith("/icons/") || path.startsWith("/tilesets/") || getTileflowStyleSelection(path) !== void 0 || path.startsWith("/fonts/") || path.startsWith("/__runtime/");
+  return path === "/" || path === "/build-manifest.json" || path === "/manifest.json" || path === "/__events" || path === "/__status" || getTileflowStyleInspectionSelection(path) !== void 0 || path.startsWith("/generations/") || path.startsWith("/icons/") || path.startsWith("/tilesets/") || getTileflowStyleSelection(path) !== void 0 || path.startsWith("/fonts/") || path.startsWith(`/${tileflowLineBackgroundGlyphRoute}/`) || path.startsWith("/__runtime/");
 }
 function tileflowErrorResponse(error) {
   if (error instanceof Error && "code" in error && error.code === "PREVIEW_SELECTION_INVALID") {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { CreateTileflowArtifactPlanOptions, TileflowArtifactAcquisition, TileflowArtifactDiagnostic, TileflowArtifactFile, TileflowArtifactInputGraph, TileflowArtifactPlan, TileflowArtifactSession, TileflowArtifactSessionOptions, TileflowArtifactSessionState, TileflowBuildArtifacts, TileflowBuildArtifactsOptions, TileflowBuildStyleInspections, TileflowHostedManifestOverwriteError, TileflowLocalTilesetFile, TileflowLocalTilesetProductionError, TileflowManifestOptions, WriteTileflowArtifactPlanOptions, WriteTileflowBuildArtifactsOptions, assertNoLocalTilesetsForProduction, assertTileflowSelfHostedManifestTarget, createTileflowArtifactDiagnostics, createTileflowArtifactPlan, createTileflowArtifactSession, createTileflowBuildArtifacts, createTileflowBuildProvenance, createTileflowManifest, createTileflowStyle, createTileflowStyles, disposeTileflowBuildArtifacts, getTileflowArtifactFiles, getTileflowAssetBasePath, getTileflowAssetFileName, getTileflowWatchPaths, isTileflowArtifactInputPath, joinTileflowPublicUrl, normalizeTileflowBasePath, prepareTileflowHostedNativeDeployment, prepareTileflowLocalTilesets, refreshTileflowArtifactSession, resolveTileflowArtifactPublicUrls, tileflowArtifactInventoryFileName, tileflowArtifactPlanSchemaVersion, tileflowArtifactSessionSchemaVersion, writeTileflowArtifactPlan, writeTileflowBuildArtifacts } from './artifacts.js';
+export { CreateTileflowArtifactPlanOptions, TileflowArtifactAcquisition, TileflowArtifactDiagnostic, TileflowArtifactFile, TileflowArtifactInputGraph, TileflowArtifactPlan, TileflowArtifactSession, TileflowArtifactSessionOptions, TileflowArtifactSessionState, TileflowBuildArtifacts, TileflowBuildArtifactsOptions, TileflowBuildStyleInspections, TileflowHostedManifestOverwriteError, TileflowLineBackgroundGlyphProviders, TileflowLineBackgroundGlyphResponder, TileflowLocalTilesetFile, TileflowLocalTilesetProductionError, TileflowManifestOptions, WriteTileflowArtifactPlanOptions, WriteTileflowBuildArtifactsOptions, assertNoLocalTilesetsForProduction, assertTileflowSelfHostedManifestTarget, createTileflowArtifactDiagnostics, createTileflowArtifactPlan, createTileflowArtifactSession, createTileflowBuildArtifacts, createTileflowBuildProvenance, createTileflowLineBackgroundGlyphResponder, createTileflowManifest, createTileflowStyle, createTileflowStyles, disposeTileflowBuildArtifacts, getTileflowArtifactFiles, getTileflowAssetBasePath, getTileflowAssetFileName, getTileflowWatchPaths, isTileflowArtifactInputPath, joinTileflowPublicUrl, normalizeTileflowBasePath, parseTileflowLineBackgroundGlyphPath, prepareTileflowHostedNativeDeployment, prepareTileflowLocalTilesets, refreshTileflowArtifactSession, resolveTileflowArtifactPublicUrls, tileflowArtifactInventoryFileName, tileflowArtifactPlanSchemaVersion, tileflowArtifactSessionSchemaVersion, tileflowLineBackgroundGlyphRoute, usesTileflowLineBackgroundGlyphs, writeTileflowArtifactPlan, writeTileflowBuildArtifacts } from './artifacts.js';
 export { LoadTileflowConfigOptions, LoadedTileflowConfig, TileflowValidationError, assertValidTileflowConfig, defaultTileflowApiUrl, defaultTileflowConfigPath, defaultTileflowManifestPath, getFirstTileflowMapName, getTileflowMapNames, loadTileflowConfig, loadTileflowConfigWithInputs, loadValidTileflowConfig, loadValidTileflowConfigWithInputs } from './config.js';
 export { CompiledTileflowFontBundle, PrepareTileflowStyleFontsOptions, PreparedTileflowStyleFonts, TileflowFontCompilationError, TileflowFontCompilationIssue, TileflowFontCompilationTarget, bindTileflowStyleFontBundle, getTileflowFontWatchPaths, prepareTileflowStyleFonts, replaceTileflowStyleFontSources } from './fonts.js';
 export { CompileTileflowIconPackagesOptions, CompileTileflowIconPackagesResult, CompiledTileflowIconPackage, CompiledTileflowIconPackageFile, ComposeTileflowIconSourcesOptions, InspectTileflowIconCatalogsOptions, PreparedTileflowBuildCatalog, PreparedTileflowCatalog, ReadTileflowIconDirectoryResult, TileflowBuildAsset, TileflowComposedIconContributor, TileflowComposedIconSources, TileflowComposedIconWinner, TileflowIconCacheOptions, TileflowIconCatalog, TileflowIconCatalogAtlasRectangle, TileflowIconCatalogContributor, TileflowIconCatalogIcon, TileflowIconCatalogIconSource, TileflowIconCatalogInspection, TileflowIconCatalogMap, TileflowIconCatalogRenderedDensity, TileflowIconCatalogSourceFormat, TileflowIconCompilationError, TileflowIconCompilationIssue, TileflowIconCompilationTarget, TileflowIconDirectoryEntry, TileflowIconDirectorySourceFile, TileflowIconReplacement, TileflowIconResolutionOptions, TileflowMapIconPackageBinding, TileflowRenderedIcon, TileflowRenderedIconCell, TileflowSourceCatalog, VerifiedTileflowIconArtifact, compileTileflowIconPackages, composeTileflowIconSources, getTileflowIconCacheDirectory, getTileflowIconWatchPaths, iconFileExtensions, inspectTileflowIconCatalogs, loadTileflowIconSetArtifact, packTileflowRenderedIcons, prepareTileflowCatalogIcons, readTileflowIconDirectory, readTileflowIconsLockfile, readTileflowIconsLockfileText, renderTileflowIconAtlasPreview, storeTileflowIconSetArtifact, verifyTileflowIconArtifact, writeTileflowIconsLockfile } from './icons.js';

package/dist/index.js

@@ -19,7 +19,7 @@ import {
   readBoundedTileflowResponse,
   renderTileflowPreviewHtml,
   resolveTileflowPreview
-} from "./chunk-6OJICHB3.js";
+} from "./chunk-CJGM6HTT.js";
 import {
   createTileflowArtifactStatus,
   createTileflowComparisonRequestHandler,
@@ -31,7 +31,7 @@ import {
   isTileflowRequestUrl,
   tileflowComparisonSchemaVersion,
   writeTileflowNodeResponse
-} from "./chunk-UCBGTEQV.js";
+} from "./chunk-YOTMY5XT.js";
 import {
   TileflowHostedManifestOverwriteError,
   TileflowLocalTilesetProductionError,
@@ -42,6 +42,7 @@ import {
   createTileflowArtifactSession,
   createTileflowBuildArtifacts,
   createTileflowBuildProvenance,
+  createTileflowLineBackgroundGlyphResponder,
   createTileflowManifest,
   createTileflowStyle,
   createTileflowStyles,
@@ -49,15 +50,18 @@ import {
   getTileflowArtifactFiles,
   getTileflowWatchPaths,
   isTileflowArtifactInputPath,
+  parseTileflowLineBackgroundGlyphPath,
   prepareTileflowHostedNativeDeployment,
   prepareTileflowLocalTilesets,
   refreshTileflowArtifactSession,
   tileflowArtifactInventoryFileName,
   tileflowArtifactPlanSchemaVersion,
   tileflowArtifactSessionSchemaVersion,
+  tileflowLineBackgroundGlyphRoute,
+  usesTileflowLineBackgroundGlyphs,
   writeTileflowArtifactPlan,
   writeTileflowBuildArtifacts
-} from "./chunk-QAMFAM3S.js";
+} from "./chunk-4HVIEMKM.js";
 import {
   inspectTileflowPmtiles,
   inspectTileflowPmtilesForLocalUse
@@ -140,6 +144,7 @@ export {
   createTileflowCommandSummary,
   createTileflowComparisonRequestHandler,
   createTileflowDevRequestHandler,
+  createTileflowLineBackgroundGlyphResponder,
   createTileflowManifest,
   createTileflowNodeRequest,
   createTileflowStructuredDiagnostics,
@@ -179,6 +184,7 @@ export {
   normalizeTileflowBasePath,
   normalizeTileflowLandmarkManifest,
   packTileflowRenderedIcons,
+  parseTileflowLineBackgroundGlyphPath,
   prepareTileflowCatalogIcons,
   prepareTileflowHostedNativeDeployment,
   prepareTileflowLocalTilesets,
@@ -203,6 +209,8 @@ export {
   tileflowArtifactSessionSchemaVersion,
   tileflowCommandDocumentSchemaVersion,
   tileflowComparisonSchemaVersion,
+  tileflowLineBackgroundGlyphRoute,
+  usesTileflowLineBackgroundGlyphs,
   validateTileflowStyle,
   verifyTileflowIconArtifact,
   writeTileflowArtifactPlan,

package/dist/preview.d.ts

@@ -58,6 +58,8 @@ type ResolvedTileflowPreview = {
     label: string;
     mapName: string;
     themeName: string;
+    /** Every theme of a map preview, in declaration order. A scene owns its theme and omits this. */
+    themeNames?: readonly string[];
     viewport?: NormalizedTileflowCaptureScene['viewport'];
 };
 declare class TileflowPreviewSelectionError extends Error {

package/dist/preview.js

@@ -5,7 +5,7 @@ import {
   readBoundedTileflowResponse,
   renderTileflowPreviewHtml,
   resolveTileflowPreview
-} from "./chunk-6OJICHB3.js";
+} from "./chunk-CJGM6HTT.js";
 import "./chunk-6MGFMKG3.js";
 import "./chunk-D4OE4ITL.js";
 export {

package/dist/server.js

@@ -9,11 +9,11 @@ import {
   isTileflowRequestUrl,
   tileflowComparisonSchemaVersion,
   writeTileflowNodeResponse
-} from "./chunk-UCBGTEQV.js";
+} from "./chunk-YOTMY5XT.js";
 import {
   createTileflowArtifactDiagnostics,
   tileflowArtifactSessionSchemaVersion
-} from "./chunk-QAMFAM3S.js";
+} from "./chunk-4HVIEMKM.js";
 import "./chunk-ONYQNLNA.js";
 import {
   getTileflowAssetBasePath,

package/docs/bounded-vector-feature-inspection.md

@@ -41,14 +41,14 @@ const result = await compileTileflowIconPackages(internalCatalog, {
 
 Streets declares `[streetsIcons]` and keeps light/dark image-token targets in that one closure;
 Cyberpunk and Matrix independently declare `[cyberpunkIcons]` and `[matrixIcons]`. Baedeker,
-Ferraris, Härad, Siegfried, Soundings, Verdant, and San Francisto declare only `[baedekerIcons]`,
-`[ferrarisIcons]`, `[haradIcons]`, `[siegfriedIcons]`, `[soundingsIcons]`, `[verdantIcons]`, and
-`[sanFrancistoIcons]`, respectively. No official root composes another map's assets even though all
+Ferraris, Härad, Siegfried, Soundings, and Blueprint declare only `[baedekerIcons]`,
+`[ferrarisIcons]`, `[haradIcons]`, `[siegfriedIcons]`, `[soundingsIcons]`, and
+`[blueprintIcons]`, respectively. No official root composes another map's assets even though all
 use the semantic compiler ABI. Baedeker's directory contains eight original travel-atlas patterns;
 its browser-derived Mapterhorn contours use runtime terrain tiles and are not part of the icon
 package. Härad's directory contains nine original Tileflow patterns inspired by Lantmäteriet's CC0
 Häradsekonomiska kartan series from 1859–1934. Soundings owns ten original nautical symbols and
-patterns. San Francisto owns four technical blueprint patterns and one schematic POI node; its
+patterns. Blueprint owns four technical blueprint patterns and one schematic POI node; its
 unbundled Mapterhorn contours remain runtime terrain, and its text uses the canonical Noto Sans
 glyph provider. An application map may inherit a root's exact array, replace it, clear it with `[]`,
 or compose it explicitly with a spread.

package/docs/local-comparison-workbench-and-compiler-inspection.md

@@ -236,11 +236,9 @@ Directories apply left to right. `<id>.<ext>` publishes an icon as `<id>`;
 `<id>.pattern.<ext>` publishes the intrinsic-size pattern as `<id>`. The published ID must already
 be canonical lower-kebab-case. A later file replaces an earlier file only for the same exact ID;
 case-only collisions fail. Package maps export `streetsIcons`, `baedekerIcons`, `civicaIcons`,
-`ferrarisIcons`, `haradIcons`, `siegfriedIcons`, `soundingsIcons`, `cyberpunkIcons`, `matrixIcons`,
-`verdantIcons`, `sanFrancistoIcons`, and `superTileWorldIcons` directory descriptors from
-`@tileflow/maps`. Cyberpunk, Matrix, Baedeker, Cívica, Siegfried, and Super Tile World also export
-`cyberpunkFonts`, `matrixFonts`, `baedekerFonts`, `civicaFonts`, `siegfriedFonts`, and
-`superTileWorldFonts`. Preparation
+`ferrarisIcons`, `haradIcons`, `siegfriedIcons`, `soundingsIcons`, `blueprintIcons` directory descriptors from
+`@tileflow/maps`. Baedeker, Cívica, and Siegfried also export
+`baedekerFonts`, `civicaFonts`, and `siegfriedFonts`. Preparation
 resolves package descriptors inside their owning package, checks real-path containment, and
 compiles them through the same pipeline as a config-relative directory. There are no
 built-in/source/sprite selectors, mappings, icon-specific inheritance, or compatibility aliases.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tileflow/dev",
-  "version": "0.1.0-alpha.26",
+  "version": "0.1.0-alpha.28",
   "license": "Apache-2.0",
   "description": "Node development utilities for Tileflow configs and builds.",
   "type": "module",
@@ -90,7 +90,7 @@
   "dependencies": {
     "@mapbox/vector-tile": "3.0.0",
     "@maplibre/maplibre-gl-style-spec": "24.8.5",
-    "@tileflow/core": ">=0.1.0-alpha.27 <0.1.0-beta.0",
+    "@tileflow/core": ">=0.1.0-alpha.30 <0.1.0-beta.0",
     "chokidar": "4.0.3",
     "fflate": "0.8.3",
     "fontkit": "2.0.4",
@@ -102,7 +102,7 @@
     "three": "0.185.1"
   },
   "devDependencies": {
-    "@tileflow/maps": "0.1.0-alpha.5"
+    "@tileflow/maps": "0.1.0-alpha.7"
   },
   "optionalDependencies": {
     "sharp": "0.35.4"