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

package/dist/artifacts.d.ts

@@ -0,0 +1,191 @@
+import { TileflowStyleOptions, MapLibreStyle } from '@tileflow/core';
+import { TileflowBuildCatalog, TileflowBuildStyles, TileflowMapBuildManifestV1, TileflowStyleInspection, TileflowMapBuildProvenanceV1, TileflowPreparedMapAssets } from '@tileflow/core/build';
+import { TileflowRuntimeManifest } from '@tileflow/core/manifest';
+import { TileflowBuildAsset, PreparedTileflowBuildCatalog, TileflowSourceCatalog, PreparedTileflowCatalog } from './icons.js';
+export { defaultTileflowConfigPath } from './config.js';
+
+type TileflowLocalTilesetFile = Readonly<{
+    byteLength: number;
+    etag: string;
+    fileName: string;
+    logicalId: string;
+    sourcePath: string;
+}>;
+declare function prepareTileflowLocalTilesets(project: TileflowBuildCatalog, styles: TileflowBuildStyles, options: {
+    assetBaseUrl: string;
+    baseDirectory: string;
+    cwd: string;
+}): Promise<{
+    dispose(): Promise<void>;
+    files: TileflowLocalTilesetFile[];
+    styles: TileflowBuildStyles;
+    watchPaths: string[];
+}>;
+
+declare const tileflowArtifactSessionSchemaVersion: 1;
+type TileflowArtifactDiagnostic = {
+    code?: string;
+    message: string;
+    path: string;
+    phase?: string;
+};
+type TileflowArtifactSessionState = {
+    status: 'building';
+    generation: number;
+    lastGoodGeneration?: number;
+} | {
+    status: 'ready';
+    generation: number;
+    artifacts: TileflowBuildArtifacts;
+    lastGoodGeneration: number;
+} | {
+    status: 'invalid';
+    generation: number;
+    diagnostics: TileflowArtifactDiagnostic[];
+    lastGoodGeneration?: number;
+};
+type TileflowArtifactSessionOptions = TileflowBuildArtifactsOptions & {
+    debounceMs?: number;
+    ignoredPaths?: string[];
+    watch?: boolean;
+};
+type TileflowArtifactAcquisition = Readonly<{
+    artifacts: TileflowBuildArtifacts;
+    generation: number;
+    release(): Promise<void>;
+}>;
+type TileflowArtifactSession = {
+    /** Pins the current generation for asynchronous work; the caller must release it. */
+    acquireArtifacts(generation?: number): TileflowArtifactAcquisition | undefined;
+    close(): Promise<void>;
+    /** Borrowed synchronous view. Use acquireArtifacts() before retaining it across an await. */
+    getLastGoodArtifacts(): TileflowBuildArtifacts | undefined;
+    /** Ready-state artifacts are a borrowed synchronous view. */
+    getState(): TileflowArtifactSessionState;
+    refresh(reason?: string): Promise<void>;
+    subscribe(listener: (state: TileflowArtifactSessionState) => void): () => void;
+};
+declare function createTileflowArtifactDiagnostics(error: unknown, cwd: string): TileflowArtifactDiagnostic[];
+
+/** Normalize a development route base. This is a URL pathname, never a filesystem path. */
+declare function normalizeTileflowBasePath(value?: string): string;
+/**
+ * Join a bundler public URL prefix to the Tileflow route without changing URL-reference kind.
+ * In particular, `./` and `../` remain path-relative rather than becoming root-relative.
+ */
+declare function joinTileflowPublicUrl(publicBase: string, basePath: string): string;
+/**
+ * Resolve the public URL at which a manifest is exposed and the URLs embedded inside its artifacts.
+ * Path-relative deployments use owner-relative references because the manifest already lives below
+ * the public prefix.
+ */
+declare function resolveTileflowArtifactPublicUrls(publicBase: string, basePath: string): {
+    assetBaseUrl?: string;
+    publicBaseUrl: string;
+    styleBaseUrl: string;
+};
+/** Convert a validated route base to a bundler-relative asset prefix. */
+declare function getTileflowAssetBasePath(basePath: string): string;
+declare function getTileflowAssetFileName(basePath: string, fileName: string): string;
+
+declare const tileflowArtifactPlanSchemaVersion: 1;
+declare const tileflowArtifactInventoryFileName = ".tileflow-artifacts.json";
+type TileflowManifestOptions = {
+    styleBaseUrl?: string;
+};
+type TileflowBuildArtifactsOptions = {
+    apiBaseUrl?: string;
+    assetBaseUrl?: string;
+    config?: string;
+    cwd?: string;
+    /** Build a memory-only compiler sidecar for local authoring tools. */
+    inspection?: boolean;
+    styleBaseUrl?: string;
+    /** Local tools may snapshot local PMTiles; production output must resolve them explicitly. */
+    target?: 'local' | 'production';
+};
+type TileflowBuildStyleInspections = Record<string, Record<string, TileflowStyleInspection>>;
+/** Compatibility shape consumed by sessions and capture callers. */
+type TileflowBuildArtifacts = {
+    assets: TileflowBuildAsset[];
+    buildManifest: TileflowMapBuildManifestV1;
+    /** Releases local immutable snapshot references owned by this artifact generation. */
+    dispose?: () => Promise<void>;
+    manifest: TileflowRuntimeManifest;
+    project: TileflowBuildCatalog;
+    /** Local-only archive ports. Paths never enter serialized build artifacts. */
+    localTilesets?: TileflowLocalTilesetFile[];
+    /** Optional local-only provenance. It is never serialized as a build artifact. */
+    styleInspections?: TileflowBuildStyleInspections;
+    styles: TileflowBuildStyles;
+    watchPaths: string[];
+};
+type TileflowArtifactFile = TileflowBuildAsset;
+type TileflowArtifactInputGraph = {
+    /** Exact executable config modules and data files observed during evaluation. */
+    files: string[];
+    /** Asset directories whose children can change without changing the config module. */
+    directories: string[];
+};
+/**
+ * Complete, deterministic output of compiling one prepared source generation.
+ * `sourceProject` is retained for diagnostics only; `project` is the portable runtime input.
+ */
+type TileflowArtifactPlan = TileflowBuildArtifacts & {
+    files: TileflowArtifactFile[];
+    inputs: TileflowArtifactInputGraph;
+    project: PreparedTileflowBuildCatalog;
+    schemaVersion: typeof tileflowArtifactPlanSchemaVersion;
+    sourceProject: TileflowSourceCatalog;
+};
+type CreateTileflowArtifactPlanOptions = Pick<TileflowBuildArtifactsOptions, 'apiBaseUrl' | 'assetBaseUrl' | 'inspection' | 'styleBaseUrl' | 'target'> & {
+    inputFiles?: readonly string[];
+};
+type WriteTileflowArtifactPlanOptions = {
+    cwd?: string;
+    outDir: string;
+    /** Explicit escape hatch for replacing a Hosted delivery manifest with self-hosted artifacts. */
+    overwriteHostedManifest?: boolean;
+};
+type WriteTileflowBuildArtifactsOptions = TileflowBuildArtifactsOptions & WriteTileflowArtifactPlanOptions;
+declare class TileflowHostedManifestOverwriteError extends Error {
+    readonly code: "HOSTED_MANIFEST_OVERWRITE_REFUSED";
+    constructor(path: string);
+}
+declare class TileflowLocalTilesetProductionError extends Error {
+    readonly code: "TF_LOCAL_TILESET_PRODUCTION_UNRESOLVED";
+    constructor();
+}
+declare function createTileflowManifest(project: TileflowBuildCatalog, options?: TileflowManifestOptions): TileflowRuntimeManifest;
+declare function createTileflowStyle(project: TileflowBuildCatalog, mapName: string, options?: TileflowStyleOptions): MapLibreStyle;
+declare function createTileflowStyles(project: TileflowBuildCatalog, options?: Omit<TileflowStyleOptions, 'preparedAssets' | 'theme'> & {
+    mapAssets?: Readonly<Record<string, TileflowPreparedMapAssets>>;
+}): TileflowBuildStyles;
+/** Compiles only a prepared project, keeping local source resolution out of core compilation. */
+declare function createTileflowArtifactPlan(prepared: PreparedTileflowCatalog, options?: CreateTileflowArtifactPlanOptions): Promise<TileflowArtifactPlan>;
+declare function createTileflowBuildArtifacts(options?: TileflowBuildArtifactsOptions): Promise<TileflowArtifactPlan>;
+declare function getTileflowArtifactFiles(artifacts: TileflowBuildArtifacts): TileflowArtifactFile[];
+/** Resolve portable build provenance without making it part of any map authoring revision. */
+declare function createTileflowBuildProvenance(cwd: string): Promise<TileflowMapBuildProvenanceV1>;
+declare function createTileflowArtifactSession(options?: TileflowArtifactSessionOptions): Promise<TileflowArtifactSession>;
+declare function getTileflowWatchPaths(options?: Pick<TileflowBuildArtifactsOptions, 'config' | 'cwd'>): Promise<string[]>;
+declare function isTileflowArtifactInputPath(inputs: TileflowArtifactInputGraph, path: string): boolean;
+/** Shared refresh gate for adapters that receive filesystem or framework lifecycle events. */
+declare function refreshTileflowArtifactSession(session: TileflowArtifactSession, options: {
+    inputPath?: string;
+    reason: string;
+}): Promise<boolean>;
+declare function writeTileflowBuildArtifacts(options: WriteTileflowBuildArtifactsOptions): Promise<TileflowArtifactPlan>;
+declare function disposeTileflowBuildArtifacts(artifacts: Pick<TileflowBuildArtifacts, 'dispose'>): Promise<void>;
+/**
+ * Replaces one managed artifact generation and records its exact file inventory. Unmanaged files
+ * are never scanned or removed. A caught filesystem failure restores every previous managed file.
+ */
+declare function writeTileflowArtifactPlan(artifacts: TileflowArtifactPlan, options: WriteTileflowArtifactPlanOptions): Promise<void>;
+declare function assertNoLocalTilesetsForProduction(artifacts: Pick<TileflowBuildArtifacts, 'localTilesets'>): void;
+/** Prevents a framework build from silently replacing the frontend's Hosted delivery contract. */
+declare function assertTileflowSelfHostedManifestTarget(manifestPath: string, options?: {
+    overwriteHostedManifest?: boolean;
+}): Promise<void>;
+
+export { type CreateTileflowArtifactPlanOptions, PreparedTileflowBuildCatalog, PreparedTileflowCatalog, type TileflowArtifactAcquisition, type TileflowArtifactDiagnostic, type TileflowArtifactFile, type TileflowArtifactInputGraph, type TileflowArtifactPlan, type TileflowArtifactSession, type TileflowArtifactSessionOptions, type TileflowArtifactSessionState, type TileflowBuildArtifacts, type TileflowBuildArtifactsOptions, TileflowBuildAsset, type TileflowBuildStyleInspections, TileflowHostedManifestOverwriteError, type TileflowLocalTilesetFile, TileflowLocalTilesetProductionError, type TileflowManifestOptions, TileflowSourceCatalog, type WriteTileflowArtifactPlanOptions, type WriteTileflowBuildArtifactsOptions, assertNoLocalTilesetsForProduction, assertTileflowSelfHostedManifestTarget, createTileflowArtifactDiagnostics, createTileflowArtifactPlan, createTileflowArtifactSession, createTileflowBuildArtifacts, createTileflowBuildProvenance, createTileflowManifest, createTileflowStyle, createTileflowStyles, disposeTileflowBuildArtifacts, getTileflowArtifactFiles, getTileflowAssetBasePath, getTileflowAssetFileName, getTileflowWatchPaths, isTileflowArtifactInputPath, joinTileflowPublicUrl, normalizeTileflowBasePath, prepareTileflowLocalTilesets, refreshTileflowArtifactSession, resolveTileflowArtifactPublicUrls, tileflowArtifactInventoryFileName, tileflowArtifactPlanSchemaVersion, tileflowArtifactSessionSchemaVersion, writeTileflowArtifactPlan, writeTileflowBuildArtifacts };

package/dist/artifacts.js

@@ -0,0 +1,71 @@
+import {
+  TileflowHostedManifestOverwriteError,
+  TileflowLocalTilesetProductionError,
+  assertNoLocalTilesetsForProduction,
+  assertTileflowSelfHostedManifestTarget,
+  createTileflowArtifactDiagnostics,
+  createTileflowArtifactPlan,
+  createTileflowArtifactSession,
+  createTileflowBuildArtifacts,
+  createTileflowBuildProvenance,
+  createTileflowManifest,
+  createTileflowStyle,
+  createTileflowStyles,
+  disposeTileflowBuildArtifacts,
+  getTileflowArtifactFiles,
+  getTileflowWatchPaths,
+  isTileflowArtifactInputPath,
+  prepareTileflowLocalTilesets,
+  refreshTileflowArtifactSession,
+  tileflowArtifactInventoryFileName,
+  tileflowArtifactPlanSchemaVersion,
+  tileflowArtifactSessionSchemaVersion,
+  writeTileflowArtifactPlan,
+  writeTileflowBuildArtifacts
+} 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 {
+  defaultTileflowConfigPath
+} from "./chunk-6MGFMKG3.js";
+import "./chunk-D4OE4ITL.js";
+export {
+  TileflowHostedManifestOverwriteError,
+  TileflowLocalTilesetProductionError,
+  assertNoLocalTilesetsForProduction,
+  assertTileflowSelfHostedManifestTarget,
+  createTileflowArtifactDiagnostics,
+  createTileflowArtifactPlan,
+  createTileflowArtifactSession,
+  createTileflowBuildArtifacts,
+  createTileflowBuildProvenance,
+  createTileflowManifest,
+  createTileflowStyle,
+  createTileflowStyles,
+  defaultTileflowConfigPath,
+  disposeTileflowBuildArtifacts,
+  getTileflowArtifactFiles,
+  getTileflowAssetBasePath,
+  getTileflowAssetFileName,
+  getTileflowWatchPaths,
+  isTileflowArtifactInputPath,
+  joinTileflowPublicUrl,
+  normalizeTileflowBasePath,
+  prepareTileflowLocalTilesets,
+  refreshTileflowArtifactSession,
+  resolveTileflowArtifactPublicUrls,
+  tileflowArtifactInventoryFileName,
+  tileflowArtifactPlanSchemaVersion,
+  tileflowArtifactSessionSchemaVersion,
+  writeTileflowArtifactPlan,
+  writeTileflowBuildArtifacts
+};

package/dist/chunk-6MGFMKG3.js

@@ -0,0 +1,284 @@
+import {
+  isPathWithin
+} from "./chunk-D4OE4ITL.js";
+
+// src/config.ts
+import { createJiti } from "jiti";
+import { existsSync, realpathSync } from "fs";
+import { createRequire } from "module";
+import { dirname, resolve, sep } from "path";
+import {
+  parseResolvedTileflowMap,
+  parseTileflowMap,
+  tileflowCaptureSceneNameSchema,
+  TileflowResolvedMapValidationError
+} from "@tileflow/core";
+import { collectTileflowMapBuildLineage } from "@tileflow/core/build";
+var defaultTileflowApiUrl = "https://api.tileflow.dev";
+var defaultTileflowConfigPath = "tileflow.config.ts";
+var defaultTileflowManifestPath = "public/tileflow/manifest.json";
+var TileflowValidationError = class extends Error {
+  code = "CONFIG_INVALID";
+  messages;
+  phase = "config-validation";
+  constructor(messages) {
+    super("Invalid Tileflow config");
+    this.name = "TileflowValidationError";
+    this.messages = messages;
+  }
+};
+async function loadTileflowConfig(configPath = defaultTileflowConfigPath, options = {}) {
+  return (await loadTileflowConfigWithInputs(configPath, options)).project;
+}
+async function loadTileflowConfigWithInputs(configPath = defaultTileflowConfigPath, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const resolvedPath = resolve(cwd, configPath);
+  if (!existsSync(resolvedPath)) {
+    throw new Error(`Config not found: ${configPath}`);
+  }
+  if (options.fresh) {
+    clearTileflowLocalModuleCache(resolvedPath, cwd);
+  }
+  const jiti = createJiti(import.meta.url, {
+    fsCache: false,
+    moduleCache: true
+  });
+  const imported = await jiti.import(resolvedPath, { default: true });
+  const allowWorkspace = /\.workspace\.(?:[cm]?[jt]s)$/u.test(resolvedPath);
+  const project = asTileflowBuildCatalog(imported, { allowWorkspace });
+  return {
+    authoringMaps: getTileflowAuthoringMaps(imported, project, allowWorkspace),
+    configFile: resolvedPath,
+    inputFiles: collectTileflowConfigInputs(resolvedPath, cwd),
+    project
+  };
+}
+async function loadValidTileflowConfig(configPath = defaultTileflowConfigPath, options = {}) {
+  const project = await loadTileflowConfig(configPath, options);
+  assertValidTileflowConfig(project);
+  return project;
+}
+async function loadValidTileflowConfigWithInputs(configPath = defaultTileflowConfigPath, options = {}) {
+  const loaded = await loadTileflowConfigWithInputs(configPath, options);
+  assertValidTileflowConfig(loaded.project);
+  return loaded;
+}
+function assertValidTileflowConfig(project) {
+  const messages = [];
+  for (const [mapId, map] of Object.entries(project.maps)) {
+    try {
+      parseResolvedTileflowMap(map);
+    } catch (error) {
+      messages.push({
+        level: "error",
+        path: `maps.${mapId}`,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  for (const [sceneId, scene] of Object.entries(project.scenes ?? {})) {
+    if (!Object.hasOwn(project.maps, scene.map)) {
+      messages.push({
+        level: "error",
+        path: `scenes.${sceneId}.map`,
+        message: `Unknown Tileflow map "${scene.map}".`
+      });
+    }
+  }
+  if (messages.length > 0) throw new TileflowValidationError(messages);
+}
+function asTileflowBuildCatalog(input, options = {}) {
+  if (isRecord(input) && isRecord(input.maps)) {
+    if (!options.allowWorkspace) {
+      throw tileflowConfigValidationError(
+        "maps",
+        new Error(
+          "tileflow.config.ts must export one map. Multi-map catalogs are internal workspaces and must use a *.workspace.ts file."
+        )
+      );
+    }
+    const unknownKey = Object.keys(input).find((key) => key !== "maps");
+    if (unknownKey) {
+      throw tileflowConfigValidationError(
+        unknownKey,
+        new Error(`Tileflow workspace has unrecognized key "${unknownKey}".`)
+      );
+    }
+    const entries = Object.entries(input.maps).map(([key, value]) => {
+      const map2 = value;
+      const resolved2 = parseTileflowCatalogMap(map2, `maps.${key}`);
+      if (key !== resolved2.id) {
+        throw tileflowConfigValidationError(
+          `maps.${key}`,
+          new Error(`Tileflow workspace map key "${key}" must match the map id "${resolved2.id}".`)
+        );
+      }
+      return [
+        key,
+        resolved2,
+        collectTileflowMapBuildLineage(map2),
+        normalizeSingularMapScenes(map2, resolved2.id)
+      ];
+    });
+    if (entries.length === 0) {
+      throw tileflowConfigValidationError(
+        "maps",
+        new Error("Tileflow workspace must contain at least one map.")
+      );
+    }
+    const scenes2 = /* @__PURE__ */ new Map();
+    for (const [mapId, , , mapScenes] of entries) {
+      for (const [sceneId, scene] of Object.entries(mapScenes ?? {})) {
+        if (scenes2.has(sceneId)) {
+          throw tileflowConfigValidationError(
+            `maps.${mapId}.scenes.${sceneId}`,
+            new Error(`Tileflow workspace scene "${sceneId}" is already defined by another map.`)
+          );
+        }
+        scenes2.set(sceneId, scene);
+      }
+    }
+    return {
+      mapMetadata: Object.fromEntries(
+        entries.map(([id, map2, lineage]) => [id, { id, lineage, version: map2.version }])
+      ),
+      maps: Object.fromEntries(entries.map(([id, map2]) => [id, map2])),
+      ...scenes2.size > 0 ? { scenes: Object.fromEntries(scenes2) } : {}
+    };
+  }
+  const map = input;
+  const resolved = parseTileflowCatalogMap(map, "");
+  let scenes;
+  try {
+    scenes = normalizeSingularMapScenes(map, resolved.id);
+  } catch (error) {
+    throw tileflowConfigValidationError("scenes", error);
+  }
+  return {
+    mapMetadata: {
+      [resolved.id]: {
+        id: resolved.id,
+        lineage: collectTileflowMapBuildLineage(map),
+        version: resolved.version
+      }
+    },
+    maps: { [resolved.id]: resolved },
+    ...scenes ? { scenes } : {}
+  };
+}
+function parseTileflowCatalogMap(map, path) {
+  try {
+    return parseTileflowMap(map);
+  } catch (error) {
+    throw tileflowConfigValidationError(path, error);
+  }
+}
+function getTileflowAuthoringMaps(input, project, allowWorkspace) {
+  if (allowWorkspace && isRecord(input) && isRecord(input.maps)) {
+    const maps = input.maps;
+    return Object.fromEntries(
+      Object.keys(project.maps).map((mapId2) => [mapId2, maps[mapId2]])
+    );
+  }
+  const [mapId] = Object.keys(project.maps);
+  return mapId ? { [mapId]: input } : {};
+}
+function tileflowConfigValidationError(path, error) {
+  if (error instanceof TileflowValidationError) return error;
+  if (error instanceof TileflowResolvedMapValidationError) {
+    return new TileflowValidationError(
+      error.messages.map((message) => ({
+        ...message,
+        path: prefixValidationPath(path, message.path)
+      }))
+    );
+  }
+  return new TileflowValidationError([
+    {
+      level: "error",
+      path: path || "map",
+      message: error instanceof Error ? error.message : String(error)
+    }
+  ]);
+}
+function prefixValidationPath(prefix, path) {
+  const child = path === "config" ? "" : path;
+  if (!prefix) return child || "map";
+  return child ? `${prefix}.${child}` : prefix;
+}
+function normalizeSingularMapScenes(map, mapId) {
+  if (!map.scenes) return void 0;
+  return Object.fromEntries(
+    Object.entries(map.scenes).map(([sceneId, scene]) => {
+      const normalizedSceneId = tileflowCaptureSceneNameSchema.parse(sceneId);
+      return [normalizedSceneId, { ...scene, map: mapId }];
+    })
+  );
+}
+function getTileflowMapNames(project) {
+  return Object.keys(project.maps);
+}
+function getFirstTileflowMapName(project) {
+  const [mapName] = getTileflowMapNames(project);
+  if (!mapName) {
+    throw new Error("Tileflow config must define at least one map.");
+  }
+  return mapName;
+}
+var localRequire = createRequire(import.meta.url);
+function collectTileflowConfigInputs(configPath, cwd) {
+  const roots = [canonicalPath(cwd), canonicalPath(dirname(resolve(configPath)))];
+  const inputs = /* @__PURE__ */ new Set([canonicalPath(configPath)]);
+  const pending = [localRequire.cache[canonicalPath(configPath)]];
+  const visited = /* @__PURE__ */ new Set();
+  while (pending.length > 0) {
+    const module = pending.pop();
+    if (!module || visited.has(module.filename)) continue;
+    visited.add(module.filename);
+    const path = canonicalPath(module.filename);
+    if (!path.split(sep).includes("node_modules") && roots.some((root) => isPathWithin(root, path))) {
+      inputs.add(path);
+    }
+    pending.push(...module.children);
+  }
+  for (const cachePath of Object.keys(localRequire.cache)) {
+    const path = canonicalPath(cachePath);
+    if (!path.split(sep).includes("node_modules") && roots.some((root) => isPathWithin(root, path))) {
+      inputs.add(path);
+    }
+  }
+  return [...inputs].sort();
+}
+function clearTileflowLocalModuleCache(configPath, cwd) {
+  const roots = [canonicalPath(cwd), canonicalPath(dirname(resolve(configPath)))];
+  for (const cachePath of Object.keys(localRequire.cache)) {
+    if (cachePath.split(sep).includes("node_modules")) continue;
+    if (roots.some((root) => isPathWithin(root, canonicalPath(cachePath)))) {
+      delete localRequire.cache[cachePath];
+    }
+  }
+}
+function canonicalPath(path) {
+  try {
+    return realpathSync.native(resolve(path));
+  } catch {
+    return resolve(path);
+  }
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+export {
+  defaultTileflowApiUrl,
+  defaultTileflowConfigPath,
+  defaultTileflowManifestPath,
+  TileflowValidationError,
+  loadTileflowConfig,
+  loadTileflowConfigWithInputs,
+  loadValidTileflowConfig,
+  loadValidTileflowConfigWithInputs,
+  assertValidTileflowConfig,
+  getTileflowMapNames,
+  getFirstTileflowMapName
+};