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

package/dist/chunk-7C4F6GAX.js

@@ -0,0 +1,170 @@
+// src/asset-directories.ts
+import { realpath, stat } from "fs/promises";
+import { createRequire } from "module";
+import { dirname, isAbsolute, relative, resolve, sep } from "path";
+import {
+  isTileflowLocalDirectory,
+  tileflowLocalDirectoryMessage
+} from "@tileflow/core";
+var TileflowAssetDirectoryError = class extends Error {
+  code = "ASSET_DIRECTORY_INVALID";
+  issues;
+  phase = "asset-directory-resolution";
+  constructor(kind, issues) {
+    super(
+      [
+        `Invalid Tileflow ${kind} directories`,
+        ...issues.map((issue) => `- ${issue.path}: ${issue.message}`)
+      ].join("\n")
+    );
+    this.name = "TileflowAssetDirectoryError";
+    this.issues = issues;
+  }
+};
+async function resolveTileflowAssetDirectories(directories, options) {
+  const issues = [];
+  let realCwd;
+  let realBaseDirectory;
+  try {
+    realCwd = await realpath(options.cwd);
+    if (!(await stat(realCwd)).isDirectory()) throw new Error("Working tree is not a directory");
+  } catch (error) {
+    throw new TileflowAssetDirectoryError(options.kind, [
+      { message: filesystemMessage(error, "Selected working tree was not found"), path: "cwd" }
+    ]);
+  }
+  try {
+    realBaseDirectory = await realpath(options.baseDirectory ?? options.cwd);
+    if (!(await stat(realBaseDirectory)).isDirectory()) {
+      throw new Error("Config base is not a directory");
+    }
+    if (!isPathInside(realCwd, realBaseDirectory)) {
+      throw new Error("Config base directory escapes the selected working tree");
+    }
+  } catch (error) {
+    throw new TileflowAssetDirectoryError(options.kind, [
+      {
+        message: filesystemMessage(error, "Config base directory was not found"),
+        path: "baseDirectory"
+      }
+    ]);
+  }
+  const result = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const [index, directory] of directories.entries()) {
+    const configPath = `${options.configPath}.${index + (options.ordinalOffset ?? 0)}`;
+    let candidate;
+    let containmentRoot;
+    let packageOwned = false;
+    if (typeof directory === "string") {
+      if (!isTileflowLocalDirectory(directory)) {
+        issues.push({
+          message: tileflowLocalDirectoryMessage,
+          path: configPath
+        });
+        continue;
+      }
+      candidate = resolve(realBaseDirectory, directory);
+      containmentRoot = realCwd;
+    } else if (isPackageDirectory(directory)) {
+      packageOwned = true;
+      let packageRoot;
+      try {
+        validatePackageDirectory(directory);
+        const requireFromProject = createRequire(resolve(realCwd, "__tileflow_config__.cjs"));
+        let packageJson;
+        try {
+          packageJson = requireFromProject.resolve(`${directory.package}/package.json`);
+        } catch {
+          packageJson = createRequire(import.meta.url).resolve(`${directory.package}/package.json`);
+        }
+        packageRoot = dirname(packageJson);
+        containmentRoot = await realpath(packageRoot);
+        candidate = resolve(containmentRoot, ...directory.path.split("/"));
+      } catch (error) {
+        issues.push({
+          message: error instanceof Error ? error.message : "Package directory could not be resolved",
+          path: configPath
+        });
+        continue;
+      }
+    } else {
+      issues.push({
+        message: "Expected a relative directory or imported package-directory descriptor",
+        path: configPath
+      });
+      continue;
+    }
+    try {
+      const realCandidate = await realpath(candidate);
+      if (!(await stat(realCandidate)).isDirectory()) {
+        throw new Error("Asset source must be a directory");
+      }
+      if (!isPathInside(containmentRoot, realCandidate)) {
+        throw new Error(
+          packageOwned ? "Package asset directory escapes its installed package" : "Asset directory escapes the selected working tree"
+        );
+      }
+      if (options.target === "hosted" && !packageOwned && !isPathInside(realCwd, realCandidate)) {
+        throw new Error("Hosted asset directories must remain inside the selected working tree");
+      }
+      const previous = seen.get(realCandidate);
+      if (previous) {
+        issues.push({ message: `Directory duplicates ${previous}`, path: configPath });
+        continue;
+      }
+      seen.set(realCandidate, configPath);
+      result.push({
+        authoring: directory,
+        configPath,
+        containmentRoot,
+        packageOwned,
+        realPath: realCandidate,
+        watch: !packageOwned
+      });
+    } catch (error) {
+      issues.push({
+        message: filesystemMessage(error, "Asset directory was not found"),
+        path: configPath
+      });
+    }
+  }
+  if (issues.length > 0) throw new TileflowAssetDirectoryError(options.kind, issues);
+  return result;
+}
+function isPackageDirectory(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype && value.kind === "package-directory"
+  );
+}
+function validatePackageDirectory(directory) {
+  const keys = Object.keys(directory).sort();
+  if (keys.join(",") !== "kind,package,path") {
+    throw new Error("Package directory accepts exactly kind, package, and path");
+  }
+  if (!/^(?:@[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*|[a-z0-9][a-z0-9._-]*)$/u.test(
+    directory.package
+  )) {
+    throw new Error("Package directory has an invalid npm package name");
+  }
+  if (!directory.path || directory.path.startsWith("/") || directory.path.includes("\\") || directory.path.split("/").some((segment) => !segment || segment === "." || segment === "..")) {
+    throw new Error("Package directory path must be a portable package-relative path");
+  }
+}
+function isPathInside(root, candidate) {
+  const pathFromRoot = relative(root, candidate);
+  return pathFromRoot === "" || !isAbsolute(pathFromRoot) && pathFromRoot !== ".." && !pathFromRoot.startsWith(`..${sep}`);
+}
+function filesystemMessage(error, fallback) {
+  if (error && typeof error === "object" && "code" in error) {
+    const code = String(error.code ?? "");
+    if (code === "ENOENT") return fallback;
+    if (code === "EACCES" || code === "EPERM") return "Asset directory is not readable";
+  }
+  return error instanceof Error && error.message ? error.message : fallback;
+}
+
+export {
+  TileflowAssetDirectoryError,
+  resolveTileflowAssetDirectories
+};

package/dist/chunk-AQUGMUZW.js

@@ -0,0 +1,324 @@
+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,
+  tileflowCaptureShotNameSchema,
+  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}".`
+      });
+    }
+  }
+  for (const [shotId, shot] of Object.entries(project.shots ?? {})) {
+    if (!Object.hasOwn(project.maps, shot.map)) {
+      messages.push({
+        level: "error",
+        path: `shots.${shotId}.map`,
+        message: `Unknown Tileflow map "${shot.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),
+        normalizeSingularMapShots(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);
+      }
+    }
+    const shots2 = /* @__PURE__ */ new Map();
+    for (const [mapId, , , , mapShots] of entries) {
+      for (const [shotId, shot] of Object.entries(mapShots ?? {})) {
+        if (shots2.has(shotId)) {
+          throw tileflowConfigValidationError(
+            `maps.${mapId}.shots.${shotId}`,
+            new Error(`Tileflow workspace shot "${shotId}" is already defined by another map.`)
+          );
+        }
+        shots2.set(shotId, shot);
+      }
+    }
+    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) } : {},
+      ...shots2.size > 0 ? { shots: Object.fromEntries(shots2) } : {}
+    };
+  }
+  const map = input;
+  const resolved = parseTileflowCatalogMap(map, "");
+  let scenes;
+  try {
+    scenes = normalizeSingularMapScenes(map, resolved.id);
+  } catch (error) {
+    throw tileflowConfigValidationError("scenes", error);
+  }
+  let shots;
+  try {
+    shots = normalizeSingularMapShots(map, resolved.id);
+  } catch (error) {
+    throw tileflowConfigValidationError("shots", error);
+  }
+  return {
+    mapMetadata: {
+      [resolved.id]: {
+        id: resolved.id,
+        lineage: collectTileflowMapBuildLineage(map),
+        version: resolved.version
+      }
+    },
+    maps: { [resolved.id]: resolved },
+    ...scenes ? { scenes } : {},
+    ...shots ? { shots } : {}
+  };
+}
+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 normalizeSingularMapShots(map, mapId) {
+  if (!map.shots) return void 0;
+  return Object.fromEntries(
+    Object.entries(map.shots).map(([shotId, shot]) => {
+      const normalizedShotId = tileflowCaptureShotNameSchema.parse(shotId);
+      return [normalizedShotId, { ...shot, 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
+};

package/dist/chunk-D4OE4ITL.js

@@ -0,0 +1,13 @@
+// src/path-safety.ts
+import path from "path";
+function isPathWithin(root, candidate) {
+  return isPathWithinWith(path, root, candidate);
+}
+function isPathWithinWith(pathApi, root, candidate) {
+  const relativePath = pathApi.relative(pathApi.resolve(root), pathApi.resolve(candidate));
+  return relativePath === "" || !pathApi.isAbsolute(relativePath) && relativePath !== ".." && !relativePath.startsWith(`..${pathApi.sep}`);
+}
+
+export {
+  isPathWithin
+};