@tileflow/dev 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/preview-assets-6LYL7GP7.js

@@ -0,0 +1,145 @@
+import {
+  isPathWithin
+} from "./chunk-D4OE4ITL.js";
+
+// src/preview-assets.ts
+import { readFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+var localRequire = createRequire(import.meta.url);
+var localMapLibreJavaScript;
+var localMapLibreStylesheet;
+var localTileflowBrowserJavaScript;
+var localThreeCoreJavaScript;
+var localThreeModuleJavaScript;
+var localPmtilesJavaScript;
+var localFflateJavaScript;
+function getTileflowPreviewRuntimeResponse(path) {
+  if (path === "/__runtime/maplibre-gl.js") {
+    return textAssetResponse(getLocalMapLibreAsset("js"), "text/javascript; charset=utf-8");
+  }
+  if (path === "/__runtime/maplibre-gl.css") {
+    return textAssetResponse(getLocalMapLibreAsset("css"), "text/css; charset=utf-8");
+  }
+  if (path === "/__runtime/tileflow-browser.js") {
+    return textAssetResponse(getLocalTileflowBrowserAsset(), "text/javascript; charset=utf-8");
+  }
+  if (path === "/__runtime/three.module.js") {
+    return textAssetResponse(getLocalThreeAsset("module"), "text/javascript; charset=utf-8");
+  }
+  if (path === "/__runtime/three.core.min.js") {
+    return textAssetResponse(getLocalThreeAsset("core"), "text/javascript; charset=utf-8");
+  }
+  if (path === "/__runtime/pmtiles.js") {
+    return textAssetResponse(getLocalPmtilesAsset(), "text/javascript; charset=utf-8");
+  }
+  if (path === "/__runtime/fflate.js") {
+    return textAssetResponse(getLocalFflateAsset(), "text/javascript; charset=utf-8");
+  }
+  if (path === "/__runtime/three-addons/libs/draco/gltf/draco_decoder.wasm") {
+    return binaryAssetResponse(
+      getLocalThreeAddonBinaryAsset("libs/draco/gltf/draco_decoder.wasm"),
+      "application/wasm"
+    );
+  }
+  if (path.startsWith("/__runtime/three-addons/")) {
+    return textAssetResponse(
+      getLocalThreeAddonAsset(path.slice("/__runtime/three-addons/".length)),
+      "text/javascript; charset=utf-8"
+    );
+  }
+  return void 0;
+}
+function getLocalMapLibreAsset(kind) {
+  if (kind === "js" && localMapLibreJavaScript !== void 0) return localMapLibreJavaScript;
+  if (kind === "css" && localMapLibreStylesheet !== void 0) return localMapLibreStylesheet;
+  const packagePath = localRequire.resolve("maplibre-gl/package.json");
+  const source = readFileSync(
+    join(dirname(packagePath), "dist", kind === "js" ? "maplibre-gl.js" : "maplibre-gl.css"),
+    "utf8"
+  );
+  if (kind === "js") localMapLibreJavaScript = source;
+  else localMapLibreStylesheet = source;
+  return source;
+}
+function getLocalTileflowBrowserAsset() {
+  if (localTileflowBrowserJavaScript !== void 0) return localTileflowBrowserJavaScript;
+  const packagePath = localRequire.resolve("@tileflow/core/package.json");
+  localTileflowBrowserJavaScript = readFileSync(
+    join(dirname(packagePath), "dist", "browser.js"),
+    "utf8"
+  );
+  return localTileflowBrowserJavaScript;
+}
+function getLocalThreeAsset(kind) {
+  if (kind === "core" && localThreeCoreJavaScript !== void 0) return localThreeCoreJavaScript;
+  if (kind === "module" && localThreeModuleJavaScript !== void 0)
+    return localThreeModuleJavaScript;
+  const commonJsPath = localRequire.resolve("three");
+  const source = readFileSync(
+    join(dirname(commonJsPath), kind === "core" ? "three.core.min.js" : "three.module.min.js"),
+    "utf8"
+  );
+  if (kind === "core") localThreeCoreJavaScript = source;
+  else localThreeModuleJavaScript = source;
+  return source;
+}
+function getLocalThreeAddonAsset(relativePath) {
+  if (!/^[A-Za-z0-9_./-]+\.js$/.test(relativePath) || relativePath.includes("..")) {
+    throw new Error("Invalid Three.js addon path.");
+  }
+  const commonJsPath = localRequire.resolve("three");
+  const addonRoot = join(dirname(dirname(commonJsPath)), "examples", "jsm");
+  const assetPath = join(addonRoot, relativePath);
+  if (!isPathWithin(addonRoot, assetPath)) throw new Error("Invalid Three.js addon path.");
+  return readFileSync(assetPath, "utf8");
+}
+function getLocalThreeAddonBinaryAsset(relativePath) {
+  if (!/^[A-Za-z0-9_./-]+\.wasm$/.test(relativePath) || relativePath.includes("..")) {
+    throw new Error("Invalid Three.js binary addon path.");
+  }
+  const commonJsPath = localRequire.resolve("three");
+  const addonRoot = join(dirname(dirname(commonJsPath)), "examples", "jsm");
+  const assetPath = join(addonRoot, relativePath);
+  if (!isPathWithin(addonRoot, assetPath)) throw new Error("Invalid Three.js binary addon path.");
+  return readFileSync(assetPath);
+}
+function getLocalPmtilesAsset() {
+  if (localPmtilesJavaScript !== void 0) return localPmtilesJavaScript;
+  const packagePath = localRequire.resolve("pmtiles/package.json");
+  localPmtilesJavaScript = readFileSync(
+    join(dirname(packagePath), "dist", "esm", "index.js"),
+    "utf8"
+  );
+  return localPmtilesJavaScript;
+}
+function getLocalFflateAsset() {
+  if (localFflateJavaScript !== void 0) return localFflateJavaScript;
+  const commonJsPath = localRequire.resolve("fflate");
+  localFflateJavaScript = readFileSync(
+    join(dirname(dirname(commonJsPath)), "esm", "browser.js"),
+    "utf8"
+  );
+  return localFflateJavaScript;
+}
+function textAssetResponse(body, contentType) {
+  return new Response(body, {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Cache-Control": "no-store",
+      "Content-Type": contentType
+    }
+  });
+}
+function binaryAssetResponse(body, contentType) {
+  return new Response(new Uint8Array(body), {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Cache-Control": "no-store",
+      "Content-Type": contentType
+    }
+  });
+}
+export {
+  getTileflowPreviewRuntimeResponse
+};

package/dist/preview.d.ts

@@ -0,0 +1,69 @@
+import { TileflowStyleFontFace, NormalizedTileflowCaptureScene } from '@tileflow/core';
+import { TileflowBuildCatalog } from '@tileflow/core/build';
+
+declare function renderTileflowPreviewHtml(preview: ResolvedTileflowPreview | undefined, basePath: string, initialStatus: unknown, isSemanticPreview: boolean, fontFaces?: readonly TileflowStyleFontFace[]): string;
+
+type TileflowLandmarkAxisConvention = 'ENU_Z_UP' | 'EUN_Y_UP' | 'EUS_Y_UP';
+type TileflowLandmarkArchive = {
+    bytes: number;
+    id: string;
+    sha256: string;
+    url: string;
+};
+type TileflowLandmarkModel = {
+    archive: TileflowLandmarkArchive;
+    archiveId: string;
+    axisConvention: TileflowLandmarkAxisConvention;
+    bytes: number;
+    key: string;
+    minzoom: number;
+    sha256: string;
+    x: number;
+    y: number;
+    z: number;
+};
+type TileflowLandmark = {
+    bounds: [number, number, number, number];
+    center: [number, number];
+    id: string;
+    models: TileflowLandmarkModel[];
+    priority: number;
+};
+type TileflowLandmarkManifestV2 = {
+    archives: TileflowLandmarkArchive[];
+    id: string;
+    landmarks: TileflowLandmark[];
+    maximumCachedModels: number;
+    maximumVisibleModels: number;
+    minzoom: number;
+    schemaVersion: 2;
+};
+/** Reads a response without ever buffering more than the declared bound. */
+declare function readBoundedTileflowResponse(response: Response, maximumBytes: number): Promise<Uint8Array>;
+/** Reads and strictly decodes a bounded UTF-8 JSON response. */
+declare function readBoundedTileflowJsonResponse(response: Response, maximumBytes: number): Promise<unknown>;
+/**
+ * Validates the browser preview's bounded v2 PMTiles landmark contract. Keep this function
+ * self-contained: the preview serializes it into its isolated browser document.
+ */
+declare function normalizeTileflowLandmarkManifest(candidate: unknown, manifestUrl: string): TileflowLandmarkManifestV2;
+
+type TileflowPreviewSelection = {
+    map?: string;
+    scene?: string;
+    theme?: string;
+};
+type ResolvedTileflowPreview = {
+    camera: NormalizedTileflowCaptureScene['camera'];
+    label: string;
+    mapName: string;
+    themeName: string;
+    viewport?: NormalizedTileflowCaptureScene['viewport'];
+};
+declare class TileflowPreviewSelectionError extends Error {
+    readonly code: "PREVIEW_SELECTION_INVALID";
+    constructor(message: string);
+}
+declare function resolveTileflowPreview(project: TileflowBuildCatalog, selection?: TileflowPreviewSelection): ResolvedTileflowPreview;
+
+export { type ResolvedTileflowPreview, type TileflowLandmark, type TileflowLandmarkArchive, type TileflowLandmarkAxisConvention, type TileflowLandmarkManifestV2, type TileflowLandmarkModel, type TileflowPreviewSelection, TileflowPreviewSelectionError, normalizeTileflowLandmarkManifest, readBoundedTileflowJsonResponse, readBoundedTileflowResponse, renderTileflowPreviewHtml, resolveTileflowPreview };

package/dist/preview.js

@@ -0,0 +1,18 @@
+import {
+  TileflowPreviewSelectionError,
+  normalizeTileflowLandmarkManifest,
+  readBoundedTileflowJsonResponse,
+  readBoundedTileflowResponse,
+  renderTileflowPreviewHtml,
+  resolveTileflowPreview
+} from "./chunk-MIGBHCXX.js";
+import "./chunk-6MGFMKG3.js";
+import "./chunk-D4OE4ITL.js";
+export {
+  TileflowPreviewSelectionError,
+  normalizeTileflowLandmarkManifest,
+  readBoundedTileflowJsonResponse,
+  readBoundedTileflowResponse,
+  renderTileflowPreviewHtml,
+  resolveTileflowPreview
+};

package/dist/server.d.ts

@@ -0,0 +1,81 @@
+import { TileflowArtifactSession, TileflowArtifactSessionState, TileflowArtifactDiagnostic } from './artifacts.js';
+export { TileflowArtifactAcquisition, TileflowArtifactSessionOptions, createTileflowArtifactDiagnostics, getTileflowAssetBasePath, getTileflowAssetFileName, joinTileflowPublicUrl, normalizeTileflowBasePath, resolveTileflowArtifactPublicUrls, tileflowArtifactSessionSchemaVersion } from './artifacts.js';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import '@tileflow/core';
+import '@tileflow/core/build';
+import '@tileflow/core/manifest';
+import './icons.js';
+import './config.js';
+
+declare const tileflowComparisonSchemaVersion: 1;
+type TileflowComparisonRequestHandler = (request: Request) => Promise<Response> | Response;
+type TileflowComparisonSide = {
+    /** Route base owned by this side's existing Tileflow dev handler. */
+    basePath: string;
+    /** Optional safe cwd-relative config argument used by Copy command. */
+    captureConfig?: string;
+    handler: TileflowComparisonRequestHandler;
+    /** Human-readable local label. It is never interpreted as HTML. */
+    label: string;
+    /** Optional compiler-inspection sidecar exposed by the owning handler. */
+    sidecarUrl?: string;
+    /** Same-origin preview URL below basePath, including its map/theme query. */
+    previewUrl: string;
+};
+type TileflowComparisonMode = 'blink' | 'overlay' | 'side-by-side' | 'split';
+type TileflowComparisonOptions = {
+    basePath?: string;
+    initialMode?: TileflowComparisonMode;
+    left: TileflowComparisonSide;
+    right: TileflowComparisonSide;
+    title?: string;
+};
+/**
+ * Compose two existing Tileflow dev handlers behind one same-origin comparison shell.
+ *
+ * The side handlers retain ownership of styles, sprites, fonts, generations, live
+ * events, and last-known-good behavior. This router owns only the shell document and
+ * deterministic dispatch by route prefix.
+ */
+declare function createTileflowComparisonRequestHandler(options: TileflowComparisonOptions): (request: Request) => Promise<Response>;
+
+type TileflowDevRequestHandlerOptions = {
+    apiBaseUrl?: string;
+    basePath?: string;
+    config?: string;
+    cwd?: string;
+    inspection?: boolean;
+    map?: string;
+    onError?: (error: unknown) => void;
+    scene?: string;
+    session?: TileflowArtifactSession;
+    styleBaseUrl?: string;
+    theme?: string;
+};
+type TileflowDevRequestHandler = ((request: Request) => Promise<Response>) & {
+    close(): Promise<void>;
+    refresh(): Promise<void>;
+};
+declare function getTileflowStyleSelection(path: string): {
+    mapName: string;
+    themeName: string;
+} | undefined;
+declare function getTileflowStyleInspectionSelection(path: string): {
+    mapName: string;
+    themeName: string;
+} | undefined;
+declare function isTileflowRequestUrl(url: string | undefined, basePath: string): boolean;
+/** Match and strip the configured route base using the same route table as the request handler. */
+declare function getTileflowRequestPath(url: string | undefined, basePath: string): string | null;
+declare function createTileflowNodeRequest(request: IncomingMessage): Request;
+declare function writeTileflowNodeResponse(response: ServerResponse, tileflowResponse: Response): Promise<void>;
+declare function createTileflowDevRequestHandler(options?: TileflowDevRequestHandlerOptions): TileflowDevRequestHandler;
+declare function createTileflowArtifactStatus(state: TileflowArtifactSessionState): {
+    diagnostics?: TileflowArtifactDiagnostic[] | undefined;
+    lastGoodGeneration?: number | undefined;
+    schemaVersion: 1;
+    generation: number;
+    status: "ready" | "building" | "invalid";
+};
+
+export { TileflowArtifactDiagnostic, TileflowArtifactSession, TileflowArtifactSessionState, type TileflowComparisonMode, type TileflowComparisonOptions, type TileflowComparisonRequestHandler, type TileflowComparisonSide, type TileflowDevRequestHandler, type TileflowDevRequestHandlerOptions, createTileflowArtifactStatus, createTileflowComparisonRequestHandler, createTileflowDevRequestHandler, createTileflowNodeRequest, getTileflowRequestPath, getTileflowStyleInspectionSelection, getTileflowStyleSelection, isTileflowRequestUrl, tileflowComparisonSchemaVersion, writeTileflowNodeResponse };

package/dist/server.js

@@ -0,0 +1,48 @@
+import {
+  createTileflowArtifactStatus,
+  createTileflowComparisonRequestHandler,
+  createTileflowDevRequestHandler,
+  createTileflowNodeRequest,
+  getTileflowRequestPath,
+  getTileflowStyleInspectionSelection,
+  getTileflowStyleSelection,
+  isTileflowRequestUrl,
+  tileflowComparisonSchemaVersion,
+  writeTileflowNodeResponse
+} from "./chunk-KH7CMHT3.js";
+import {
+  createTileflowArtifactDiagnostics,
+  tileflowArtifactSessionSchemaVersion
+} from "./chunk-XTRHREXO.js";
+import "./chunk-ONYQNLNA.js";
+import {
+  getTileflowAssetBasePath,
+  getTileflowAssetFileName,
+  joinTileflowPublicUrl,
+  normalizeTileflowBasePath,
+  resolveTileflowArtifactPublicUrls
+} from "./chunk-RSBV4L2Y.js";
+import "./chunk-CENQR5Q2.js";
+import "./chunk-BL3FK4GO.js";
+import "./chunk-KDFTE4Q5.js";
+import "./chunk-6MGFMKG3.js";
+import "./chunk-D4OE4ITL.js";
+export {
+  createTileflowArtifactDiagnostics,
+  createTileflowArtifactStatus,
+  createTileflowComparisonRequestHandler,
+  createTileflowDevRequestHandler,
+  createTileflowNodeRequest,
+  getTileflowAssetBasePath,
+  getTileflowAssetFileName,
+  getTileflowRequestPath,
+  getTileflowStyleInspectionSelection,
+  getTileflowStyleSelection,
+  isTileflowRequestUrl,
+  joinTileflowPublicUrl,
+  normalizeTileflowBasePath,
+  resolveTileflowArtifactPublicUrls,
+  tileflowArtifactSessionSchemaVersion,
+  tileflowComparisonSchemaVersion,
+  writeTileflowNodeResponse
+};

package/dist/tilesets-C0tGeenP.d.ts

@@ -0,0 +1,94 @@
+declare const inspectionLimits: Readonly<{
+    maxBytes: 24000000;
+    maxDistinctValuesPerField: 256;
+    maxFeatures: 20000;
+    maxIncludedValueFields: 32;
+    maxTiles: 8;
+    maxValueLength: 256;
+    maxValuesPerField: 16;
+}>;
+type TileCoordinate = Readonly<{
+    x: number;
+    y: number;
+    z: number;
+}>;
+type FieldType = 'Boolean' | 'Number' | 'String';
+type FieldValue = boolean | number | string;
+type TileflowTilesetInspectionWarning = Readonly<{
+    code: string;
+    message: string;
+    path: string;
+}>;
+type TileflowTilesetInspectionV1 = Readonly<{
+    schemaVersion: 1;
+    contract: Readonly<{
+        authority: 'pmtiles-header-and-tilejson-v1';
+        attribution?: string;
+        bounds: readonly [number, number, number, number];
+        center: readonly [number, number, number];
+        counts: Readonly<{
+            addressedTiles: number;
+            declaredTileContents: number | null;
+            tileEntries: number;
+        }>;
+        maxzoom: number;
+        minzoom: number;
+        sourceLayersDeclared: boolean;
+        sourceLayers: readonly Readonly<{
+            fieldsDeclared: boolean;
+            fields: readonly Readonly<{
+                name: string;
+                type?: FieldType;
+            }>[];
+            id: string;
+            maxzoom?: number;
+            minzoom?: number;
+        }>[];
+        tileType: 'avif' | 'jpeg' | 'mlt' | 'mvt' | 'png' | 'webp';
+    }>;
+    observation?: Readonly<{
+        authority: 'bounded-mvt-sample-v1';
+        featuresRead: number;
+        includedValueFields: readonly string[];
+        limits: typeof inspectionLimits;
+        sourceLayers: readonly Readonly<{
+            featuresRead: number;
+            fields: readonly Readonly<{
+                distinctValuesObserved: number;
+                distinctValuesTruncated: boolean;
+                featuresMissing: number;
+                featuresPresent: number;
+                name: string;
+                numericRange?: Readonly<{
+                    max: number;
+                    min: number;
+                }>;
+                observedValues?: readonly Readonly<{
+                    count: number;
+                    value: FieldValue;
+                }>[];
+                observedValuesTruncated?: boolean;
+                types: readonly FieldType[];
+            }>[];
+            geometryTypes: readonly string[];
+            id: string;
+        }>[];
+        tiles: readonly TileCoordinate[];
+        tilesRead: number;
+        truncated: boolean;
+    }>;
+    warnings: readonly TileflowTilesetInspectionWarning[];
+}>;
+type TileflowLocalTilesetInspection = Readonly<{
+    contract: Pick<TileflowTilesetInspectionV1['contract'], 'sourceLayers' | 'sourceLayersDeclared' | 'tileType'>;
+    warnings: readonly TileflowTilesetInspectionWarning[];
+}>;
+declare function inspectTileflowPmtilesForLocalUse(archivePath: string): Promise<TileflowLocalTilesetInspection>;
+declare function inspectTileflowPmtiles(archivePath: string, options?: {
+    includeValues?: readonly string[];
+    maximumDirectoryDepth?: number;
+    sample?: boolean;
+    signal?: AbortSignal;
+}): Promise<TileflowTilesetInspectionV1>;
+
+export { type TileflowLocalTilesetInspection as T, type TileflowTilesetInspectionV1 as a, type TileflowTilesetInspectionWarning as b, inspectTileflowPmtilesForLocalUse as c, inspectTileflowPmtiles as i };

package/dist/tilesets.d.ts

@@ -0,0 +1 @@
+export { a as TileflowTilesetInspectionV1, b as TileflowTilesetInspectionWarning, i as inspectTileflowPmtiles } from './tilesets-C0tGeenP.js';

package/dist/tilesets.js

@@ -0,0 +1,6 @@
+import {
+  inspectTileflowPmtiles
+} from "./chunk-ONYQNLNA.js";
+export {
+  inspectTileflowPmtiles
+};

package/dist/validation.d.ts

@@ -0,0 +1,63 @@
+import { MapLibreStyle } from '@tileflow/core';
+
+declare function sanitizeDiagnosticSecrets(value: string): string;
+
+type TileflowStyleValidationIssue = {
+    map: string;
+    message: string;
+    path: string;
+};
+declare class TileflowStyleValidationError extends Error {
+    readonly code: "STYLE_INVALID";
+    readonly issues: TileflowStyleValidationIssue[];
+    readonly phase: "style-validation";
+    constructor(issues: readonly TileflowStyleValidationIssue[]);
+}
+declare function assertValidTileflowStyle(style: MapLibreStyle, map: string): void;
+declare function validateTileflowStyle(style: MapLibreStyle, map: string): TileflowStyleValidationIssue[];
+
+declare const tileflowCommandDocumentSchemaVersion: 1;
+type TileflowDiagnosticSeverity = 'error' | 'info' | 'warning';
+/** Stable, bounded diagnostic contract intended for tools and coding agents. */
+type TileflowStructuredDiagnostic = {
+    phase: string;
+    code: string;
+    /** Semantic compiler domain. Legacy `owner` inputs are normalized to this field. */
+    domain?: string;
+    path: string;
+    /** Semantic compiler target, when the diagnostic applies to one render contribution. */
+    target?: string;
+    severity: TileflowDiagnosticSeverity;
+    message: string;
+    suggestion: string;
+};
+type TileflowCommandSummary = TileflowStructuredDiagnostic & {
+    schemaVersion: typeof tileflowCommandDocumentSchemaVersion;
+    command: string;
+    ok: boolean;
+};
+type TileflowCommandFailureDocument = TileflowCommandSummary & {
+    ok: false;
+    diagnostics: TileflowStructuredDiagnostic[];
+};
+type TileflowDiagnosticDefaults = {
+    code: string;
+    phase: string;
+    severity?: TileflowDiagnosticSeverity;
+};
+declare function createTileflowCommandSummary(input: {
+    code: string;
+    command: string;
+    message: string;
+    ok: boolean;
+    path?: string;
+    phase: string;
+    severity: TileflowDiagnosticSeverity;
+    suggestion: string;
+}): TileflowCommandSummary;
+/** Convert arbitrary SDK failures to sorted diagnostics without leaking paths, URLs, or secrets. */
+declare function createTileflowStructuredDiagnostics(error: unknown, cwd: string, defaults: TileflowDiagnosticDefaults): TileflowStructuredDiagnostic[];
+declare function createTileflowCommandFailureDocument(command: string, error: unknown, cwd: string, defaults: TileflowDiagnosticDefaults): TileflowCommandFailureDocument;
+declare function serializeTileflowCommandDocument(value: unknown): string;
+
+export { type TileflowCommandFailureDocument, type TileflowCommandSummary, type TileflowDiagnosticSeverity, type TileflowStructuredDiagnostic, TileflowStyleValidationError, type TileflowStyleValidationIssue, assertValidTileflowStyle, createTileflowCommandFailureDocument, createTileflowCommandSummary, createTileflowStructuredDiagnostics, sanitizeDiagnosticSecrets, serializeTileflowCommandDocument, tileflowCommandDocumentSchemaVersion, validateTileflowStyle };

package/dist/validation.js

@@ -0,0 +1,24 @@
+import {
+  createTileflowCommandFailureDocument,
+  createTileflowCommandSummary,
+  createTileflowStructuredDiagnostics,
+  serializeTileflowCommandDocument,
+  tileflowCommandDocumentSchemaVersion
+} from "./chunk-LNCTVFUD.js";
+import {
+  TileflowStyleValidationError,
+  assertValidTileflowStyle,
+  sanitizeDiagnosticSecrets,
+  validateTileflowStyle
+} from "./chunk-KDFTE4Q5.js";
+export {
+  TileflowStyleValidationError,
+  assertValidTileflowStyle,
+  createTileflowCommandFailureDocument,
+  createTileflowCommandSummary,
+  createTileflowStructuredDiagnostics,
+  sanitizeDiagnosticSecrets,
+  serializeTileflowCommandDocument,
+  tileflowCommandDocumentSchemaVersion,
+  validateTileflowStyle
+};