@malloy-publisher/server 0.0.235 → 0.0.236

package/src/controller/watch-mode.controller.ts

@@ -1,243 +0,0 @@
-import chokidar, { FSWatcher } from "chokidar";
-import { EventEmitter } from "events";
-import { RequestHandler } from "express";
-import path from "path";
-import { components } from "../api";
-import { internalErrorToHttpError } from "../errors";
-import { logger } from "../logger";
-import { assertSafePackageName } from "../path_safety";
-import { EnvironmentStore } from "../service/environment_store";
-
-type StartWatchReq = components["schemas"]["StartWatchRequest"];
-type WatchStatusRes = components["schemas"]["WatchStatus"];
-type Handler<Req = object, Res = void> = RequestHandler<object, Res, Req>;
-
-// File extensions that should trigger a live-reload event but NOT a Malloy
-// environment reload (these are package assets, not semantic-model sources).
-const ASSET_EXTS = new Set([
-   ".html",
-   ".htm",
-   ".css",
-   ".js",
-   ".mjs",
-   ".json",
-   ".png",
-   ".jpg",
-   ".jpeg",
-   ".gif",
-   ".svg",
-   ".webp",
-   ".ico",
-   ".woff",
-   ".woff2",
-]);
-const MODEL_EXTS = new Set([".malloy", ".malloynb", ".md"]);
-
-export class WatchModeController {
-   watchingPath: string | null;
-   watchingEnvironmentName: string | null;
-   watcher: FSWatcher | null = null;
-   // Serializes ensureWatching so concurrent callers can't both close and
-   // recreate the watcher and orphan one (each chokidar watcher holds OS
-   // handles). See ensureWatching.
-   private setupChain: Promise<void> | null = null;
-   /**
-    * Per-package change bus. Event name is `<environmentName>/<packageName>`.
-    * Used by the SSE live-reload endpoint to push refreshes to embedded HTML
-    * dashboards. Each emit carries `{ path, kind }` for diagnostics; the SSE
-    * handler currently ignores the payload and just sends "changed".
-    */
-   public events = new EventEmitter();
-
-   constructor(private environmentStore: EnvironmentStore) {
-      this.watchingPath = null;
-      this.watchingEnvironmentName = null;
-      // Live-reload subscribers can be many (one per open browser tab);
-      // bump the default cap so Node doesn't warn under normal use.
-      this.events.setMaxListeners(100);
-   }
-
-   /**
-    * Idempotent: starts watching `environmentName` if not already.
-    *
-    * Throws if the environment can't be resolved — never falls back to a
-    * `<serverRoot>/<envName>` path that an attacker could control via
-    * URL-encoded path traversal. Callers (the SSE handler in particular)
-    * must validate the env name before calling this.
-    */
-   public async ensureWatching(environmentName: string): Promise<void> {
-      if (this.watchingEnvironmentName === environmentName && this.watcher) {
-         return;
-      }
-      // Serialize setup behind any in-flight one, then re-check the guard, so
-      // concurrent callers don't both close + recreate the watcher (which would
-      // orphan a chokidar instance and leak its OS file handles).
-      const run = (this.setupChain ?? Promise.resolve())
-         .catch(() => {})
-         .then(async () => {
-            if (
-               this.watchingEnvironmentName === environmentName &&
-               this.watcher
-            ) {
-               return;
-            }
-            const env = await this.environmentStore.getEnvironment(
-               environmentName,
-               false,
-            );
-            const watchPath = env.getEnvironmentPath();
-            if (this.watcher) {
-               await this.watcher.close();
-               this.watcher = null;
-            }
-            this.startWatcher(environmentName, watchPath);
-         });
-      this.setupChain = run;
-      await run;
-   }
-
-   /** Whether watch mode is currently running for the given env. */
-   public isWatching(environmentName: string): boolean {
-      return !!this.watcher && this.watchingEnvironmentName === environmentName;
-   }
-
-   private startWatcher(watchName: string, watchPath: string) {
-      this.watchingEnvironmentName = watchName;
-      this.watchingPath = watchPath;
-      this.watcher = chokidar.watch(this.watchingPath, {
-         ignored: (filePath, stats) => {
-            if (!stats?.isFile()) return false;
-            const ext = path.extname(filePath).toLowerCase();
-            return !MODEL_EXTS.has(ext) && !ASSET_EXTS.has(ext);
-         },
-         ignoreInitial: true,
-      });
-      // Reload just the package a changed file belongs to: this recompiles
-      // that package's models from disk (Package.create) and replaces the
-      // cached entry, so the next query sees the edit. Scoped to watch mode by
-      // construction — it only runs from this watcher, which is started only
-      // when watch mode is active.
-      //
-      // The previous env-level reload (getEnvironment(reload) + addEnvironment)
-      // was a no-op for compilation: addEnvironment on an existing env calls
-      // Environment.update(), which refreshes metadata/connections only and
-      // never touches this.packages, so edits never took effect.
-      // Returns true if the package recompiled cleanly. A transient compile
-      // error (e.g. a half-typed model saved mid-edit) returns false so we can
-      // avoid bouncing open browser tabs into a compile-error/404 — see onEvent.
-      const reloadPackage = async (pkgName: string): Promise<boolean> => {
-         try {
-            const environment = await this.environmentStore.getEnvironment(
-               watchName,
-               false,
-            );
-            await environment.getPackage(pkgName, true);
-            logger.info(
-               `Watch: recompiled package "${pkgName}" in environment "${watchName}"`,
-            );
-            return true;
-         } catch (error) {
-            logger.error(
-               `Watch: failed to recompile package "${pkgName}" in environment "${watchName}"`,
-               { error },
-            );
-            return false;
-         }
-      };
-      const onEvent =
-         (kind: "add" | "change" | "unlink") => async (filePath: string) => {
-            logger.info(`Watch ${kind}: ${filePath}; environment=${watchName}`);
-            // Resolve which package the file belongs to. Packages are
-            // subdirectories of the environment (env/<pkg>/...), so a file must
-            // be nested at least one level to belong to a package; files at the
-            // environment root belong to no package and are ignored.
-            const rel = path.relative(this.watchingPath ?? "", filePath);
-            const segments = rel.split(path.sep);
-            const pkgName =
-               segments.length > 1 &&
-               segments[0] &&
-               !segments[0].startsWith("..")
-                  ? segments[0]
-                  : null;
-            if (!pkgName) return;
-
-            // Recompile Malloy state only for model files. Asset edits
-            // (HTML/CSS/JS) skip recompile — they just need the live-reload
-            // fanout below. For model edits, only signal a reload once the
-            // recompile succeeds: a transient syntax error shouldn't bounce
-            // open pages into a compile error or 404.
-            const ext = path.extname(filePath).toLowerCase();
-            if (MODEL_EXTS.has(ext)) {
-               const recompiled = await reloadPackage(pkgName);
-               if (!recompiled) return;
-            }
-            // Fan out to SSE clients embedded in the affected package.
-            this.events.emit(`${watchName}/${pkgName}`, {
-               path: filePath,
-               kind,
-            });
-         };
-      this.watcher.on("add", onEvent("add"));
-      this.watcher.on("change", onEvent("change"));
-      this.watcher.on("unlink", onEvent("unlink"));
-   }
-
-   public getWatchStatus: Handler<void, WatchStatusRes> = async (_req, res) => {
-      return res.json({
-         enabled: !!this.watchingPath,
-         watchingPath: this.watchingPath ?? "",
-         environmentName: this.watchingEnvironmentName ?? "",
-      });
-   };
-
-   public startWatching: Handler<StartWatchReq, { error: string }> = async (
-      req,
-      res,
-   ) => {
-      const watchName = req.body.environmentName ?? "";
-      try {
-         assertSafePackageName(watchName);
-      } catch (error) {
-         logger.error(error);
-         const { status } = internalErrorToHttpError(error as Error);
-         res.status(status).json({ error: (error as Error).message });
-         return;
-      }
-      const environmentManifest =
-         await EnvironmentStore.reloadEnvironmentManifest(
-            this.environmentStore.serverRootPath,
-         );
-      const environment = environmentManifest.environments.find(
-         (e) => e.name === watchName,
-      );
-      if (
-         !environment ||
-         !environment.packages ||
-         environment.packages.length === 0
-      ) {
-         res.status(404).json({
-            error: `Environment ${watchName} not found or has no packages`,
-         });
-         return;
-      }
-      try {
-         await this.ensureWatching(watchName);
-      } catch (error) {
-         logger.error(error);
-         const { status } = internalErrorToHttpError(error as Error);
-         res.status(status).json({ error: (error as Error).message });
-         return;
-      }
-      res.json();
-   };
-
-   public stopWatchMode: Handler = async (_req, res) => {
-      if (this.watcher) {
-         await this.watcher.close();
-         this.watcher = null;
-      }
-      this.watchingPath = null;
-      this.watchingEnvironmentName = null;
-      res.json();
-   };
-}

package/src/data_styles.ts

@@ -1,71 +0,0 @@
-import { URLReader } from "@malloydata/malloy";
-import { DataStyles } from "@malloydata/render";
-import { logger } from "./logger";
-
-export function compileDataStyles(styles: string): DataStyles {
-   try {
-      return JSON.parse(styles) as DataStyles;
-   } catch (error) {
-      throw new Error(`Error compiling data styles: ${error}`);
-   }
-}
-
-// TODO replace this with actual JSON metadata import functionality, when it exists
-export async function dataStylesForFile(
-   url: string,
-   text: string,
-   urlReader: URLReader,
-): Promise<DataStyles> {
-   const PREFIX = "--! styles ";
-   let styles: DataStyles = {};
-   for (const line of text.split("\n")) {
-      if (line.startsWith(PREFIX)) {
-         const fileName = line.trimEnd().substring(PREFIX.length);
-         // TODO instead of failing silently when the file does not exist, perform this after the WebView has been
-         //      created, so that the error can be shown there.
-         let stylesText;
-         try {
-            stylesText = (await urlReader.readURL(
-               new URL(fileName, url),
-            )) as string;
-         } catch (error) {
-            logger.error(`Error loading data style '${fileName}': ${error}`);
-            stylesText = "{}";
-         }
-         styles = { ...styles, ...compileDataStyles(stylesText) };
-      }
-   }
-
-   return styles;
-}
-
-// TODO Come up with a better way to handle data styles. Perhaps this is
-//      an in-language understanding of model "metadata". For now,
-//      we abuse the `URLReader` API to keep track of requested URLs
-//      and accumulate data styles for those files.
-export class HackyDataStylesAccumulator implements URLReader {
-   private urlReader: URLReader;
-   private dataStyles: DataStyles = {};
-
-   constructor(urlReader: URLReader) {
-      this.urlReader = urlReader;
-   }
-
-   async readURL(url: URL): Promise<string> {
-      const contents = await this.urlReader.readURL(url);
-      this.dataStyles = {
-         ...this.dataStyles,
-         ...(await dataStylesForFile(
-            url.toString(),
-            contents as string,
-            this.urlReader,
-         )),
-      };
-
-      return contents as string;
-   }
-
-   getHackyAccumulatedDataStyles(): DataStyles {
-      return this.dataStyles;
-   }
-}

package/src/default-publisher.config.json

@@ -1,23 +0,0 @@
-{
-  "frozenConfig": false,
-  "environments": [
-    {
-      "name": "examples",
-      "packages": [
-        {
-          "name": "storefront",
-          "location": "https://github.com/malloydata/publisher/tree/main/examples/storefront"
-        },
-        {
-          "name": "governed-analytics",
-          "location": "https://github.com/malloydata/publisher/tree/main/examples/governed-analytics"
-        },
-        {
-          "name": "html-data-app",
-          "location": "https://github.com/malloydata/publisher/tree/main/examples/html-data-app"
-        }
-      ],
-      "connections": []
-    }
-  ]
-}

package/src/ducklake_version.spec.ts

@@ -1,163 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
-import {
-   catalogFormatRangeForEngine,
-   compareCatalogFormat,
-   ENGINE_MAX_FORMAT,
-   isCatalogFormatInRange,
-   isCatalogFormatSupportedByEngine,
-   MIN_CATALOG_FORMAT,
-   parseCatalogFormat,
-   parseEngineMajorMinor,
-} from "./ducklake_version";
-
-/**
- * Resolve the pinned `@duckdb/node-api` engine version from bun.lock, the same
- * source `scripts/duckdb-version.js` reads (mirrored here rather than imported
- * because the server tsconfig has `allowJs: false`). Prefers the version nested
- * under `@malloydata/db-duckdb` — the engine Malloy actually runs on — and
- * falls back to the deduped top-level entry.
- */
-function resolvePinnedDuckDBVersion(): string {
-   const lock = readFileSync(
-      fileURLToPath(new URL("../../../bun.lock", import.meta.url)),
-      "utf8",
-   );
-   const nested = lock.match(
-      /"@malloydata\/db-duckdb\/@duckdb\/node-api":\s*\["@duckdb\/node-api@(\d+\.\d+\.\d+[^"]*)"/,
-   );
-   const plain = lock.match(
-      /"@duckdb\/node-api":\s*\["@duckdb\/node-api@(\d+\.\d+\.\d+[^"]*)"/,
-   );
-   const match = nested ?? plain;
-   if (!match) throw new Error("@duckdb/node-api not found in bun.lock");
-   return match[1];
-}
-
-describe("ducklake_version", () => {
-   describe("parseCatalogFormat", () => {
-      it("parses two-part and pre-release formats", () => {
-         expect(parseCatalogFormat("1.0")).toEqual({ major: 1, minor: 0 });
-         expect(parseCatalogFormat("0.3-dev1")).toEqual({
-            major: 0,
-            minor: 3,
-            prerelease: "dev1",
-         });
-      });
-
-      it("rejects malformed input without throwing", () => {
-         // Three-part strings are malformed for a catalog format, not a newer
-         // version -- they must not parse as a bigger number.
-         expect(parseCatalogFormat("1.0.0")).toBeNull();
-         expect(parseCatalogFormat("1.1.0")).toBeNull();
-         expect(parseCatalogFormat("")).toBeNull();
-         expect(parseCatalogFormat("not a version")).toBeNull();
-         expect(parseCatalogFormat("0.3 ")).toBeNull();
-      });
-   });
-
-   describe("compareCatalogFormat", () => {
-      const p = (s: string) => parseCatalogFormat(s)!;
-      it("orders by major, then minor", () => {
-         expect(compareCatalogFormat(p("0.3"), p("1.0"))).toBe(-1);
-         expect(compareCatalogFormat(p("1.1"), p("1.0"))).toBe(1);
-         expect(compareCatalogFormat(p("1.0"), p("1.0"))).toBe(0);
-      });
-      it("sorts a release above its own pre-releases", () => {
-         expect(compareCatalogFormat(p("1.0"), p("1.0-dev1"))).toBe(1);
-         expect(compareCatalogFormat(p("0.3-dev1"), p("0.3"))).toBe(-1);
-      });
-   });
-
-   describe("parseEngineMajorMinor", () => {
-      it("extracts the minor line from assorted engine spec forms", () => {
-         expect(parseEngineMajorMinor("1.5.3")).toEqual({ major: 1, minor: 5 });
-         expect(parseEngineMajorMinor("1.5.3-r.2")).toEqual({
-            major: 1,
-            minor: 5,
-         });
-         expect(parseEngineMajorMinor("v1.5.3")).toEqual({
-            major: 1,
-            minor: 5,
-         });
-      });
-      it("returns null when no version is present", () => {
-         expect(parseEngineMajorMinor("nope")).toBeNull();
-      });
-   });
-
-   describe("catalogFormatRangeForEngine", () => {
-      it("derives [1.0, maxFormat] for a covered engine (all patch levels)", () => {
-         expect(catalogFormatRangeForEngine("1.5.3")).toEqual({
-            min: "1.0",
-            max: "1.0",
-            engineVersion: "1.5",
-         });
-         // Any patch of a known minor line resolves to the same range.
-         expect(catalogFormatRangeForEngine("1.5.9")).toEqual({
-            min: "1.0",
-            max: "1.0",
-            engineVersion: "1.5",
-         });
-      });
-      it("returns null (drift signal) for an engine with no matrix row", () => {
-         expect(catalogFormatRangeForEngine("1.6.0")).toBeNull();
-         expect(catalogFormatRangeForEngine("2.0.0")).toBeNull();
-         expect(catalogFormatRangeForEngine("garbage")).toBeNull();
-      });
-   });
-
-   // These reproduce the accept/reject set the prior enumerated-list work
-   // asserted, now expressed as a RANGE derived from the 1.5.x engine.
-   describe("isCatalogFormatSupportedByEngine (engine 1.5.x)", () => {
-      const engine = "1.5.3";
-      it("accepts the 1.0 catalog format produced by the 1.5.x engine", () => {
-         expect(isCatalogFormatSupportedByEngine("1.0", engine)).toBe(true);
-      });
-      it("rejects the 0.3-line formats (attach only via migration)", () => {
-         for (const v of ["0.1", "0.2", "0.3-dev1", "0.3"]) {
-            expect(isCatalogFormatSupportedByEngine(v, engine)).toBe(false);
-         }
-      });
-      it("rejects formats newer than the supported max", () => {
-         for (const v of ["1.1", "2.0", "0.4", "0.3-dev2"]) {
-            expect(isCatalogFormatSupportedByEngine(v, engine)).toBe(false);
-         }
-      });
-      it("rejects malformed / three-part input without throwing", () => {
-         for (const v of ["1.0.0", "1.1.0", "", "not a version", "0.3 "]) {
-            expect(isCatalogFormatSupportedByEngine(v, engine)).toBe(false);
-         }
-      });
-      it("rejects everything when the engine is unknown (no matrix row)", () => {
-         expect(isCatalogFormatSupportedByEngine("1.0", "1.6.0")).toBe(false);
-      });
-   });
-
-   describe("isCatalogFormatInRange", () => {
-      const range = catalogFormatRangeForEngine("1.5.3")!;
-      it("is inclusive at both ends", () => {
-         expect(isCatalogFormatInRange("1.0", range)).toBe(true);
-      });
-      it("rejects below min and above max", () => {
-         expect(isCatalogFormatInRange("0.9", range)).toBe(false);
-         expect(isCatalogFormatInRange("1.1", range)).toBe(false);
-      });
-   });
-
-   // The version-contract: the ENGINE_MAX_FORMAT matrix MUST cover the DuckDB
-   // engine this repo is pinned to. This is the same drift guard the CI script
-   // enforces (scripts/validate-ducklake-catalog-range.ts); asserting it here
-   // fails `bun test` the moment a Malloy bump moves the engine past the matrix.
-   describe("pinned-engine drift contract", () => {
-      it("has a matrix row covering the pinned @duckdb/node-api engine", () => {
-         const engineVersion = resolvePinnedDuckDBVersion();
-         const range = catalogFormatRangeForEngine(engineVersion);
-         expect(range).not.toBeNull();
-         expect(range!.min).toBe(MIN_CATALOG_FORMAT);
-         // The matrix must not be empty and its rows must be well-formed.
-         expect(ENGINE_MAX_FORMAT.length).toBeGreaterThan(0);
-      });
-   });
-});

package/src/ducklake_version.ts

@@ -1,153 +0,0 @@
-// DuckLake catalog-format version contract.
-//
-// A DuckLake catalog records the on-disk format version it was written at. The
-// DuckLake extension bundled with a given DuckDB engine attaches only a bounded
-// RANGE of catalog formats without migration; a catalog outside that range
-// fails deep inside DuckDB with an opaque error. This module derives the
-// supported range purely from the pinned DuckDB engine version, so it never has
-// to enumerate an allow-list of "known good" catalog versions (which drifts
-// silently on an engine bump and is easy to forget to update). Both the runtime
-// attach preflight (`service/connection.ts`) and the CI version-contract check
-// (`scripts/validate-ducklake-catalog-range.ts`) consume this one source.
-//
-// Lower bound: fixed at "1.0". The 1.x DuckLake line does not attach the older
-// 0.x formats without AUTOMATIC_MIGRATION, and the Publisher attach paths never
-// pass that flag, so 1.0 is the floor. Upper bound: the maximum format the
-// engine's bundled extension writes/attaches, looked up in the migration matrix
-// below and keyed by engine (major, minor).
-
-/** A parsed DuckLake catalog format version, e.g. `1.0` or `0.3-dev1`. */
-export interface CatalogFormat {
-   major: number;
-   minor: number;
-   /** e.g. `dev1` in `0.3-dev1`; a pre-release sorts BELOW the same release. */
-   prerelease?: string;
-}
-
-/** The inclusive `[min, max]` catalog-format range for a given engine. */
-export interface CatalogFormatRange {
-   min: string;
-   max: string;
-   /** The engine minor line the range was derived from (for error messages). */
-   engineVersion: string;
-}
-
-/** Fixed lower bound of the supported range (see file header). */
-export const MIN_CATALOG_FORMAT = "1.0";
-
-/**
- * Migration matrix: DuckDB engine minor line -> the maximum DuckLake catalog
- * format its bundled DuckLake extension attaches WITHOUT migration. This is NOT
- * an allow-list of catalog versions -- it is the single fact, per engine minor
- * line, from which the `[MIN_CATALOG_FORMAT, maxFormat]` range is derived.
- *
- * Verified against the baked extension: DuckDB 1.5.x's DuckLake extension writes
- * and attaches the "1.0" catalog format (the older 0.x formats require
- * AUTOMATIC_MIGRATION, which Publisher never passes). When a Malloy bump moves
- * `@duckdb/node-api` to a new minor line, add its row here after verifying the
- * extension's max attach-without-migration format -- the CI version-contract
- * check FAILS THE BUILD until a row covers the pinned engine, so this never
- * drifts silently.
- */
-export const ENGINE_MAX_FORMAT: ReadonlyArray<{
-   engine: { major: number; minor: number };
-   maxFormat: string;
-}> = [{ engine: { major: 1, minor: 5 }, maxFormat: "1.0" }];
-
-const CATALOG_FORMAT_RE = /^(\d+)\.(\d+)(?:-([0-9A-Za-z.]+))?$/;
-
-/**
- * Parse a catalog format string into its components, or `null` if it is not a
- * valid `<major>.<minor>[-<prerelease>]` format. A three-part version like
- * `1.0.0` is intentionally rejected: catalog formats are two-part, and a
- * three-part string is a malformed input, not a newer format.
- */
-export function parseCatalogFormat(raw: string): CatalogFormat | null {
-   if (typeof raw !== "string") return null;
-   const m = CATALOG_FORMAT_RE.exec(raw);
-   if (!m) return null;
-   const format: CatalogFormat = { major: Number(m[1]), minor: Number(m[2]) };
-   if (m[3] !== undefined) format.prerelease = m[3];
-   return format;
-}
-
-/**
- * Compare two parsed catalog formats: -1 if `a < b`, 0 if equal, 1 if `a > b`.
- * A release sorts ABOVE its own pre-releases (`1.0` > `1.0-dev1`), matching
- * semver ordering.
- */
-export function compareCatalogFormat(
-   a: CatalogFormat,
-   b: CatalogFormat,
-): number {
-   if (a.major !== b.major) return a.major < b.major ? -1 : 1;
-   if (a.minor !== b.minor) return a.minor < b.minor ? -1 : 1;
-   if (a.prerelease === b.prerelease) return 0;
-   if (a.prerelease === undefined) return 1; // release > pre-release
-   if (b.prerelease === undefined) return -1;
-   return a.prerelease < b.prerelease ? -1 : 1;
-}
-
-/**
- * Extract the `{ major, minor }` line from a DuckDB engine version string
- * (`1.5.3`, `1.5.3-r.2`, `v1.5.3` all parse to `{1, 5}`), or `null` if none is
- * present.
- */
-export function parseEngineMajorMinor(
-   raw: string,
-): { major: number; minor: number } | null {
-   const m = /(\d+)\.(\d+)\.(\d+)/.exec(String(raw));
-   if (!m) return null;
-   return { major: Number(m[1]), minor: Number(m[2]) };
-}
-
-/**
- * The supported catalog-format range for a DuckDB engine version, or `null`
- * when the engine's minor line has no row in {@link ENGINE_MAX_FORMAT}. A
- * `null` return is the DRIFT signal: the CI version-contract check fails the
- * build on it, and the runtime preflight treats it as "unknown, skip" (the
- * preflight is non-load-bearing). The match is by `(major, minor)` so any patch
- * release of a known minor line resolves.
- */
-export function catalogFormatRangeForEngine(
-   engineVersion: string,
-): CatalogFormatRange | null {
-   const e = parseEngineMajorMinor(engineVersion);
-   if (!e) return null;
-   const entry = ENGINE_MAX_FORMAT.find(
-      (r) => r.engine.major === e.major && r.engine.minor === e.minor,
-   );
-   if (!entry) return null;
-   return {
-      min: MIN_CATALOG_FORMAT,
-      max: entry.maxFormat,
-      engineVersion: `${e.major}.${e.minor}`,
-   };
-}
-
-/** Whether `format` falls within the inclusive range (invalid input -> false). */
-export function isCatalogFormatInRange(
-   format: string,
-   range: CatalogFormatRange,
-): boolean {
-   const f = parseCatalogFormat(format);
-   const min = parseCatalogFormat(range.min);
-   const max = parseCatalogFormat(range.max);
-   if (!f || !min || !max) return false;
-   return (
-      compareCatalogFormat(f, min) >= 0 && compareCatalogFormat(f, max) <= 0
-   );
-}
-
-/**
- * Whether a catalog `format` is supported by the DuckLake extension bundled
- * with `engineVersion`. Returns `false` for an unknown engine (no matrix row)
- * or a malformed format.
- */
-export function isCatalogFormatSupportedByEngine(
-   format: string,
-   engineVersion: string,
-): boolean {
-   const range = catalogFormatRangeForEngine(engineVersion);
-   return range ? isCatalogFormatInRange(format, range) : false;
-}