@tileflow/core 0.1.0-alpha.26 → 0.1.0-alpha.27

package/dist/{manifest-B5GKVMFE.d.ts → manifest-types-BdGjIYy-.d.ts}

@@ -1,5 +1,3 @@
-import { z } from 'zod';
-
 declare const expressionBrand: unique symbol;
 declare const themeValueBrand: unique symbol;
 declare const zoomBrand: unique symbol;
@@ -610,14 +608,10 @@ type TileflowStyleFontFace = {
     style?: 'italic' | 'normal' | 'oblique';
     weight?: '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
 };
-/** Browser input is either one published Tileflow map or one direct MapLibre style. */
+/** One published Tileflow map. Renderer-specific styles are not framework Map inputs. */
 type TileflowRuntimeSource = {
-    kind: 'tileflow';
     manifestUrl?: string;
     map: string;
-} | {
-    kind: 'maplibre';
-    style: MapLibreStyle | string;
 };
 type TileflowRuntimeStyleOptions = {
     colorScheme?: TileflowRuntimeColorScheme;
@@ -750,8 +744,5 @@ type TileflowRuntimeManifest = {
     maps: Record<string, TileflowRuntimeManifestMapEntry>;
     version: typeof tileflowRuntimeManifestVersion;
 };
-declare const tileflowRuntimeManifestSchema: z.ZodType<TileflowRuntimeManifest>;
-declare function parseTileflowRuntimeManifest(input: unknown): TileflowRuntimeManifest;
-declare function safeParseTileflowRuntimeManifest(input: unknown): z.ZodSafeParseResult<TileflowRuntimeManifest>;
 
-export { type TileflowNumberInsetsStyleValue as $, type TileflowFillPaint as A, type TileflowIconAnchor as B, type TileflowIconLayout as C, type TileflowIconPaint as D, type TileflowIconStyle as E, type TileflowIconTextFit as F, type TileflowImageStyleValue as G, type TileflowLabelDetail as H, type TileflowLabelLanguage as I, type TileflowLabelStyles as J, type TileflowLayerRange as K, type TileflowLight as L, type MapLibreStyle as M, type TileflowLineCap as N, type TileflowLineHatchStyle as O, type TileflowLineJoin as P, type TileflowLineLayout as Q, type TileflowLinePaint as R, type TileflowLineStackStyle as S, type TileflowRuntimeManifest as T, type TileflowManifestFetchOptions as U, type ValidationMessage as V, type TileflowManifestLoadOptions as W, type TileflowMapMode as X, type TileflowMapModeOptions as Y, type TileflowMarkerSymbolStyle as Z, type TileflowMountainBikeScale as _, type TileflowExpression as a, type TileflowTextPaint as a$, type TileflowNumberStyleValue as a0, type TileflowPlaceLabelClass as a1, type TileflowPoiCategory as a2, type TileflowPoiCategoryStyle as a3, type TileflowPoiColorMode as a4, type TileflowPoiDensity as a5, type TileflowPriorityOrder as a6, type TileflowProjection as a7, type TileflowResolvedRuntimeTheme as a8, type TileflowRoadAreaStyle as a9, type TileflowRuntimeSource as aA, type TileflowRuntimeSourceValidation as aB, type TileflowRuntimeStyle as aC, type TileflowRuntimeStyleOptions as aD, type TileflowRuntimeSystemThemes as aE, type TileflowRuntimeViewOptions as aF, type TileflowSessionController as aG, type TileflowSessionGrantResponse as aH, type TileflowStringStyleValue as aI, type TileflowStructuralStyleValue as aJ, type TileflowStyleFontFace as aK, type TileflowStyleValue as aL, type TileflowSymbolPlacement as aM, type TileflowSymbolPlacementStyle as aN, type TileflowSymbolZOrder as aO, type TileflowTerrain as aP, type TileflowTerrainConfig as aQ, type TileflowTerrainContourLabelStyle as aR, type TileflowTerrainContourLineStyle as aS, type TileflowTerrainContoursConfig as aT, type TileflowTerrainEncoding as aU, type TileflowTerrainHillshadeStyle as aV, type TileflowTerrainLayerRange as aW, type TileflowTerrainMode as aX, type TileflowTextAnchor as aY, type TileflowTextJustify as aZ, type TileflowTextLayout as a_, type TileflowRoadClass as aa, type TileflowRoadClassStyle as ab, type TileflowRoadCrossingStyle as ac, type TileflowRoadDetail as ad, type TileflowRoadExtras as ae, type TileflowRoadHierarchy as af, type TileflowRoadLabelDetail as ag, type TileflowRoadLayerStyle as ah, type TileflowRoadModifier as ai, type TileflowRoadOutline as aj, type TileflowRoadRestriction as ak, type TileflowRoadRoundaboutStyle as al, type TileflowRoadServiceType as am, type TileflowRoadShieldDetail as an, type TileflowRoadShieldStyles as ao, type TileflowRoadSidewalkStyle as ap, type TileflowRoadStructure as aq, type TileflowRoadTreatmentLayerStyle as ar, type TileflowRoadTreatmentLineStyle as as, type TileflowRoadTreatmentStyle as at, type TileflowRoadWeight as au, type TileflowRuntimeCenterLike as av, type TileflowRuntimeColorScheme as aw, type TileflowRuntimeManifestMap as ax, type TileflowRuntimeManifestMapEntry as ay, type TileflowRuntimeManifestTheme as az, type TileflowFixedValue as b, type TileflowTextStyle as b0, type TileflowThemeColorAlpha as b1, type TileflowThemeColorMix as b2, type TileflowThemeColorValue as b3, type TileflowThemeFontValue as b4, type TileflowThemeImageValue as b5, type TileflowThemeNumberValue as b6, type TileflowThemeSelection as b7, type TileflowThemeTokenCategory as b8, type TileflowThemeValue as b9, resolveTileflowRuntimeTheme as bA, resolveTileflowRuntimeView as bB, resolveTileflowStaticImageUrl as bC, safeParseTileflowRuntimeManifest as bD, shouldLoadTileflowManifest as bE, startTileflowSession as bF, tileflowPoiCategories as bG, tileflowRuntimeManifestLimits as bH, tileflowRuntimeManifestSchema as bI, tileflowRuntimeManifestVersion as bJ, tileflowStyleFontFaceLimits as bK, tileflowStyleFontFacesMetadataKey as bL, tileflowThemeTokenCategories as bM, token as bN, validateTileflowRuntimeSource as bO, validateTileflowThemeSelection as bP, zoom as bQ, type TileflowTypographyStyle as bR, type ResolvedTileflowTypography as bS, normalizeTileflowSurfaceId as bT, type TileflowViewConfig as ba, type TileflowWaterLabelClass as bb, type TileflowZoomInterpolation as bc, type TileflowZoomValue as bd, type ValidationResult as be, assertValidTileflowRuntimeSource as bf, clearTileflowManifestCache as bg, color as bh, createTileflowSessionController as bi, createTileflowSessionId as bj, defaultTileflowManifestUrl as bk, defaultTileflowRuntimeView as bl, fixed as bm, getTileflowAnalyticsApiUrl as bn, getTileflowStyleFontFaces as bo, inferTileflowAnalyticsFromStyleUrl as bp, loadTileflowManifest as bq, mergeTileflowAnalytics as br, normalizeTileflowRuntimeCenter as bs, normalizeTileflowStaticImageSize as bt, normalizeTileflowUrl as bu, parseTileflowRuntimeManifest as bv, resolveTileflowAnalyticsRequestUrl as bw, resolveTileflowManifestMap as bx, resolveTileflowMapMode as by, resolveTileflowRuntimeStyle as bz, type TileflowThemeTokenReference as c, type TileflowThemeColorOperation as d, type TileflowBackgroundStyle as e, type TileflowCircleStyle as f, type TileflowExtrusionStyle as g, type TileflowFillStyle as h, type TileflowLineStyle as i, type TileflowSymbolStyle as j, type TileflowRoadsModuleOptions as k, type TileflowRoadsModuleConfig as l, type TileflowLabelsModuleOptions as m, type TileflowLabelsModuleConfig as n, type TileflowPoiModuleOptions as o, type TileflowPoiModuleConfig as p, type MapLibreSprite as q, type TileflowAerodromeCodeDetail as r, type TileflowAlignment as s, type TileflowAnalytics as t, type TileflowAreaStyle as u, type TileflowBackgroundPaint as v, type TileflowCirclePaint as w, type TileflowColor as x, type TileflowColorStyleValue as y, type TileflowExtrusionPaint as z };
+export { type TileflowManifestFetchOptions as $, type TileflowAreaStyle as A, type TileflowBackgroundPaint as B, type TileflowCirclePaint as C, type TileflowColor as D, type TileflowColorStyleValue as E, type TileflowExtrusionPaint as F, type TileflowFillPaint as G, type TileflowIconAnchor as H, type TileflowIconLayout as I, type TileflowIconPaint as J, type TileflowIconStyle as K, type TileflowIconTextFit as L, type MapLibreStyle as M, type TileflowImageStyleValue as N, type TileflowLabelDetail as O, type TileflowLabelLanguage as P, type TileflowLabelStyles as Q, type TileflowLayerRange as R, type TileflowLight as S, type TileflowRuntimeManifest as T, type TileflowLineCap as U, type ValidationMessage as V, type TileflowLineHatchStyle as W, type TileflowLineJoin as X, type TileflowLineLayout as Y, type TileflowLinePaint as Z, type TileflowLineStackStyle as _, type TileflowRuntimeColorScheme as a, type TileflowTextJustify as a$, type TileflowManifestLoadOptions as a0, type TileflowMapMode as a1, type TileflowMapModeOptions as a2, type TileflowMarkerSymbolStyle as a3, type TileflowMountainBikeScale as a4, type TileflowNumberInsetsStyleValue as a5, type TileflowNumberStyleValue as a6, type TileflowPlaceLabelClass as a7, type TileflowPoiCategory as a8, type TileflowPoiCategoryStyle as a9, type TileflowRoadWeight as aA, type TileflowRuntimeCenterLike as aB, type TileflowRuntimeManifestMap as aC, type TileflowRuntimeSource as aD, type TileflowRuntimeSourceValidation as aE, type TileflowRuntimeStyle as aF, type TileflowRuntimeStyleOptions as aG, type TileflowRuntimeViewOptions as aH, type TileflowSessionController as aI, type TileflowSessionGrantResponse as aJ, type TileflowStringStyleValue as aK, type TileflowStructuralStyleValue as aL, type TileflowStyleFontFace as aM, type TileflowStyleValue as aN, type TileflowSymbolPlacement as aO, type TileflowSymbolPlacementStyle as aP, type TileflowSymbolZOrder as aQ, type TileflowTerrain as aR, type TileflowTerrainConfig as aS, type TileflowTerrainContourLabelStyle as aT, type TileflowTerrainContourLineStyle as aU, type TileflowTerrainContoursConfig as aV, type TileflowTerrainEncoding as aW, type TileflowTerrainHillshadeStyle as aX, type TileflowTerrainLayerRange as aY, type TileflowTerrainMode as aZ, type TileflowTextAnchor as a_, type TileflowPoiColorMode as aa, type TileflowPoiDensity as ab, type TileflowPriorityOrder as ac, type TileflowProjection as ad, type TileflowResolvedRuntimeTheme as ae, type TileflowRoadAreaStyle as af, type TileflowRoadClass as ag, type TileflowRoadClassStyle as ah, type TileflowRoadCrossingStyle as ai, type TileflowRoadDetail as aj, type TileflowRoadExtras as ak, type TileflowRoadHierarchy as al, type TileflowRoadLabelDetail as am, type TileflowRoadLayerStyle as an, type TileflowRoadModifier as ao, type TileflowRoadOutline as ap, type TileflowRoadRestriction as aq, type TileflowRoadRoundaboutStyle as ar, type TileflowRoadServiceType as as, type TileflowRoadShieldDetail as at, type TileflowRoadShieldStyles as au, type TileflowRoadSidewalkStyle as av, type TileflowRoadStructure as aw, type TileflowRoadTreatmentLayerStyle as ax, type TileflowRoadTreatmentLineStyle as ay, type TileflowRoadTreatmentStyle as az, type TileflowRuntimeManifestMapEntry as b, type TileflowTextLayout as b0, type TileflowTextPaint as b1, type TileflowTextStyle as b2, type TileflowThemeColorAlpha as b3, type TileflowThemeColorMix as b4, type TileflowThemeColorValue as b5, type TileflowThemeFontValue as b6, type TileflowThemeImageValue as b7, type TileflowThemeNumberValue as b8, type TileflowThemeSelection as b9, resolveTileflowRuntimeStyle as bA, resolveTileflowRuntimeTheme as bB, resolveTileflowRuntimeView as bC, resolveTileflowStaticImageUrl as bD, shouldLoadTileflowManifest as bE, startTileflowSession as bF, tileflowPoiCategories as bG, tileflowStyleFontFaceLimits as bH, tileflowStyleFontFacesMetadataKey as bI, tileflowThemeTokenCategories as bJ, token as bK, validateTileflowRuntimeSource as bL, validateTileflowThemeSelection as bM, zoom as bN, type TileflowTypographyStyle as bO, type ResolvedTileflowTypography as bP, normalizeTileflowSurfaceId as bQ, type TileflowThemeTokenCategory as ba, type TileflowThemeValue as bb, type TileflowViewConfig as bc, type TileflowWaterLabelClass as bd, type TileflowZoomInterpolation as be, type TileflowZoomValue as bf, type ValidationResult as bg, assertValidTileflowRuntimeSource as bh, clearTileflowManifestCache as bi, color as bj, createTileflowSessionController as bk, createTileflowSessionId as bl, defaultTileflowManifestUrl as bm, defaultTileflowRuntimeView as bn, fixed as bo, getTileflowAnalyticsApiUrl as bp, getTileflowStyleFontFaces as bq, inferTileflowAnalyticsFromStyleUrl as br, loadTileflowManifest as bs, mergeTileflowAnalytics as bt, normalizeTileflowRuntimeCenter as bu, normalizeTileflowStaticImageSize as bv, normalizeTileflowUrl as bw, resolveTileflowAnalyticsRequestUrl as bx, resolveTileflowManifestMap as by, resolveTileflowMapMode as bz, type TileflowRuntimeManifestTheme as c, type TileflowRuntimeSystemThemes as d, tileflowRuntimeManifestVersion as e, type TileflowExpression as f, type TileflowFixedValue as g, type TileflowThemeTokenReference as h, type TileflowThemeColorOperation as i, type TileflowBackgroundStyle as j, type TileflowCircleStyle as k, type TileflowExtrusionStyle as l, type TileflowFillStyle as m, type TileflowLineStyle as n, type TileflowSymbolStyle as o, type TileflowRoadsModuleOptions as p, type TileflowRoadsModuleConfig as q, type TileflowLabelsModuleOptions as r, type TileflowLabelsModuleConfig as s, tileflowRuntimeManifestLimits as t, type TileflowPoiModuleOptions as u, type TileflowPoiModuleConfig as v, type MapLibreSprite as w, type TileflowAerodromeCodeDetail as x, type TileflowAlignment as y, type TileflowAnalytics as z };

package/dist/manifest.d.ts

@@ -1,2 +1,9 @@
-import 'zod';
-export { aw as TileflowRuntimeColorScheme, T as TileflowRuntimeManifest, ay as TileflowRuntimeManifestMapEntry, az as TileflowRuntimeManifestTheme, aE as TileflowRuntimeSystemThemes, bv as parseTileflowRuntimeManifest, bD as safeParseTileflowRuntimeManifest, bH as tileflowRuntimeManifestLimits, bI as tileflowRuntimeManifestSchema, bJ as tileflowRuntimeManifestVersion } from './manifest-B5GKVMFE.js';
+import { z } from 'zod';
+import { T as TileflowRuntimeManifest } from './manifest-types-BdGjIYy-.js';
+export { a as TileflowRuntimeColorScheme, b as TileflowRuntimeManifestMapEntry, c as TileflowRuntimeManifestTheme, d as TileflowRuntimeSystemThemes, t as tileflowRuntimeManifestLimits, e as tileflowRuntimeManifestVersion } from './manifest-types-BdGjIYy-.js';
+
+declare const tileflowRuntimeManifestSchema: z.ZodType<TileflowRuntimeManifest>;
+declare function parseTileflowRuntimeManifest(input: unknown): TileflowRuntimeManifest;
+declare function safeParseTileflowRuntimeManifest(input: unknown): z.ZodSafeParseResult<TileflowRuntimeManifest>;
+
+export { TileflowRuntimeManifest, parseTileflowRuntimeManifest, safeParseTileflowRuntimeManifest, tileflowRuntimeManifestSchema };

package/dist/manifest.js

@@ -1,8 +1,6 @@
-// src/manifest.ts
-import { z as z2 } from "zod";
-
-// src/portable-identity.ts
-import { z } from "zod";
+// src/manifest-types.ts
+var tileflowRuntimeManifestVersion = 1;
+var tileflowRuntimeManifestLimits = Object.freeze({ maximumBytes: 1024 * 1024 });
 
 // src/portable-identity-rules.ts
 var tileflowPortableIdMaximumLength = 64;
@@ -14,17 +12,41 @@ function isTileflowThemeName(value) {
   return isTileflowPortableId(value) && value !== "system";
 }
 
-// src/portable-identity.ts
-var tileflowPortableIdSchema = z.string().min(1).max(tileflowPortableIdMaximumLength).regex(tileflowPortableIdPattern, {
-  message: "Expected lowercase kebab-case beginning with a letter"
-}).refine(
-  (name) => !["constructor", "prototype"].includes(name) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(name),
-  "Expected a portable identifier that is not a reserved filename or prototype key"
-);
-var tileflowThemeNameSchema = tileflowPortableIdSchema.refine(
-  isTileflowThemeName,
-  "Expected a concrete theme name; system is browser-only"
-);
+// src/portable-identity-schema.ts
+function createPortableIdentitySchemas(operations) {
+  const bounded = operations.maxLength(
+    operations.minLength(operations.string(), 1),
+    tileflowPortableIdMaximumLength
+  );
+  const pattern = operations.regex(
+    bounded,
+    tileflowPortableIdPattern,
+    "Expected lowercase kebab-case beginning with a letter"
+  );
+  const tileflowPortableIdSchema2 = operations.refine(
+    pattern,
+    (name) => !["constructor", "prototype"].includes(name) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(name),
+    "Expected a portable identifier that is not a reserved filename or prototype key"
+  );
+  const tileflowThemeNameSchema2 = operations.refine(
+    tileflowPortableIdSchema2,
+    isTileflowThemeName,
+    "Expected a concrete theme name; system is browser-only"
+  );
+  return { tileflowPortableIdSchema: tileflowPortableIdSchema2, tileflowThemeNameSchema: tileflowThemeNameSchema2 };
+}
+
+// src/runtime-view-schema.ts
+function createTileflowRuntimeViewSchema(operations) {
+  return operations.object({
+    bearing: operations.optional(operations.number(-180, 180)),
+    center: operations.optional(
+      operations.tuplePair(operations.number(-180, 180), operations.number(-90, 90))
+    ),
+    pitch: operations.optional(operations.number(0, 85)),
+    zoom: operations.optional(operations.number(0, 24))
+  });
+}
 
 // src/themes/model.ts
 var tileflowThemeLimits = Object.freeze({ maxThemes: 64 });
@@ -37,204 +59,305 @@ var themeTypographyKeys = [
   "water"
 ];
 
-// src/manifest.ts
-var tileflowRuntimeManifestVersion = 1;
-var tileflowRuntimeManifestLimits = Object.freeze({ maximumBytes: 1024 * 1024 });
-var safeTextSchema = z2.string().min(1).max(2048).refine((value) => value === value.trim(), "Expected text without surrounding whitespace").refine((value) => !/[\p{Cc}\\]/u.test(value), "Expected safe text");
-var publicResourceUrlSchema = safeTextSchema.refine(isPublicResourceUrl, {
-  message: "Expected an HTTP(S), root-relative, or path-relative public URL"
-});
-var apiOriginSchema = safeTextSchema.refine(isApiOrigin, {
-  message: "Expected an absolute HTTP(S) origin without path, credentials, query, or fragment"
-});
-var viewSchema = z2.object({
-  bearing: z2.number().finite().min(-180).max(180).optional(),
-  center: z2.tuple([z2.number().finite().min(-180).max(180), z2.number().finite().min(-90).max(90)]).optional(),
-  pitch: z2.number().finite().min(0).max(85).optional(),
-  zoom: z2.number().finite().min(0).max(24).optional()
-}).strict();
-var fontFaceSchema = z2.object({
-  family: safeTextSchema.max(100),
-  source: publicResourceUrlSchema,
-  style: z2.enum(["italic", "normal", "oblique"]).optional(),
-  weight: z2.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"]).optional()
-}).strict();
-var fontFacesSchema = z2.array(fontFaceSchema).max(16).superRefine(validateUniqueFontFaces);
-var manifestThemeSchema = z2.object({
-  colorScheme: z2.enum(["dark", "light"]),
-  fontFaces: fontFacesSchema.optional(),
-  revision: safeTextSchema.max(128).optional(),
-  styleId: safeTextSchema.max(128).optional(),
-  styleUrl: publicResourceUrlSchema
-}).strict();
-var manifestMapSchema = z2.object({
-  apiUrl: apiOriginSchema.optional(),
-  defaultTheme: tileflowThemeNameSchema,
-  environment: safeTextSchema.max(128).optional(),
-  mapId: safeTextSchema.max(128).optional(),
-  systemThemes: z2.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict().optional(),
-  themes: z2.record(tileflowThemeNameSchema, manifestThemeSchema),
-  usageMode: z2.literal("session").optional(),
-  view: viewSchema.optional(),
-  worldGeneration: z2.literal("v1").optional()
-}).strict().superRefine((entry, context) => {
-  const names = Object.keys(entry.themes);
-  if (names.length === 0) {
-    context.addIssue({ code: "custom", message: "Expected at least one theme", path: ["themes"] });
-  }
-  if (names.length > tileflowThemeLimits.maxThemes) {
-    context.addIssue({
-      code: "too_big",
-      maximum: tileflowThemeLimits.maxThemes,
-      origin: "object",
-      path: ["themes"]
-    });
-  }
-  if (!Object.hasOwn(entry.themes, entry.defaultTheme)) {
-    context.addIssue({
-      code: "custom",
-      message: "defaultTheme must name a declared theme",
-      path: ["defaultTheme"]
-    });
-  }
-  if (entry.systemThemes) {
-    for (const colorScheme of ["light", "dark"]) {
-      const name = entry.systemThemes[colorScheme];
-      const theme = entry.themes[name];
-      if (!theme) {
+// src/manifest-schema.ts
+function createTileflowRuntimeManifestSchema(primitives, operations, identities = createPortableIdentitySchemas(operations)) {
+  const { tileflowPortableIdSchema: tileflowPortableIdSchema2, tileflowThemeNameSchema: tileflowThemeNameSchema2 } = identities;
+  const safeTextSchema = operations.refine(
+    operations.refine(
+      operations.maxLength(operations.minLength(operations.string(), 1), 2048),
+      (value) => value === value.trim(),
+      "Expected text without surrounding whitespace"
+    ),
+    (value) => !/[\p{Cc}\\]/u.test(value),
+    "Expected safe text"
+  );
+  const publicResourceUrlSchema = operations.refine(
+    safeTextSchema,
+    isPublicResourceUrl,
+    "Expected an HTTP(S), root-relative, or path-relative public URL"
+  );
+  const apiOriginSchema = operations.refine(
+    safeTextSchema,
+    isApiOrigin,
+    "Expected an absolute HTTP(S) origin without path, credentials, query, or fragment"
+  );
+  const viewSchema = createTileflowRuntimeViewSchema(operations);
+  const fontFaceSchema = operations.object({
+    family: operations.maxLength(safeTextSchema, 100),
+    source: publicResourceUrlSchema,
+    style: operations.optional(operations.enum(["italic", "normal", "oblique"])),
+    weight: operations.optional(
+      operations.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"])
+    )
+  });
+  const fontFacesSchema = operations.superRefine(
+    operations.maxLength(operations.array(fontFaceSchema), 16),
+    validateUniqueFontFaces
+  );
+  const manifestThemeSchema = operations.object({
+    colorScheme: operations.enum(["dark", "light"]),
+    fontFaces: operations.optional(fontFacesSchema),
+    revision: operations.optional(operations.maxLength(safeTextSchema, 128)),
+    styleId: operations.optional(operations.maxLength(safeTextSchema, 128)),
+    styleUrl: publicResourceUrlSchema
+  });
+  const manifestMapSchema = operations.superRefine(
+    operations.object({
+      apiUrl: operations.optional(apiOriginSchema),
+      defaultTheme: tileflowThemeNameSchema2,
+      environment: operations.optional(operations.maxLength(safeTextSchema, 128)),
+      mapId: operations.optional(operations.maxLength(safeTextSchema, 128)),
+      systemThemes: operations.optional(
+        operations.object({
+          dark: tileflowThemeNameSchema2,
+          light: tileflowThemeNameSchema2
+        })
+      ),
+      themes: operations.record(tileflowThemeNameSchema2, manifestThemeSchema),
+      usageMode: operations.optional(operations.literal("session")),
+      view: operations.optional(viewSchema),
+      worldGeneration: operations.optional(operations.literal("v1"))
+    }),
+    (entry, context) => {
+      const names = Object.keys(entry.themes);
+      if (names.length === 0) {
+        context.addIssue({
+          code: "custom",
+          message: "Expected at least one theme",
+          path: ["themes"]
+        });
+      }
+      if (names.length > tileflowThemeLimits.maxThemes) {
+        context.addIssue({
+          code: "too_big",
+          maximum: tileflowThemeLimits.maxThemes,
+          origin: "object",
+          path: ["themes"]
+        });
+      }
+      if (!Object.hasOwn(entry.themes, entry.defaultTheme)) {
         context.addIssue({
           code: "custom",
-          message: `systemThemes.${colorScheme} must name a declared theme`,
-          path: ["systemThemes", colorScheme]
+          message: "defaultTheme must name a declared theme",
+          path: ["defaultTheme"]
         });
-      } else if (theme.colorScheme !== colorScheme) {
+      }
+      if (entry.systemThemes) {
+        for (const colorScheme of ["light", "dark"]) {
+          const name = entry.systemThemes[colorScheme];
+          const theme = entry.themes[name];
+          if (!theme) {
+            context.addIssue({
+              code: "custom",
+              message: `systemThemes.${colorScheme} must name a declared theme`,
+              path: ["systemThemes", colorScheme]
+            });
+          } else if (theme.colorScheme !== colorScheme) {
+            context.addIssue({
+              code: "custom",
+              message: `systemThemes.${colorScheme} must reference a ${colorScheme} theme`,
+              path: ["systemThemes", colorScheme]
+            });
+          }
+        }
+      }
+      if (entry.usageMode === void 0 !== (entry.worldGeneration === void 0)) {
         context.addIssue({
           code: "custom",
-          message: `systemThemes.${colorScheme} must reference a ${colorScheme} theme`,
-          path: ["systemThemes", colorScheme]
+          message: "usageMode and worldGeneration must be declared together"
         });
       }
     }
-  }
-  if (entry.usageMode === void 0 !== (entry.worldGeneration === void 0)) {
-    context.addIssue({
-      code: "custom",
-      message: "usageMode and worldGeneration must be declared together"
-    });
-  }
-});
-var canonicalManifestSchema = z2.object({
-  apiUrl: apiOriginSchema.optional(),
-  maps: z2.record(tileflowPortableIdSchema, manifestMapSchema),
-  version: z2.literal(tileflowRuntimeManifestVersion)
-}).strict().superRefine((manifest, context) => {
-  const mapCount = Object.keys(manifest.maps).length;
-  if (mapCount === 0) {
-    context.addIssue({ code: "custom", message: "Expected at least one map", path: ["maps"] });
-  }
-  if (mapCount > 1e3) {
-    context.addIssue({ code: "too_big", maximum: 1e3, origin: "object", path: ["maps"] });
-  }
-  if (new TextEncoder().encode(JSON.stringify(manifest)).byteLength > tileflowRuntimeManifestLimits.maximumBytes) {
-    context.addIssue({
-      code: "too_big",
-      maximum: tileflowRuntimeManifestLimits.maximumBytes,
-      origin: "string",
-      message: "Manifest JSON exceeds the 1 MiB limit"
-    });
-  }
-});
-var safeManifestInputSchema = z2.unknown().superRefine((input, context) => {
-  const unsafe = findUnsafeManifestStructure(input);
-  if (unsafe) {
-    context.addIssue({
-      code: "custom",
-      message: unsafe.reason === "prototype" ? "Expected plain manifest objects" : "Expected no prototype-mutating keys",
-      path: unsafe.path
-    });
-  }
-});
-var tileflowRuntimeManifestSchema = safeManifestInputSchema.pipe(canonicalManifestSchema);
-function parseTileflowRuntimeManifest(input) {
-  return tileflowRuntimeManifestSchema.parse(input);
-}
-function safeParseTileflowRuntimeManifest(input) {
-  return tileflowRuntimeManifestSchema.safeParse(input);
-}
-function validateUniqueFontFaces(fontFaces, context) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const [index, fontFace] of fontFaces.entries()) {
-    const identity = `${fontFace.family}\0${fontFace.style ?? "normal"}\0${fontFace.weight ?? "400"}`;
-    const first = seen.get(identity);
-    if (first !== void 0) {
+  );
+  const canonicalManifestSchema = operations.superRefine(
+    operations.object({
+      apiUrl: operations.optional(apiOriginSchema),
+      maps: operations.record(tileflowPortableIdSchema2, manifestMapSchema),
+      version: operations.literal(tileflowRuntimeManifestVersion)
+    }),
+    (manifest, context) => {
+      const mapCount = Object.keys(manifest.maps).length;
+      if (mapCount === 0) {
+        context.addIssue({ code: "custom", message: "Expected at least one map", path: ["maps"] });
+      }
+      if (mapCount > 1e3) {
+        context.addIssue({ code: "too_big", maximum: 1e3, origin: "object", path: ["maps"] });
+      }
+      if (primitives.utf8ByteLength(JSON.stringify(manifest)) > tileflowRuntimeManifestLimits.maximumBytes) {
+        context.addIssue({
+          code: "too_big",
+          maximum: tileflowRuntimeManifestLimits.maximumBytes,
+          origin: "string",
+          message: "Manifest JSON exceeds the 1 MiB limit"
+        });
+      }
+    }
+  );
+  const safeManifestInputSchema = operations.superRefine(operations.unknown(), (input, context) => {
+    const unsafe = findUnsafeManifestStructure(input);
+    if (unsafe) {
       context.addIssue({
         code: "custom",
-        message: `Duplicate font face identity; first declared at index ${first}`,
-        path: [index]
+        message: unsafe.reason === "prototype" ? "Expected plain manifest objects" : "Expected no prototype-mutating keys",
+        path: unsafe.path
       });
-      continue;
     }
-    seen.set(identity, index);
+  });
+  function validateUniqueFontFaces(fontFaces, context) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const [index, fontFace] of fontFaces.entries()) {
+      const identity = `${fontFace.family}\0${fontFace.style ?? "normal"}\0${fontFace.weight ?? "400"}`;
+      const first = seen.get(identity);
+      if (first !== void 0) {
+        context.addIssue({
+          code: "custom",
+          message: `Duplicate font face identity; first declared at index ${first}`,
+          path: [index]
+        });
+        continue;
+      }
+      seen.set(identity, index);
+    }
   }
-}
-function isPublicResourceUrl(value) {
-  if (value.startsWith("//")) return false;
-  if (!value.startsWith("/") && !value.startsWith("./") && !value.startsWith("../") && !isAbsolutePublicUrl(value)) {
-    return false;
+  function isPublicResourceUrl(value) {
+    if (value.startsWith("//")) return false;
+    if (!value.startsWith("/") && !value.startsWith("./") && !value.startsWith("../") && !isAbsolutePublicUrl(value)) {
+      return false;
+    }
+    return isSafeResolvedPublicUrl(value);
   }
-  return isSafeResolvedPublicUrl(value);
-}
-function isAbsolutePublicUrl(value) {
-  try {
-    const url = new URL(value);
-    return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash && !hasEncodedPathSeparator(value);
-  } catch {
-    return false;
+  function isAbsolutePublicUrl(value) {
+    try {
+      const url = primitives.parseUrl(value);
+      return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash && !hasEncodedPathSeparator(value);
+    } catch {
+      return false;
+    }
   }
-}
-function isSafeResolvedPublicUrl(value) {
-  try {
-    const url = new URL(value, "https://manifest.invalid/owner/manifest.json");
-    return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash && !hasEncodedPathSeparator(value);
-  } catch {
-    return false;
+  function isSafeResolvedPublicUrl(value) {
+    try {
+      const url = primitives.parseUrl(value, "https://manifest.invalid/owner/manifest.json");
+      return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash && !hasEncodedPathSeparator(value);
+    } catch {
+      return false;
+    }
   }
-}
-function hasEncodedPathSeparator(value) {
-  return /%(?:2f|5c)/iu.test(value);
-}
-function isApiOrigin(value) {
-  try {
-    const url = new URL(value);
-    return isAbsolutePublicUrl(value) && url.pathname === "/" && !url.search && value.replace(/\/$/u, "") === url.origin;
-  } catch {
-    return false;
+  function hasEncodedPathSeparator(value) {
+    return /%(?:2f|5c)/iu.test(value);
   }
-}
-function findUnsafeManifestStructure(input) {
-  if (!input || typeof input !== "object") return void 0;
-  const pending = [{ path: [], value: input }];
-  const visited = /* @__PURE__ */ new WeakSet();
-  while (pending.length > 0) {
-    const current = pending.pop();
-    if (visited.has(current.value)) continue;
-    visited.add(current.value);
-    if (!Array.isArray(current.value)) {
-      const prototype = Object.getPrototypeOf(current.value);
-      if (prototype !== Object.prototype && prototype !== null) {
-        return { path: current.path, reason: "prototype" };
-      }
+  function isApiOrigin(value) {
+    try {
+      const url = primitives.parseUrl(value);
+      return isAbsolutePublicUrl(value) && url.pathname === "/" && !url.search && value.replace(/\/$/u, "") === url.origin;
+    } catch {
+      return false;
     }
-    for (const key of Object.keys(current.value)) {
-      const path = [...current.path, Array.isArray(current.value) ? Number(key) : key];
-      if (key === "__proto__") return { path, reason: "key" };
-      const descriptor = Object.getOwnPropertyDescriptor(current.value, key);
-      if (descriptor && "value" in descriptor && descriptor.value && typeof descriptor.value === "object") {
-        pending.push({ path, value: descriptor.value });
+  }
+  function findUnsafeManifestStructure(input) {
+    if (!input || typeof input !== "object") return void 0;
+    const pending = [
+      { path: [], value: input }
+    ];
+    const visited = /* @__PURE__ */ new WeakSet();
+    while (pending.length > 0) {
+      const current = pending.pop();
+      if (visited.has(current.value)) continue;
+      visited.add(current.value);
+      if (!Array.isArray(current.value)) {
+        const prototype = Object.getPrototypeOf(current.value);
+        if (prototype !== Object.prototype && prototype !== null) {
+          return { path: current.path, reason: "prototype" };
+        }
+      }
+      for (const key of Object.keys(current.value)) {
+        const path = [...current.path, Array.isArray(current.value) ? Number(key) : key];
+        if (key === "__proto__") return { path, reason: "key" };
+        const descriptor = Object.getOwnPropertyDescriptor(current.value, key);
+        if (descriptor && "value" in descriptor && descriptor.value && typeof descriptor.value === "object") {
+          pending.push({ path, value: descriptor.value });
+        }
       }
     }
+    return void 0;
   }
-  return void 0;
+  return operations.pipe(safeManifestInputSchema, canonicalManifestSchema);
+}
+
+// src/manifest-schema-classic.ts
+import { z as z2 } from "zod";
+
+// src/native-zod-object.ts
+import { z } from "zod";
+function strictNativeObject(shape) {
+  const object = new z.core.$ZodObject({
+    type: "object",
+    shape,
+    catchall: z.never()
+  });
+  return z.lazy(() => object);
+}
+
+// src/manifest-schema-classic.ts
+function classic(schema) {
+  return schema;
+}
+var classicManifestStringOperations = {
+  string: () => z2.string(),
+  minLength(schema, minimum) {
+    return schema.min(
+      minimum
+    );
+  },
+  maxLength(schema, maximum) {
+    return schema.max(
+      maximum
+    );
+  },
+  regex: (schema, pattern, message) => schema.regex(pattern, { message }),
+  refine: (schema, check, message) => classic(schema).refine(check, message)
+};
+var classicManifestSchemaOperations = {
+  ...classicManifestStringOperations,
+  number: (minimum, maximum) => z2.number().finite().min(minimum).max(maximum),
+  unknown: () => z2.unknown(),
+  optional: (schema) => classic(schema).optional(),
+  array: (schema) => z2.array(classic(schema)),
+  enum(values) {
+    return z2.enum(values);
+  },
+  literal: (value) => z2.literal(value),
+  tuplePair(left, right) {
+    return z2.tuple([classic(left), classic(right)]);
+  },
+  object(shape) {
+    return strictNativeObject(shape);
+  },
+  record(key, value) {
+    return z2.record(classic(key), classic(value));
+  },
+  superRefine: (schema, check) => classic(schema).superRefine(check),
+  pipe: (input, output) => classic(input).pipe(classic(output))
+};
+
+// src/portable-identity.ts
+var schemas = createPortableIdentitySchemas(classicManifestStringOperations);
+var tileflowPortableIdSchema = schemas.tileflowPortableIdSchema;
+var tileflowThemeNameSchema = schemas.tileflowThemeNameSchema;
+
+// src/manifest.ts
+var tileflowRuntimeManifestSchema = createTileflowRuntimeManifestSchema(
+  {
+    parseUrl: (value, base) => base === void 0 ? new URL(value) : new URL(value, base),
+    utf8ByteLength: (value) => new TextEncoder().encode(value).byteLength
+  },
+  classicManifestSchemaOperations,
+  { tileflowPortableIdSchema, tileflowThemeNameSchema }
+);
+function parseTileflowRuntimeManifest(input) {
+  return tileflowRuntimeManifestSchema.parse(input);
+}
+function safeParseTileflowRuntimeManifest(input) {
+  return tileflowRuntimeManifestSchema.safeParse(input);
 }
 export {
   parseTileflowRuntimeManifest,