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

package/dist/runtime.d.ts

@@ -1,2 +1 @@
-export { t as TileflowAnalytics, U as TileflowManifestFetchOptions, W as TileflowManifestLoadOptions, X as TileflowMapMode, Y as TileflowMapModeOptions, a8 as TileflowResolvedRuntimeTheme, av as TileflowRuntimeCenterLike, aw as TileflowRuntimeColorScheme, T as TileflowRuntimeManifest, ax as TileflowRuntimeManifestMap, ay as TileflowRuntimeManifestMapEntry, az as TileflowRuntimeManifestTheme, aA as TileflowRuntimeSource, aB as TileflowRuntimeSourceValidation, aC as TileflowRuntimeStyle, aD as TileflowRuntimeStyleOptions, aE as TileflowRuntimeSystemThemes, aF as TileflowRuntimeViewOptions, aG as TileflowSessionController, aH as TileflowSessionGrantResponse, aK as TileflowStyleFontFace, b7 as TileflowThemeSelection, bf as assertValidTileflowRuntimeSource, bg as clearTileflowManifestCache, bi as createTileflowSessionController, bj as createTileflowSessionId, bk as defaultTileflowManifestUrl, bl as defaultTileflowRuntimeView, bn as getTileflowAnalyticsApiUrl, bo as getTileflowStyleFontFaces, bp as inferTileflowAnalyticsFromStyleUrl, bq as loadTileflowManifest, br as mergeTileflowAnalytics, bs as normalizeTileflowRuntimeCenter, bt as normalizeTileflowStaticImageSize, bT as normalizeTileflowSurfaceId, bu as normalizeTileflowUrl, bw as resolveTileflowAnalyticsRequestUrl, bx as resolveTileflowManifestMap, by as resolveTileflowMapMode, bz as resolveTileflowRuntimeStyle, bA as resolveTileflowRuntimeTheme, bB as resolveTileflowRuntimeView, bC as resolveTileflowStaticImageUrl, bE as shouldLoadTileflowManifest, bF as startTileflowSession, bK as tileflowStyleFontFaceLimits, bL as tileflowStyleFontFacesMetadataKey, bO as validateTileflowRuntimeSource, bP as validateTileflowThemeSelection } from './manifest-B5GKVMFE.js';
-import 'zod';
+export { z as TileflowAnalytics, $ as TileflowManifestFetchOptions, a0 as TileflowManifestLoadOptions, a1 as TileflowMapMode, a2 as TileflowMapModeOptions, ae as TileflowResolvedRuntimeTheme, aB as TileflowRuntimeCenterLike, a as TileflowRuntimeColorScheme, T as TileflowRuntimeManifest, aC as TileflowRuntimeManifestMap, b as TileflowRuntimeManifestMapEntry, c as TileflowRuntimeManifestTheme, aD as TileflowRuntimeSource, aE as TileflowRuntimeSourceValidation, aF as TileflowRuntimeStyle, aG as TileflowRuntimeStyleOptions, d as TileflowRuntimeSystemThemes, aH as TileflowRuntimeViewOptions, aI as TileflowSessionController, aJ as TileflowSessionGrantResponse, aM as TileflowStyleFontFace, b9 as TileflowThemeSelection, bh as assertValidTileflowRuntimeSource, bi as clearTileflowManifestCache, bk as createTileflowSessionController, bl as createTileflowSessionId, bm as defaultTileflowManifestUrl, bn as defaultTileflowRuntimeView, bp as getTileflowAnalyticsApiUrl, bq as getTileflowStyleFontFaces, br as inferTileflowAnalyticsFromStyleUrl, bs as loadTileflowManifest, bt as mergeTileflowAnalytics, bu as normalizeTileflowRuntimeCenter, bv as normalizeTileflowStaticImageSize, bQ as normalizeTileflowSurfaceId, bw as normalizeTileflowUrl, bx as resolveTileflowAnalyticsRequestUrl, by as resolveTileflowManifestMap, bz as resolveTileflowMapMode, bA as resolveTileflowRuntimeStyle, bB as resolveTileflowRuntimeTheme, bC as resolveTileflowRuntimeView, bD as resolveTileflowStaticImageUrl, bE as shouldLoadTileflowManifest, bF as startTileflowSession, bH as tileflowStyleFontFaceLimits, bI as tileflowStyleFontFacesMetadataKey, bL as validateTileflowRuntimeSource, bM as validateTileflowThemeSelection } from './manifest-types-BdGjIYy-.js';

package/dist/runtime.js

@@ -29,29 +29,59 @@ var init_portable_identity_rules = __esm({
   }
 });
 
-// src/portable-identity.ts
-import { z } from "zod";
-var tileflowPortableIdSchema, tileflowThemeNameSchema;
-var init_portable_identity = __esm({
-  "src/portable-identity.ts"() {
+// src/manifest-types.ts
+var tileflowRuntimeManifestVersion, tileflowRuntimeManifestLimits;
+var init_manifest_types = __esm({
+  "src/manifest-types.ts"() {
+    "use strict";
+    tileflowRuntimeManifestVersion = 1;
+    tileflowRuntimeManifestLimits = Object.freeze({ maximumBytes: 1024 * 1024 });
+  }
+});
+
+// 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 };
+}
+var init_portable_identity_schema = __esm({
+  "src/portable-identity-schema.ts"() {
     "use strict";
     init_portable_identity_rules();
-    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"
-    );
-    tileflowThemeNameSchema = tileflowPortableIdSchema.refine(
-      isTileflowThemeName,
-      "Expected a concrete theme name; system is browser-only"
-    );
   }
 });
 
-// src/themes/visual-semantics.ts
-var init_visual_semantics = __esm({
-  "src/themes/visual-semantics.ts"() {
+// 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))
+  });
+}
+var init_runtime_view_schema = __esm({
+  "src/runtime-view-schema.ts"() {
     "use strict";
   }
 });
@@ -73,155 +103,73 @@ var init_model = __esm({
   }
 });
 
-// src/themes/index.ts
-var init_themes = __esm({
-  "src/themes/index.ts"() {
-    "use strict";
-    init_model();
-    init_visual_semantics();
-  }
-});
-
-// src/manifest.ts
-var manifest_exports = {};
-__export(manifest_exports, {
-  parseTileflowRuntimeManifest: () => parseTileflowRuntimeManifest,
-  safeParseTileflowRuntimeManifest: () => safeParseTileflowRuntimeManifest,
-  tileflowRuntimeManifestLimits: () => tileflowRuntimeManifestLimits,
-  tileflowRuntimeManifestSchema: () => tileflowRuntimeManifestSchema,
-  tileflowRuntimeManifestVersion: () => tileflowRuntimeManifestVersion
-});
-import { z as z2 } from "zod";
-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) {
-      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;
-  }
-  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 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 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 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;
-}
-var tileflowRuntimeManifestVersion, tileflowRuntimeManifestLimits, safeTextSchema, publicResourceUrlSchema, apiOriginSchema, viewSchema, fontFaceSchema, fontFacesSchema, manifestThemeSchema, manifestMapSchema, canonicalManifestSchema, safeManifestInputSchema, tileflowRuntimeManifestSchema;
-var init_manifest = __esm({
-  "src/manifest.ts"() {
-    "use strict";
-    init_portable_identity();
-    init_themes();
-    tileflowRuntimeManifestVersion = 1;
-    tileflowRuntimeManifestLimits = Object.freeze({ maximumBytes: 1024 * 1024 });
-    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");
-    publicResourceUrlSchema = safeTextSchema.refine(isPublicResourceUrl, {
-      message: "Expected an HTTP(S), root-relative, or path-relative public URL"
-    });
-    apiOriginSchema = safeTextSchema.refine(isApiOrigin, {
-      message: "Expected an absolute HTTP(S) origin without path, credentials, query, or fragment"
-    });
-    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();
-    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();
-    fontFacesSchema = z2.array(fontFaceSchema).max(16).superRefine(validateUniqueFontFaces);
-    manifestThemeSchema = z2.object({
-      colorScheme: z2.enum(["dark", "light"]),
-      fontFaces: fontFacesSchema.optional(),
-      revision: safeTextSchema.max(128).optional(),
-      styleId: safeTextSchema.max(128).optional(),
-      styleUrl: publicResourceUrlSchema
-    }).strict();
-    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) => {
+// 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"] });
+        context.addIssue({
+          code: "custom",
+          message: "Expected at least one theme",
+          path: ["themes"]
+        });
       }
       if (names.length > tileflowThemeLimits.maxThemes) {
         context.addIssue({
@@ -263,12 +211,15 @@ var init_manifest = __esm({
           message: "usageMode and worldGeneration must be declared together"
         });
       }
-    });
-    canonicalManifestSchema = z2.object({
-      apiUrl: apiOriginSchema.optional(),
-      maps: z2.record(tileflowPortableIdSchema, manifestMapSchema),
-      version: z2.literal(tileflowRuntimeManifestVersion)
-    }).strict().superRefine((manifest, context) => {
+    }
+  );
+  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"] });
@@ -276,7 +227,7 @@ var init_manifest = __esm({
       if (mapCount > 1e3) {
         context.addIssue({ code: "too_big", maximum: 1e3, origin: "object", path: ["maps"] });
       }
-      if (new TextEncoder().encode(JSON.stringify(manifest)).byteLength > tileflowRuntimeManifestLimits.maximumBytes) {
+      if (primitives.utf8ByteLength(JSON.stringify(manifest)) > tileflowRuntimeManifestLimits.maximumBytes) {
         context.addIssue({
           code: "too_big",
           maximum: tileflowRuntimeManifestLimits.maximumBytes,
@@ -284,18 +235,217 @@ var init_manifest = __esm({
           message: "Manifest JSON exceeds the 1 MiB limit"
         });
       }
-    });
-    safeManifestInputSchema = z2.unknown().superRefine((input, context) => {
-      const unsafe = findUnsafeManifestStructure(input);
-      if (unsafe) {
+    }
+  );
+  const safeManifestInputSchema = operations.superRefine(operations.unknown(), (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
+      });
+    }
+  });
+  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: unsafe.reason === "prototype" ? "Expected plain manifest objects" : "Expected no prototype-mutating keys",
-          path: unsafe.path
+          message: `Duplicate font face identity; first declared at index ${first}`,
+          path: [index]
         });
+        continue;
       }
-    });
-    tileflowRuntimeManifestSchema = safeManifestInputSchema.pipe(canonicalManifestSchema);
+      seen.set(identity, index);
+    }
+  }
+  function isPublicResourceUrl(value) {
+    if (value.startsWith("//")) return false;
+    if (!value.startsWith("/") && !value.startsWith("./") && !value.startsWith("../") && !isAbsolutePublicUrl(value)) {
+      return false;
+    }
+    return isSafeResolvedPublicUrl(value);
+  }
+  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 = 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 = primitives.parseUrl(value);
+      return isAbsolutePublicUrl(value) && url.pathname === "/" && !url.search && value.replace(/\/$/u, "") === url.origin;
+    } catch {
+      return false;
+    }
+  }
+  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 operations.pipe(safeManifestInputSchema, canonicalManifestSchema);
+}
+var init_manifest_schema = __esm({
+  "src/manifest-schema.ts"() {
+    "use strict";
+    init_manifest_types();
+    init_portable_identity_schema();
+    init_runtime_view_schema();
+    init_model();
+  }
+});
+
+// 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);
+}
+var init_native_zod_object = __esm({
+  "src/native-zod-object.ts"() {
+    "use strict";
+  }
+});
+
+// src/manifest-schema-classic.ts
+import { z as z2 } from "zod";
+function classic(schema) {
+  return schema;
+}
+var classicManifestStringOperations, classicManifestSchemaOperations;
+var init_manifest_schema_classic = __esm({
+  "src/manifest-schema-classic.ts"() {
+    "use strict";
+    init_native_zod_object();
+    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)
+    };
+    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, tileflowPortableIdSchema, tileflowThemeNameSchema;
+var init_portable_identity = __esm({
+  "src/portable-identity.ts"() {
+    "use strict";
+    init_manifest_schema_classic();
+    init_portable_identity_schema();
+    schemas = createPortableIdentitySchemas(classicManifestStringOperations);
+    tileflowPortableIdSchema = schemas.tileflowPortableIdSchema;
+    tileflowThemeNameSchema = schemas.tileflowThemeNameSchema;
+  }
+});
+
+// src/manifest.ts
+var manifest_exports = {};
+__export(manifest_exports, {
+  parseTileflowRuntimeManifest: () => parseTileflowRuntimeManifest,
+  safeParseTileflowRuntimeManifest: () => safeParseTileflowRuntimeManifest,
+  tileflowRuntimeManifestLimits: () => tileflowRuntimeManifestLimits,
+  tileflowRuntimeManifestSchema: () => tileflowRuntimeManifestSchema,
+  tileflowRuntimeManifestVersion: () => tileflowRuntimeManifestVersion
+});
+function parseTileflowRuntimeManifest(input) {
+  return tileflowRuntimeManifestSchema.parse(input);
+}
+function safeParseTileflowRuntimeManifest(input) {
+  return tileflowRuntimeManifestSchema.safeParse(input);
+}
+var tileflowRuntimeManifestSchema;
+var init_manifest = __esm({
+  "src/manifest.ts"() {
+    "use strict";
+    init_manifest_schema();
+    init_manifest_schema_classic();
+    init_portable_identity();
+    init_manifest_types();
+    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 }
+    );
   }
 });
 
@@ -325,7 +475,7 @@ var maximumSessionGrantBytes = 64 * 1024;
 var manifestCache = new globalThis.Map();
 var missingStaticMapIdWarnings = /* @__PURE__ */ new Set();
 function shouldLoadTileflowManifest(options) {
-  return options.source.kind === "tileflow";
+  return validateTileflowRuntimeSource(options.source).ok;
 }
 function validateTileflowRuntimeSource(source) {
   if (source === void 0) {
@@ -334,32 +484,14 @@ function validateTileflowRuntimeSource(source) {
   if (!isPlainRuntimeRecord(source)) {
     return { code: "invalid-source", error: "source must be an object", ok: false };
   }
-  if (source.kind === "tileflow") {
-    if (!isTileflowPortableId(source.map) || source.manifestUrl !== void 0 && (typeof source.manifestUrl !== "string" || source.manifestUrl.length === 0)) {
-      return {
-        code: "invalid-source",
-        error: "a tileflow source requires a portable map id and an optional non-empty manifestUrl",
-        ok: false
-      };
-    }
-    return { ok: true };
-  }
-  if (source.kind === "maplibre") {
-    const style = source.style;
-    if ((typeof style !== "string" || style.length === 0) && (!style || typeof style !== "object" || Array.isArray(style))) {
-      return {
-        code: "invalid-source",
-        error: "a maplibre source requires a style object or non-empty style URL",
-        ok: false
-      };
-    }
-    return { ok: true };
+  if ("kind" in source || "style" in source || !isTileflowPortableId(source.map) || source.manifestUrl !== void 0 && (typeof source.manifestUrl !== "string" || source.manifestUrl.length === 0)) {
+    return {
+      code: "invalid-source",
+      error: "source requires a portable map id and an optional non-empty manifestUrl; renderer inputs are not supported",
+      ok: false
+    };
   }
-  return {
-    code: "invalid-source",
-    error: "source.kind must be 'tileflow' or 'maplibre'",
-    ok: false
-  };
+  return { ok: true };
 }
 function validateTileflowThemeSelection(value) {
   return value === "system" || isTileflowThemeName(value);
@@ -372,21 +504,6 @@ function assertValidTileflowRuntimeSource(source) {
 }
 function resolveTileflowRuntimeStyle(options) {
   assertValidTileflowRuntimeSource(options.source);
-  if (options.source.kind === "maplibre") {
-    if (options.theme !== void 0) {
-      throw new TypeError("The theme option is only valid for a Tileflow map source.");
-    }
-    if (typeof options.source.style !== "string") {
-      return {
-        fontFaces: getTileflowStyleFontFaces(options.source.style),
-        style: options.source.style
-      };
-    }
-    return {
-      analytics: inferTileflowAnalyticsFromStyleUrl(options.source.style),
-      style: options.source.style
-    };
-  }
   if (options.manifestMap) {
     const theme = resolveTileflowRuntimeTheme(
       options.manifestMap,

package/docs/authoring-model.md

@@ -3,7 +3,7 @@
 Start with the [@tileflow/core guide](https://github.com/tileflow/tileflow-sdk/blob/main/packages/core/README.md) for installation and a complete first example.
 
 Tileflow exposes one authoring concept and one constructor: `defineMap()`. A complete map omits
-`extends`; an inherited map sets `extends` to another imported map object. All ten first-party
+`extends`; an inherited map sets `extends` to another imported map object. All first-party
 maps are independent standalone maps. They use the sole semantic compiler while defining
 their complete designs and asset providers directly; no official map imports or extends another
 official map. Applications can extend any of those maps through the same public API. Streets
@@ -106,7 +106,7 @@ const companyBase = defineMap({
   version: 1,
   glyphs: {
     kind: 'url',
-    url: 'https://api.tileflow.dev/fonts/{fontstack}/{range}.pbf',
+    url: 'https://api.tileflow.dev/base/33d4de5e8086d9d629d67d3f39fedb87e23686c4c1ac653c27e2a52aee9d00b3/glyphs/{fontstack}/{range}.pbf',
     fontStacks: ['Noto Sans Regular', 'Noto Sans Bold'],
   },
   icons: [streetsIcons],
@@ -126,8 +126,9 @@ export default defineMap({
 The standalone map above is complete as written. A map always owns its complete text provider; Core does not
 obtain fonts or sprites from World and never invents a fallback URL. The URL-backed first-party
 `streets`, `ferraris`, `harad`, `soundings`, `verdant`, and `sanFrancisto` maps declare their glyph
-providers directly, while `baedeker`, `siegfried`, `cyberpunk`, and `matrix` declare packaged fonts, so ordinary imports and derived
-maps compile without out-of-band release metadata.
+providers directly. `baedeker`, `civica`, `cyberpunk`, `matrix`, `siegfried`, and `superTileWorld`
+declare packaged fonts, so ordinary imports and derived maps compile without out-of-band release
+metadata.
 
 ```mermaid
 flowchart LR