@tileflow/dev 0.1.0-alpha.3 → 0.1.0-alpha.30

package/dist/artifacts.d.ts

@@ -0,0 +1,265 @@
+import { MapLibreStyle, TileflowViewConfig, TileflowStyleOptions } from '@tileflow/core';
+import { TileflowBuildCatalog, TileflowBuildStyles, TileflowMapBuildManifestV1, TileflowRendererDeploymentArtifact, TileflowStyleInspection, TileflowMapBuildProvenanceV1, TileflowPreparedMapAssets } from '@tileflow/core/build';
+import { TileflowRuntimeManifest } from '@tileflow/core/manifest';
+import { TileflowRenderer, TileflowNativeBuildRecord } from '@tileflow/core/native-profile';
+import { TileflowBuildAsset, TileflowIconResolutionOptions, PreparedTileflowBuildCatalog, TileflowSourceCatalog, PreparedTileflowCatalog } from './icons.js';
+export { defaultTileflowConfigPath } from './config.js';
+
+/**
+ * Local glyph serving for line-fitted text backgrounds.
+ *
+ * A style whose text uses a derived `<stack> lines-v1-…` font stack needs a glyph provider that
+ * derives those ranges. Local previews and captures route such a map's glyph URL through
+ * `__glyphs/<map>/…`: ordinary stacks pass through from the map's declared provider unchanged, and
+ * derived stacks are computed from their source stack's range. Production output keeps the
+ * declared provider, which must serve derived stacks itself.
+ */
+declare const tileflowLineBackgroundGlyphRoute = "__glyphs";
+/** Map name to the upstream glyph URL template its styles declared. Local only; never serialized. */
+type TileflowLineBackgroundGlyphProviders = Readonly<Record<string, string>>;
+type TileflowLineBackgroundGlyphResponderOptions = {
+    /** Project root; ranges are cached under `.tileflow/cache/glyphs/v1`. */
+    cwd: string;
+    fetch?: typeof globalThis.fetch;
+};
+type TileflowLineBackgroundGlyphResponder = (upstream: string, fontStack: string, range: string) => Promise<Response>;
+/** Whether a compiled style draws text with a derived line-background stack. */
+declare function usesTileflowLineBackgroundGlyphs(style: MapLibreStyle): boolean;
+/** Parses `/__glyphs/<map>/<fontstack>/<range>.pbf` from a decoded route path. */
+declare function parseTileflowLineBackgroundGlyphPath(path: string): {
+    fontStack: string;
+    mapName: string;
+    range: string;
+} | undefined;
+/**
+ * Serves one glyph range for a declared upstream template. Upstream ranges are cached on disk;
+ * derived ranges are recomputed from them and kept in a bounded in-memory cache.
+ */
+declare function createTileflowLineBackgroundGlyphResponder(options: TileflowLineBackgroundGlyphResponderOptions): TileflowLineBackgroundGlyphResponder;
+
+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;
+    renderer?: 'native';
+    profile?: 'native-v1';
+    severity?: 'error';
+    suggestion?: 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[];
+
+type Input = Readonly<{
+    mapId: string;
+    buildManifest: TileflowMapBuildManifestV1;
+    styles: Readonly<Record<string, MapLibreStyle>>;
+    teamSources: Readonly<Record<string, Readonly<{
+        tileset: string;
+        type: 'raster' | 'vector';
+    }>>>;
+    assets: readonly TileflowBuildAsset[];
+    view?: TileflowViewConfig;
+}>;
+/**
+ * Prepare both representations from the same already compiled, asset-bound web family.
+ * This has no network or publication port. Call it before any authenticated remote operation.
+ * Logical Hosted placeholders are validated syntactically without granting delivery authority.
+ */
+declare function prepareTileflowHostedNativeDeployment(input: Input): Promise<TileflowRendererDeploymentArtifact>;
+
+/** 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;
+    /**
+     * Native local preview only: the exact HTTP origin serving these artifacts, such as
+     * `http://127.0.0.1:3333`. Native checks accept HTTP resources at this origin only; every other
+     * origin still requires HTTPS. It is never inferred, and web or production output rejects it.
+     */
+    developmentOrigin?: string;
+    /**
+     * Explicit shared Icon Set resolution settings for this build.
+     *
+     * Builds never resolve a catalog head. These options only choose the verified cache root,
+     * offline behavior, trusted delivery origins and the transport used to hydrate exact pins.
+     */
+    icons?: TileflowIconResolutionOptions;
+    /** Artifact renderer. Omission is identical to web; native uses a separate output directory. */
+    renderer?: TileflowRenderer;
+    /** 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;
+    /** Present only for native artifact preparation; never part of the runtime manifest. */
+    nativeBuild?: TileflowNativeBuildRecord;
+    /** 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[];
+    /** Local-only upstream glyph templates for maps whose text uses line-fitted backgrounds. */
+    lineBackgroundGlyphs?: TileflowLineBackgroundGlyphProviders;
+    /** 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' | 'developmentOrigin' | 'inspection' | 'renderer' | '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, TileflowIconResolutionOptions, type TileflowLineBackgroundGlyphProviders, type TileflowLineBackgroundGlyphResponder, type TileflowLocalTilesetFile, TileflowLocalTilesetProductionError, type TileflowManifestOptions, TileflowSourceCatalog, type WriteTileflowArtifactPlanOptions, type WriteTileflowBuildArtifactsOptions, assertNoLocalTilesetsForProduction, assertTileflowSelfHostedManifestTarget, createTileflowArtifactDiagnostics, createTileflowArtifactPlan, createTileflowArtifactSession, createTileflowBuildArtifacts, createTileflowBuildProvenance, createTileflowLineBackgroundGlyphResponder, createTileflowManifest, createTileflowStyle, createTileflowStyles, disposeTileflowBuildArtifacts, getTileflowArtifactFiles, getTileflowAssetBasePath, getTileflowAssetFileName, getTileflowWatchPaths, isTileflowArtifactInputPath, joinTileflowPublicUrl, normalizeTileflowBasePath, parseTileflowLineBackgroundGlyphPath, prepareTileflowHostedNativeDeployment, prepareTileflowLocalTilesets, refreshTileflowArtifactSession, resolveTileflowArtifactPublicUrls, tileflowArtifactInventoryFileName, tileflowArtifactPlanSchemaVersion, tileflowArtifactSessionSchemaVersion, tileflowLineBackgroundGlyphRoute, usesTileflowLineBackgroundGlyphs, writeTileflowArtifactPlan, writeTileflowBuildArtifacts };

package/dist/artifacts.js

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