@tileflow/core 0.1.0-alpha.4 → 0.1.0-alpha.41

package/dist/build.d.ts

@@ -0,0 +1,595 @@
+import { T as TileflowCaptureScene, a as TileflowCaptureShot } from './capture-shot-ChPQvPyi.js';
+import { T as TileflowRenderedIconIdentity, a as TileflowIconCompositionV1, R as ResolvedTileflowMap, b as TileflowDataRequirementsV1, c as TileflowSourceRequirementsV1, d as TileflowMap, e as TileflowStyleOptions, f as TileflowInspectedStyle, g as TileflowPreparedMapAssets } from './icon-composition-HUh_Lj8Z.js';
+export { h as TileflowDataCompatibilityIssue, i as TileflowDataFieldRequirement, j as TileflowDataFieldType, k as TileflowDataLayerRequirement, l as TileflowObservedDataContractV1, m as TileflowStyleInspection, n as TileflowStyleInspectionContribution, o as TileflowStyleInspectionLayer, p as TileflowStyleInspectionRenderOperation, q as collectMapLineage, r as inferTileflowDataRequirements, s as inferTileflowSourceRequirements, t as tileflowStyleInspectionSchemaVersion, v as validateTileflowDataCompatibility } from './icon-composition-HUh_Lj8Z.js';
+import { M as MapLibreStyle, f as TileflowTimeOfDayVariants, T as TileflowRuntimeManifest } from './manifest-types-DnhSJjCM.js';
+import { z } from 'zod';
+
+declare const tileflowMapRevisionSchemaVersion: 1;
+declare const tileflowSharedIconMapRevisionSchemaVersion: 2;
+declare const tileflowMapRevisionCanonicalization: "tileflow-canonical-json-v1";
+declare const tileflowMapBuildManifestSchemaVersion: 1;
+declare const tileflowMapBuildManifestFileName: "build-manifest.json";
+/** One effective icon source after ordered directory replacement has completed. */
+type TileflowEffectiveIconSourceIdentity = TileflowRenderedIconIdentity | {
+    format: 'jpeg' | 'png' | 'svg' | 'webp';
+    id: string;
+    kind: 'icon' | 'pattern';
+    sha256: string;
+};
+/** One effective local font face actually referenced by the compiled map. */
+type TileflowEffectiveFontSourceIdentity = {
+    family: string;
+    sha256: string;
+    style: 'italic' | 'normal' | 'oblique';
+    weight: '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
+};
+/** One effective 3D model file a map declares: a level of detail, near, mid or far. */
+type TileflowEffectiveModelSourceIdentity = {
+    id: string;
+    level: 'far' | 'mid' | 'near';
+    sha256: string;
+};
+type TileflowEffectiveMapSourceAssets = {
+    fonts: readonly TileflowEffectiveFontSourceIdentity[];
+    icons: readonly TileflowEffectiveIconSourceIdentity[];
+    /** The map's own 3D models; absent, as for maps without models, leaves revisions unchanged. */
+    models?: readonly TileflowEffectiveModelSourceIdentity[];
+    /** Exact ordered shared dependencies, separate from original-source history and output bytes. */
+    iconComposition?: TileflowIconCompositionV1;
+};
+type TileflowHashableBuildAsset = {
+    contentType: string;
+    fileName: string;
+    source: string | Uint8Array;
+};
+/** Canonical byte identity used by the immutable asset-set hash. */
+type TileflowBuildAssetIdentity = {
+    byteLength: number;
+    contentType: string;
+    fileName: string;
+    sha256: string;
+};
+/** One authoring node in leaf-to-root order, retained only for auditability. */
+type TileflowMapBuildLineageEntry = {
+    id: string;
+    mapVersion: number;
+};
+type TileflowMapBuildInput = {
+    assets: readonly TileflowHashableBuildAsset[];
+    lineage: readonly TileflowMapBuildLineageEntry[];
+    /** Validated, inheritance-free semantic compiler input. */
+    map: ResolvedTileflowMap;
+    sourceAssets: TileflowEffectiveMapSourceAssets;
+    styles: Readonly<Record<string, MapLibreStyle>>;
+};
+type TileflowThemeBuildManifestEntryV1 = {
+    colorScheme: 'dark' | 'light';
+    dataRequirements: TileflowDataRequirementsV1;
+    sourceRequirements: TileflowSourceRequirementsV1;
+    styleSha256: string;
+    themeId: string;
+    themeVersion: number;
+};
+type TileflowMapBuildManifestEntryV1 = {
+    assetSetSha256: string;
+    defaultTheme: string;
+    lineage: readonly TileflowMapBuildLineageEntry[];
+    mapRevisionSha256: string;
+    /** Omission means the unchanged legacy v1 source contract. Shared sets use explicit v2. */
+    mapRevisionSchemaVersion?: 2;
+    mapVersion: number;
+    semanticCompiler: {
+        name: 'tileflow-semantic';
+        version: number;
+    };
+    sourceAssets: TileflowEffectiveMapSourceAssets;
+    systemThemes?: {
+        dark: string;
+        light: string;
+    };
+    timeOfDay?: TileflowTimeOfDayVariants;
+    themes: Record<string, TileflowThemeBuildManifestEntryV1>;
+};
+/**
+ * Collect leaf-to-root editorial identities for manifest auditability.
+ *
+ * This lineage is deliberately not an additional `mapRevisionSha256` input. The resolved effective
+ * map already determines that identity, so a fully shadowed ancestor change stays non-material.
+ */
+declare function collectTileflowMapBuildLineage(input: TileflowMap): TileflowMapBuildLineageEntry[];
+type TileflowMapBuildProvenanceV1 = {
+    lockfile?: {
+        format: 'bun' | 'npm' | 'pnpm' | 'yarn';
+        sha256: string;
+    };
+    packages: Readonly<Record<string, string>>;
+    schemaVersion: 1;
+};
+type TileflowMapBuildManifestV1 = {
+    maps: Record<string, TileflowMapBuildManifestEntryV1>;
+    provenance?: TileflowMapBuildProvenanceV1;
+    schemaVersion: typeof tileflowMapBuildManifestSchemaVersion;
+};
+/**
+ * Create the portable map build identity document.
+ *
+ * `mapRevisionSha256` identifies the effective cartographic definition and effective source
+ * icon/font bytes. Editorial identity, default view, capture scenes and shots, package
+ * versions, compiler ABI versions, compiled Style JSON, generated sprite/font outputs, filesystem
+ * paths, and a concrete resolution of a floating World selector are outside that hash. They have
+ * their own identities or remain tooling/delivery state.
+ */
+declare function createTileflowMapBuildManifest(maps: Readonly<Record<string, TileflowMapBuildInput>>, options?: {
+    provenance?: TileflowMapBuildProvenanceV1;
+}): Promise<TileflowMapBuildManifestV1>;
+/** Hash a resolved map definition with the versioned, domain-separated revision contract. */
+declare function hashTileflowMapRevision(input: ResolvedTileflowMap, sourceAssets: TileflowEffectiveMapSourceAssets): Promise<string>;
+/** Hash the exact compiled resources bound to one map, independently from its Style JSON. */
+declare function hashTileflowAssetSet(input: readonly TileflowHashableBuildAsset[]): Promise<string>;
+/**
+ * Hash already-verified resource identities with the same v1 contract as byte-backed build assets.
+ *
+ * Hosted uses this after independently confirming immutable object bytes against their manifests;
+ * package or bundle hashes are not substitutes for this per-file identity closure.
+ */
+declare function hashTileflowAssetSetIdentities(input: readonly TileflowBuildAssetIdentity[]): Promise<string>;
+
+/**
+ * Compile the ordinary MapLibre Style and a separate read-only physical-output sidecar.
+ * Its physical IDs are diagnostic observations, never authoring targets. The sidecar never enters
+ * the Style object or runtime manifest.
+ */
+declare function createStyleWithInspection(config: TileflowMap, options?: TileflowStyleOptions): TileflowInspectedStyle;
+
+/** These are transport/validation bounds, not renderer or commercial quotas. */
+declare const tileflowRendererDeploymentLimits: Readonly<{
+    maximumBytes: number;
+    maximumNativeFamilyBytes: number;
+    maximumThemes: 64;
+}>;
+/** Explicit v2 only. Existing v1 envelopes and decoders are not extended by this schema. */
+declare const tileflowRendererDeploymentArtifactSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"tileflow-map-deployment">;
+    schemaVersion: z.ZodLiteral<2>;
+    mapId: z.ZodString;
+    teamSources: z.ZodRecord<z.ZodString, z.ZodObject<{
+        tileset: z.ZodString;
+        type: z.ZodEnum<{
+            raster: "raster";
+            vector: "vector";
+        }>;
+    }, z.core.$strict>>;
+    view: z.ZodOptional<z.ZodObject<{
+        center: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+        bearing: z.ZodOptional<z.ZodNumber>;
+        pitch: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    renderers: z.ZodObject<{
+        web: z.ZodObject<{
+            buildManifest: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                maps: z.ZodRecord<z.ZodString, z.ZodObject<{
+                    assetSetSha256: z.ZodString;
+                    defaultTheme: z.ZodString;
+                    lineage: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        mapVersion: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    mapRevisionSha256: z.ZodString;
+                    mapRevisionSchemaVersion: z.ZodOptional<z.ZodLiteral<2>>;
+                    mapVersion: z.ZodNumber;
+                    semanticCompiler: z.ZodObject<{
+                        name: z.ZodLiteral<"tileflow-semantic">;
+                        version: z.ZodLiteral<1>;
+                    }, z.core.$strict>;
+                    sourceAssets: z.ZodObject<{
+                        fonts: z.ZodArray<z.ZodObject<{
+                            family: z.ZodString;
+                            sha256: z.ZodString;
+                            style: z.ZodEnum<{
+                                italic: "italic";
+                                normal: "normal";
+                                oblique: "oblique";
+                            }>;
+                            weight: z.ZodEnum<{
+                                100: "100";
+                                200: "200";
+                                300: "300";
+                                400: "400";
+                                500: "500";
+                                600: "600";
+                                700: "700";
+                                800: "800";
+                                900: "900";
+                            }>;
+                        }, z.core.$strict>>;
+                        icons: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                            format: z.ZodEnum<{
+                                jpeg: "jpeg";
+                                png: "png";
+                                svg: "svg";
+                                webp: "webp";
+                            }>;
+                            id: z.ZodString;
+                            kind: z.ZodEnum<{
+                                icon: "icon";
+                                pattern: "pattern";
+                            }>;
+                            sha256: z.ZodString;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"rendered-icon">;
+                            id: z.ZodString;
+                            appearance: z.ZodOptional<z.ZodObject<{
+                                representation: z.ZodLiteral<"sdf">;
+                                defaults: z.ZodObject<{
+                                    color: z.ZodString;
+                                    haloColor: z.ZodString;
+                                    haloWidth: z.ZodNumber;
+                                    haloBlur: z.ZodNumber;
+                                }, z.core.$strict>;
+                            }, z.core.$strict>>;
+                            layout: z.ZodOptional<z.ZodObject<{
+                                stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+                                stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+                                content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+                            }, z.core.$strict>>;
+                            width: z.ZodNumber;
+                            height: z.ZodNumber;
+                            pixelSha256: z.ZodObject<{
+                                oneX: z.ZodString;
+                                twoX: z.ZodString;
+                            }, z.core.$strict>;
+                        }, z.core.$strict>]>>;
+                        iconComposition: z.ZodOptional<z.ZodObject<{
+                            format: z.ZodEnum<{
+                                'tileflow-icon-composition-v1': "tileflow-icon-composition-v1";
+                                'tileflow-icon-composition-v2': "tileflow-icon-composition-v2";
+                            }>;
+                            compositionVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+                            packageHash: z.ZodString;
+                            contributors: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                kind: z.ZodLiteral<"local">;
+                                iconIds: z.ZodArray<z.ZodString>;
+                            }, z.core.$strict>, z.ZodObject<{
+                                kind: z.ZodLiteral<"package">;
+                                package: z.ZodString;
+                                iconIds: z.ZodArray<z.ZodString>;
+                            }, z.core.$strict>, z.ZodObject<{
+                                kind: z.ZodLiteral<"icon-set">;
+                                reference: z.ZodString;
+                                teamId: z.ZodString;
+                                setId: z.ZodString;
+                                versionId: z.ZodString;
+                                version: z.ZodNumber;
+                                packageId: z.ZodString;
+                                contentHash: z.ZodString;
+                                iconIds: z.ZodArray<z.ZodString>;
+                            }, z.core.$strict>], "kind">>;
+                            winners: z.ZodArray<z.ZodObject<{
+                                id: z.ZodString;
+                                appearance: z.ZodOptional<z.ZodObject<{
+                                    representation: z.ZodLiteral<"sdf">;
+                                    defaults: z.ZodObject<{
+                                        color: z.ZodString;
+                                        haloColor: z.ZodString;
+                                        haloWidth: z.ZodNumber;
+                                        haloBlur: z.ZodNumber;
+                                    }, z.core.$strict>;
+                                }, z.core.$strict>>;
+                                layout: z.ZodOptional<z.ZodObject<{
+                                    stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+                                    stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+                                    content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+                                }, z.core.$strict>>;
+                                width: z.ZodNumber;
+                                height: z.ZodNumber;
+                                pixelSha256: z.ZodObject<{
+                                    oneX: z.ZodString;
+                                    twoX: z.ZodString;
+                                }, z.core.$strict>;
+                                contributor: z.ZodNumber;
+                            }, z.core.$strict>>;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>;
+                    systemThemes: z.ZodOptional<z.ZodObject<{
+                        dark: z.ZodString;
+                        light: z.ZodString;
+                    }, z.core.$strict>>;
+                    themes: z.ZodRecord<z.ZodString, z.ZodObject<{
+                        colorScheme: z.ZodEnum<{
+                            dark: "dark";
+                            light: "light";
+                        }>;
+                        dataRequirements: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        sourceRequirements: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        styleSha256: z.ZodString;
+                        themeId: z.ZodString;
+                        themeVersion: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    timeOfDay: z.ZodOptional<z.ZodType<Readonly<Record<string, Readonly<Partial<Record<"dawn" | "day" | "dusk" | "night", string>>>>>, unknown, z.core.$ZodTypeInternals<Readonly<Record<string, Readonly<Partial<Record<"dawn" | "day" | "dusk" | "night", string>>>>>, unknown>>>;
+                }, z.core.$strict>>;
+                provenance: z.ZodOptional<z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<1>;
+                    lockfile: z.ZodOptional<z.ZodObject<{
+                        format: z.ZodEnum<{
+                            bun: "bun";
+                            npm: "npm";
+                            pnpm: "pnpm";
+                            yarn: "yarn";
+                        }>;
+                        sha256: z.ZodString;
+                    }, z.core.$strict>>;
+                    packages: z.ZodRecord<z.ZodString, z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            styles: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>;
+        native: z.ZodObject<{
+            buildManifest: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                maps: z.ZodRecord<z.ZodString, z.ZodObject<{
+                    assetSetSha256: z.ZodString;
+                    defaultTheme: z.ZodString;
+                    lineage: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        mapVersion: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    mapRevisionSha256: z.ZodString;
+                    mapRevisionSchemaVersion: z.ZodOptional<z.ZodLiteral<2>>;
+                    mapVersion: z.ZodNumber;
+                    semanticCompiler: z.ZodObject<{
+                        name: z.ZodLiteral<"tileflow-semantic">;
+                        version: z.ZodLiteral<1>;
+                    }, z.core.$strict>;
+                    sourceAssets: z.ZodObject<{
+                        fonts: z.ZodArray<z.ZodObject<{
+                            family: z.ZodString;
+                            sha256: z.ZodString;
+                            style: z.ZodEnum<{
+                                italic: "italic";
+                                normal: "normal";
+                                oblique: "oblique";
+                            }>;
+                            weight: z.ZodEnum<{
+                                100: "100";
+                                200: "200";
+                                300: "300";
+                                400: "400";
+                                500: "500";
+                                600: "600";
+                                700: "700";
+                                800: "800";
+                                900: "900";
+                            }>;
+                        }, z.core.$strict>>;
+                        icons: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                            format: z.ZodEnum<{
+                                jpeg: "jpeg";
+                                png: "png";
+                                svg: "svg";
+                                webp: "webp";
+                            }>;
+                            id: z.ZodString;
+                            kind: z.ZodEnum<{
+                                icon: "icon";
+                                pattern: "pattern";
+                            }>;
+                            sha256: z.ZodString;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"rendered-icon">;
+                            id: z.ZodString;
+                            appearance: z.ZodOptional<z.ZodObject<{
+                                representation: z.ZodLiteral<"sdf">;
+                                defaults: z.ZodObject<{
+                                    color: z.ZodString;
+                                    haloColor: z.ZodString;
+                                    haloWidth: z.ZodNumber;
+                                    haloBlur: z.ZodNumber;
+                                }, z.core.$strict>;
+                            }, z.core.$strict>>;
+                            layout: z.ZodOptional<z.ZodObject<{
+                                stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+                                stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+                                content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+                            }, z.core.$strict>>;
+                            width: z.ZodNumber;
+                            height: z.ZodNumber;
+                            pixelSha256: z.ZodObject<{
+                                oneX: z.ZodString;
+                                twoX: z.ZodString;
+                            }, z.core.$strict>;
+                        }, z.core.$strict>]>>;
+                        iconComposition: z.ZodOptional<z.ZodObject<{
+                            format: z.ZodEnum<{
+                                'tileflow-icon-composition-v1': "tileflow-icon-composition-v1";
+                                'tileflow-icon-composition-v2': "tileflow-icon-composition-v2";
+                            }>;
+                            compositionVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+                            packageHash: z.ZodString;
+                            contributors: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                kind: z.ZodLiteral<"local">;
+                                iconIds: z.ZodArray<z.ZodString>;
+                            }, z.core.$strict>, z.ZodObject<{
+                                kind: z.ZodLiteral<"package">;
+                                package: z.ZodString;
+                                iconIds: z.ZodArray<z.ZodString>;
+                            }, z.core.$strict>, z.ZodObject<{
+                                kind: z.ZodLiteral<"icon-set">;
+                                reference: z.ZodString;
+                                teamId: z.ZodString;
+                                setId: z.ZodString;
+                                versionId: z.ZodString;
+                                version: z.ZodNumber;
+                                packageId: z.ZodString;
+                                contentHash: z.ZodString;
+                                iconIds: z.ZodArray<z.ZodString>;
+                            }, z.core.$strict>], "kind">>;
+                            winners: z.ZodArray<z.ZodObject<{
+                                id: z.ZodString;
+                                appearance: z.ZodOptional<z.ZodObject<{
+                                    representation: z.ZodLiteral<"sdf">;
+                                    defaults: z.ZodObject<{
+                                        color: z.ZodString;
+                                        haloColor: z.ZodString;
+                                        haloWidth: z.ZodNumber;
+                                        haloBlur: z.ZodNumber;
+                                    }, z.core.$strict>;
+                                }, z.core.$strict>>;
+                                layout: z.ZodOptional<z.ZodObject<{
+                                    stretchX: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+                                    stretchY: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+                                    content: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+                                }, z.core.$strict>>;
+                                width: z.ZodNumber;
+                                height: z.ZodNumber;
+                                pixelSha256: z.ZodObject<{
+                                    oneX: z.ZodString;
+                                    twoX: z.ZodString;
+                                }, z.core.$strict>;
+                                contributor: z.ZodNumber;
+                            }, z.core.$strict>>;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>;
+                    systemThemes: z.ZodOptional<z.ZodObject<{
+                        dark: z.ZodString;
+                        light: z.ZodString;
+                    }, z.core.$strict>>;
+                    themes: z.ZodRecord<z.ZodString, z.ZodObject<{
+                        colorScheme: z.ZodEnum<{
+                            dark: "dark";
+                            light: "light";
+                        }>;
+                        dataRequirements: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        sourceRequirements: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        styleSha256: z.ZodString;
+                        themeId: z.ZodString;
+                        themeVersion: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    timeOfDay: z.ZodOptional<z.ZodType<Readonly<Record<string, Readonly<Partial<Record<"dawn" | "day" | "dusk" | "night", string>>>>>, unknown, z.core.$ZodTypeInternals<Readonly<Record<string, Readonly<Partial<Record<"dawn" | "day" | "dusk" | "night", string>>>>>, unknown>>>;
+                }, z.core.$strict>>;
+                provenance: z.ZodOptional<z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<1>;
+                    lockfile: z.ZodOptional<z.ZodObject<{
+                        format: z.ZodEnum<{
+                            bun: "bun";
+                            npm: "npm";
+                            pnpm: "pnpm";
+                            yarn: "yarn";
+                        }>;
+                        sha256: z.ZodString;
+                    }, z.core.$strict>>;
+                    packages: z.ZodRecord<z.ZodString, z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            styles: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            buildRecord: 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<{
+                        "globe-to-mercator": "globe-to-mercator";
+                        "mercator-to-implicit": "mercator-to-implicit";
+                        none: "none";
+                    }>;
+                    sky: z.ZodOptional<z.ZodLiteral<"removed">>;
+                    layers: z.ZodArray<z.ZodLazy<z.core.$ZodObject<{
+                        inputLayer: z.ZodNumber;
+                        outputStart: z.ZodNumber;
+                        outputCount: z.ZodNumber;
+                        properties: z.ZodArray<z.ZodEnum<{
+                            "line-cap": "line-cap";
+                            "line-dasharray": "line-dasharray";
+                        }>>;
+                    }, z.core.$strict>>>;
+                    symbolOverlap: z.ZodArray<z.ZodLazy<z.core.$ZodObject<{
+                        inputLayer: z.ZodNumber;
+                        properties: z.ZodArray<z.ZodEnum<{
+                            "icon-overlap": "icon-overlap";
+                            "text-overlap": "text-overlap";
+                        }>>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type TileflowRendererDeploymentArtifact = z.infer<typeof tileflowRendererDeploymentArtifactSchema>;
+declare class TileflowRendererDeploymentError extends Error {
+    readonly code: "RENDERER_DEPLOYMENT_INVALID";
+    constructor();
+}
+/** Hash/profile verification is deliberately separate from shape validation and server authority. */
+declare function parseTileflowRendererDeploymentArtifact(input: unknown): Promise<TileflowRendererDeploymentArtifact>;
+declare const tileflowRendererDeploymentResponseSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"tileflow-map-deployment-result">;
+    schemaVersion: z.ZodLiteral<2>;
+    changed: z.ZodBoolean;
+    mapId: z.ZodString;
+    deploymentId: z.ZodString;
+    version: z.ZodNumber;
+    worldConversionId: z.ZodOptional<z.ZodString>;
+    renderers: z.ZodObject<{
+        web: z.ZodObject<{
+            themes: z.ZodRecord<z.ZodString, z.ZodObject<{
+                styleId: z.ZodOptional<z.ZodString>;
+                styleUrl: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        native: z.ZodObject<{
+            profile: z.ZodLiteral<"native-v1">;
+            manifestUrl: z.ZodString;
+            themes: z.ZodRecord<z.ZodString, z.ZodObject<{
+                styleUrl: z.ZodString;
+                revision: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type TileflowRendererDeploymentResponse = z.infer<typeof tileflowRendererDeploymentResponseSchema>;
+
+type TileflowCompiledMapMetadata = Pick<ResolvedTileflowMap, 'id' | 'version'> & {
+    lineage: readonly TileflowMapBuildLineageEntry[];
+};
+/** Multi-map intermediate representation owned by Node build tooling. */
+type TileflowBuildCatalog = {
+    /** Validated, inheritance-free compiler inputs. Authoring definitions live outside the catalog. */
+    maps: Record<string, ResolvedTileflowMap>;
+    mapMetadata?: Record<string, TileflowCompiledMapMetadata>;
+    scenes?: Record<string, TileflowCaptureScene>;
+    shots?: Record<string, TileflowCaptureShot>;
+};
+/** Complete compiled style family, addressed first by logical map and then by theme name. */
+type TileflowBuildStyles = Record<string, Record<string, MapLibreStyle>>;
+/** Style family plus opt-in, read-only, non-addressable physical-output diagnostics. */
+type TileflowBuildInspectedStyles = Record<string, Record<string, TileflowInspectedStyle>>;
+declare function createStyleFromCatalog<const TCatalog extends TileflowBuildCatalog, const TMapName extends keyof TCatalog['maps'] & string>(catalog: TCatalog, mapName: TMapName, options?: TileflowStyleOptions): MapLibreStyle;
+declare function createStyleFromCatalogWithInspection<const TCatalog extends TileflowBuildCatalog, const TMapName extends keyof TCatalog['maps'] & string>(catalog: TCatalog, mapName: TMapName, options?: TileflowStyleOptions): TileflowInspectedStyle;
+/** Compile every declared theme for every logical map in deterministic key order. */
+declare function createStylesFromCatalog(catalog: TileflowBuildCatalog, options?: Omit<TileflowStyleOptions, 'preparedAssets' | 'theme'> & {
+    mapAssets?: Readonly<Record<string, TileflowPreparedMapAssets>>;
+}): TileflowBuildStyles;
+/** Compile every declared theme with a separate read-only physical-output diagnostic sidecar. */
+declare function createStylesFromCatalogWithInspection(catalog: TileflowBuildCatalog, options?: Omit<TileflowStyleOptions, 'preparedAssets' | 'theme'> & {
+    mapAssets?: Readonly<Record<string, TileflowPreparedMapAssets>>;
+}): TileflowBuildInspectedStyles;
+declare function createManifest(catalog: TileflowBuildCatalog, options?: {
+    styleBaseUrl?: string;
+    manifestVersion?: 1 | 2;
+}): TileflowRuntimeManifest;
+
+export { type TileflowBuildAssetIdentity, type TileflowBuildCatalog, type TileflowBuildInspectedStyles, type TileflowBuildStyles, type TileflowCompiledMapMetadata, TileflowDataRequirementsV1, type TileflowEffectiveFontSourceIdentity, type TileflowEffectiveIconSourceIdentity, type TileflowEffectiveMapSourceAssets, type TileflowEffectiveModelSourceIdentity, type TileflowHashableBuildAsset, TileflowInspectedStyle, type TileflowMapBuildInput, type TileflowMapBuildLineageEntry, type TileflowMapBuildManifestEntryV1, type TileflowMapBuildManifestV1, type TileflowMapBuildProvenanceV1, TileflowPreparedMapAssets, type TileflowRendererDeploymentArtifact, TileflowRendererDeploymentError, type TileflowRendererDeploymentResponse, TileflowSourceRequirementsV1, type TileflowThemeBuildManifestEntryV1, collectTileflowMapBuildLineage, createManifest, createStyleFromCatalog, createStyleFromCatalogWithInspection, createStyleWithInspection, createStylesFromCatalog, createStylesFromCatalogWithInspection, createTileflowMapBuildManifest, hashTileflowAssetSet, hashTileflowAssetSetIdentities, hashTileflowMapRevision, parseTileflowRendererDeploymentArtifact, tileflowMapBuildManifestFileName, tileflowMapBuildManifestSchemaVersion, tileflowMapRevisionCanonicalization, tileflowMapRevisionSchemaVersion, tileflowRendererDeploymentArtifactSchema, tileflowRendererDeploymentLimits, tileflowRendererDeploymentResponseSchema, tileflowSharedIconMapRevisionSchemaVersion };