@tileflow/core 0.1.0-alpha.3 → 0.1.0-alpha.31

package/dist/manifest.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { T as TileflowRuntimeManifest } from './manifest-types-CTT2eLbp.js';
+export { a as TileflowRuntimeColorScheme, b as TileflowRuntimeManifestMapEntry, c as TileflowRuntimeManifestTheme, d as TileflowRuntimeSystemThemes, t as tileflowRuntimeManifestLimits, e as tileflowRuntimeManifestVersion } from './manifest-types-CTT2eLbp.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

@@ -0,0 +1,368 @@
+// src/manifest-types.ts
+var tileflowRuntimeManifestVersion = 1;
+var tileflowRuntimeManifestLimits = Object.freeze({ maximumBytes: 1024 * 1024 });
+
+// src/portable-identity-rules.ts
+var tileflowPortableIdMaximumLength = 64;
+var tileflowPortableIdPattern = /^[a-z][a-z0-9-]{0,63}$/u;
+function isTileflowPortableId(value) {
+  return typeof value === "string" && value.length <= tileflowPortableIdMaximumLength && tileflowPortableIdPattern.test(value) && !["constructor", "prototype"].includes(value) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(value);
+}
+function isTileflowThemeName(value) {
+  return isTileflowPortableId(value) && value !== "system";
+}
+
+// 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 });
+var themeTypographyStyleKeys = ["fallbacks", "font", "letterSpacing", "transform"];
+var themeTypographyKeys = [
+  ...themeTypographyStyleKeys,
+  "places",
+  "poi",
+  "roads",
+  "water"
+];
+
+// 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: "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) {
+            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: "usageMode and worldGeneration must be declared together"
+        });
+      }
+    }
+  );
+  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: 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: `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 = 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);
+}
+
+// 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,
+  safeParseTileflowRuntimeManifest,
+  tileflowRuntimeManifestLimits,
+  tileflowRuntimeManifestSchema,
+  tileflowRuntimeManifestVersion
+};

package/dist/native-profile.d.ts

@@ -0,0 +1,188 @@
+import { z } from 'zod';
+
+/** Static preparation profile, not evidence that an application ran on a device. */
+declare const tileflowNativeProfileSchema: z.ZodLazy<z.core.$ZodObject<{
+    id: z.ZodLiteral<"native-v1">;
+    renderer: z.ZodLiteral<"native">;
+    schemaVersion: z.ZodLiteral<1>;
+    styleVersion: z.ZodLiteral<8>;
+    validatorStyleSpec: z.ZodLiteral<"24.8.5">;
+    reactNativeStyleSpec: z.ZodLiteral<"26.2.1">;
+    maplibreReactNative: z.ZodLiteral<"11.3.10">;
+    android: z.ZodLiteral<"13.2.0">;
+    ios: z.ZodLiteral<"6.26.0">;
+}, z.core.$strict>>;
+type TileflowNativeProfile = z.infer<typeof tileflowNativeProfileSchema>;
+declare const tileflowNativeProfile: Readonly<TileflowNativeProfile>;
+declare const tileflowNativeProfileIdSchema: z.ZodLiteral<"native-v1">;
+declare const tileflowRendererSchema: z.ZodEnum<{
+    native: "native";
+    web: "web";
+}>;
+type TileflowRenderer = z.infer<typeof tileflowRendererSchema>;
+
+type TileflowColor = `#${string}`;
+type MapLibreSprite = string | Array<{
+    id: string;
+    url: string;
+}>;
+type TileflowProjection = 'globe' | 'mercator';
+type TileflowLight = {
+    anchor?: 'map' | 'viewport';
+    color?: TileflowColor;
+    intensity?: number;
+    position?: readonly [number, number, number];
+};
+type MapLibreStyle = {
+    sky?: Record<string, unknown>;
+    version: 8;
+    name: string;
+    glyphs?: string;
+    light?: TileflowLight;
+    projection?: {
+        type: TileflowProjection;
+    };
+    sprite?: MapLibreSprite;
+    sources: Record<string, Record<string, unknown>>;
+    layers: Array<Record<string, unknown>>;
+    terrain?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+};
+
+/** Resource budgets apply to validation work, not downloaded resources or native GPU memory. */
+declare const tileflowNativeProfileLimits: Readonly<{
+    maximumStyleBytes: number;
+    maximumDepth: 64;
+    maximumNodes: 160000;
+    maximumSources: 128;
+    maximumLayers: 4096;
+    maximumIssues: 32;
+    maximumFontFaces: 16;
+    maximumFontBytes: number;
+}>;
+/** Fixed output budget for a prepared native-v1 style, never a raw input allowance. */
+declare const tileflowNativePreparedStyleLimits: Readonly<{
+    maximumNodes: 540000;
+    maximumStyleBytes: number;
+    maximumDepth: 64;
+    maximumSources: 128;
+    maximumLayers: 4096;
+    maximumIssues: 32;
+    maximumFontFaces: 16;
+    maximumFontBytes: number;
+}>;
+
+declare const tileflowNativeBuildRecordFileName = "native-build.json";
+declare const tileflowNativeStyleTransformationSchema: z.ZodLazy<z.core.$ZodObject<{
+    map: z.ZodString;
+    theme: z.ZodString;
+    inputStyleSha256: z.ZodString;
+    loweredStyleSha256: z.ZodString;
+    inputLayers: z.ZodNumber;
+    outputLayers: z.ZodNumber;
+    projection: z.ZodEnum<{
+        none: "none";
+        "mercator-to-implicit": "mercator-to-implicit";
+        "globe-to-mercator": "globe-to-mercator";
+    }>;
+    layers: z.ZodArray<z.ZodLazy<z.core.$ZodObject<{
+        inputLayer: z.ZodNumber;
+        outputStart: z.ZodNumber;
+        outputCount: z.ZodNumber;
+        properties: z.ZodArray<z.ZodEnum<{
+            "line-dasharray": "line-dasharray";
+            "line-cap": "line-cap";
+        }>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>;
+type TileflowNativeStyleTransformation = z.infer<typeof tileflowNativeStyleTransformationSchema>;
+/** Version 2 adds explicit preparation evidence. The runtime manifest remains version 1. */
+declare const tileflowNativeBuildRecordSchema: z.ZodLazy<z.core.$ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    renderer: z.ZodLiteral<"native">;
+    profile: z.ZodLiteral<"native-v1">;
+    validation: z.ZodLiteral<"static-artifacts">;
+    preparationVersion: z.ZodLiteral<"native-lowering-v1">;
+    engines: z.ZodLazy<z.core.$ZodObject<{
+        android: z.ZodLiteral<"13.2.0">;
+        ios: z.ZodLiteral<"6.26.0">;
+    }, z.core.$strict>>;
+    buildManifestSha256: z.ZodString;
+    transformations: z.ZodArray<z.ZodLazy<z.core.$ZodObject<{
+        map: z.ZodString;
+        theme: z.ZodString;
+        inputStyleSha256: z.ZodString;
+        loweredStyleSha256: z.ZodString;
+        inputLayers: z.ZodNumber;
+        outputLayers: z.ZodNumber;
+        projection: z.ZodEnum<{
+            none: "none";
+            "mercator-to-implicit": "mercator-to-implicit";
+            "globe-to-mercator": "globe-to-mercator";
+        }>;
+        layers: z.ZodArray<z.ZodLazy<z.core.$ZodObject<{
+            inputLayer: z.ZodNumber;
+            outputStart: z.ZodNumber;
+            outputCount: z.ZodNumber;
+            properties: z.ZodArray<z.ZodEnum<{
+                "line-dasharray": "line-dasharray";
+                "line-cap": "line-cap";
+            }>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>;
+type TileflowNativeBuildRecord = z.infer<typeof tileflowNativeBuildRecordSchema>;
+declare function createTileflowNativeBuildRecord(buildManifestSha256: string, transformations?: readonly TileflowNativeStyleTransformation[]): TileflowNativeBuildRecord;
+
+declare const tileflowNativeDiagnosticCodeSchema: z.ZodEnum<{
+    NATIVE_UNSUPPORTED_STYLE: "NATIVE_UNSUPPORTED_STYLE";
+    NATIVE_UNSUPPORTED_SOURCE: "NATIVE_UNSUPPORTED_SOURCE";
+    NATIVE_FONT_UNAVAILABLE: "NATIVE_FONT_UNAVAILABLE";
+    NATIVE_MANIFEST_REQUIRED: "NATIVE_MANIFEST_REQUIRED";
+    NATIVE_RENDERER_UNSUPPORTED: "NATIVE_RENDERER_UNSUPPORTED";
+}>;
+type TileflowNativeDiagnosticCode = z.infer<typeof tileflowNativeDiagnosticCodeSchema>;
+/** Uses the command diagnostic fields; renderer/profile are bounded additional context. */
+declare const tileflowNativeDiagnosticSchema: z.ZodLazy<z.core.$ZodObject<{
+    code: z.ZodEnum<{
+        NATIVE_UNSUPPORTED_STYLE: "NATIVE_UNSUPPORTED_STYLE";
+        NATIVE_UNSUPPORTED_SOURCE: "NATIVE_UNSUPPORTED_SOURCE";
+        NATIVE_FONT_UNAVAILABLE: "NATIVE_FONT_UNAVAILABLE";
+        NATIVE_MANIFEST_REQUIRED: "NATIVE_MANIFEST_REQUIRED";
+        NATIVE_RENDERER_UNSUPPORTED: "NATIVE_RENDERER_UNSUPPORTED";
+    }>;
+    phase: z.ZodLiteral<"native-compatibility">;
+    severity: z.ZodLiteral<"error">;
+    path: z.ZodString;
+    renderer: z.ZodLiteral<"native">;
+    profile: z.ZodLiteral<"native-v1">;
+    message: z.ZodString;
+    suggestion: z.ZodString;
+}, z.core.$strict>>;
+type TileflowNativeDiagnostic = z.infer<typeof tileflowNativeDiagnosticSchema>;
+declare function createTileflowNativeDiagnostic(code: TileflowNativeDiagnosticCode, path?: string): TileflowNativeDiagnostic;
+declare class TileflowNativeCompatibilityError extends Error {
+    readonly phase: "native-compatibility";
+    readonly issues: readonly TileflowNativeDiagnostic[];
+    readonly code: TileflowNativeDiagnosticCode;
+    constructor(issues: readonly TileflowNativeDiagnostic[]);
+}
+declare function resolveTileflowRenderer(value?: unknown): TileflowRenderer;
+type TileflowNativeStyleValidationOptions = {
+    profile?: 'native-v1';
+    /** Used only for URL syntax resolution; no request or authority is implied. */
+    documentUrl?: string;
+    developmentOrigin?: string;
+    /** Build preflight may defer font closure until the existing font pipeline has run. */
+    deferFontClosure?: boolean;
+};
+/** Validate bounded JSON and the common native engine surface without executing a renderer. */
+declare function validateTileflowNativeStyle(input: unknown, options?: TileflowNativeStyleValidationOptions): TileflowNativeDiagnostic[];
+/**
+ * Check an already prepared artifact with the fixed native-v1 output allowance.
+ * This does not lower a style or prove its origin. Authoring input must use the raw validator.
+ */
+declare function validateTileflowNativePreparedStyle(input: unknown, options?: TileflowNativeStyleValidationOptions): TileflowNativeDiagnostic[];
+declare function assertTileflowNativeStyle(style: unknown, options?: TileflowNativeStyleValidationOptions): asserts style is MapLibreStyle;
+
+export { type TileflowNativeBuildRecord, TileflowNativeCompatibilityError, type TileflowNativeDiagnostic, type TileflowNativeDiagnosticCode, type TileflowNativeProfile, type TileflowNativeStyleValidationOptions, type TileflowRenderer, assertTileflowNativeStyle, createTileflowNativeBuildRecord, createTileflowNativeDiagnostic, resolveTileflowRenderer, tileflowNativeBuildRecordFileName, tileflowNativeBuildRecordSchema, tileflowNativeDiagnosticCodeSchema, tileflowNativeDiagnosticSchema, tileflowNativePreparedStyleLimits, tileflowNativeProfile, tileflowNativeProfileIdSchema, tileflowNativeProfileLimits, tileflowNativeProfileSchema, tileflowRendererSchema, validateTileflowNativePreparedStyle, validateTileflowNativeStyle };