@malloy-publisher/server 0.0.198-dev2 → 0.0.198-dev4

package/dist/server.mjs

@@ -44,6 +44,7 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js
@@ -115087,6 +115088,91 @@ var require_winston = __commonJS((exports) => {
   warn.forProperties(exports, "deprecated", ["emitErrs", "levelLength"]);
 });
 
+// src/logger.ts
+function extractTraceIdFromTraceparent(traceparent) {
+  if (!traceparent) {
+    return;
+  }
+  const parts = traceparent.split("-");
+  const traceId = parts.length >= 2 ? parts[1] : parts.length == 1 ? parts[0] : undefined;
+  if (traceId && traceId.length === 32 && /^[0-9a-fA-F]{32}$/.test(traceId)) {
+    return traceId;
+  }
+  return;
+}
+function formatDuration(durationMs) {
+  if (durationMs >= 1000) {
+    const seconds = durationMs / 1000;
+    return `${seconds.toFixed(2)}s`;
+  }
+  return `${durationMs.toFixed(2)}ms`;
+}
+var import_winston, isTelemetryEnabled, VALID_LOG_LEVELS, getLogLevel = () => {
+  if (process.env.LOG_LEVEL) {
+    const logLevel = process.env.LOG_LEVEL.toLowerCase();
+    if (VALID_LOG_LEVELS.includes(logLevel)) {
+      return logLevel;
+    } else {
+      console.error(`Invalid log level: ${process.env.LOG_LEVEL}. Valid log levels are: ${VALID_LOG_LEVELS.join(", ")}. Defaulting to "debug".`);
+    }
+  }
+  return "debug";
+}, logger, DISABLE_RESPONSE_LOGGING, loggerMiddleware = (req, res, next) => {
+  const startTime = performance.now();
+  const resJson = res.json;
+  res.json = (body) => {
+    res.locals.body = body;
+    return resJson.call(res, body);
+  };
+  res.on("finish", () => {
+    const endTime = performance.now();
+    const durationMs = endTime - startTime;
+    const traceparent = req.headers["traceparent"];
+    const traceId = extractTraceIdFromTraceparent(traceparent);
+    const logMetadata = {
+      statusCode: res.statusCode,
+      duration: formatDuration(durationMs),
+      payload: req.body,
+      params: req.params,
+      query: req.query
+    };
+    if (!DISABLE_RESPONSE_LOGGING) {
+      logMetadata.response = res.locals.body;
+    }
+    if (traceId) {
+      logMetadata.traceId = traceId;
+    }
+    if (req.url !== "/metrics" && req.url !== "/health" && req.url !== "/health/liveness" && req.url !== "/health/readiness") {
+      logger.info(`${req.method} ${req.url}`, logMetadata);
+    }
+  });
+  next();
+}, logAxiosError = (error) => {
+  if (error.response) {
+    logger.error("Axios server-side error", {
+      url: error.response.config.url,
+      status: error.response.status,
+      headers: error.response.headers,
+      data: error.response.data
+    });
+  } else if (error.request) {
+    logger.error("Axios client-side error", { error: error.request });
+  } else {
+    logger.error("Axios unknown error", { error });
+  }
+};
+var init_logger = __esm(() => {
+  import_winston = __toESM(require_winston(), 1);
+  isTelemetryEnabled = Boolean(process.env.OTEL_EXPORTER_OTLP_ENDPOINT);
+  VALID_LOG_LEVELS = ["error", "warn", "info", "verbose", "debug", "silly"];
+  logger = import_winston.default.createLogger({
+    level: getLogLevel(),
+    format: isTelemetryEnabled ? import_winston.default.format.combine(import_winston.default.format.uncolorize(), import_winston.default.format.timestamp(), import_winston.default.format.errors({ stack: true }), import_winston.default.format.json()) : import_winston.default.format.combine(import_winston.default.format.colorize(), import_winston.default.format.simple()),
+    transports: [new import_winston.default.transports.Console]
+  });
+  DISABLE_RESPONSE_LOGGING = process.env.DISABLE_RESPONSE_LOGGING === "true" || process.env.DISABLE_RESPONSE_LOGGING === "1";
+});
+
 // ../../node_modules/bytes/index.js
 var require_bytes = __commonJS((exports, module) => {
   /*!
@@ -147228,6 +147314,132 @@ var require_dist4 = __commonJS((exports) => {
   __exportStar(require_legacy2(), exports);
 });
 
+// src/constants.ts
+import os from "os";
+var API_PREFIX = "/api/v0", README_NAME = "README.md", PUBLISHER_CONFIG_NAME = "publisher.config.json", PACKAGE_MANIFEST_NAME = "publisher.json", MODEL_FILE_SUFFIX = ".malloy", NOTEBOOK_FILE_SUFFIX = ".malloynb", ROW_LIMIT = 1000, TEMP_DIR_PATH, PUBLISHER_DATA_DIR = "publisher_data";
+var init_constants = __esm(() => {
+  TEMP_DIR_PATH = os.tmpdir();
+});
+
+// src/errors.ts
+import { MalloyError } from "@malloydata/malloy";
+function internalErrorToHttpError(error) {
+  if (error instanceof BadRequestError) {
+    return httpError(400, error.message);
+  } else if (error instanceof FrozenConfigError) {
+    return httpError(403, error.message);
+  } else if (error instanceof EnvironmentNotFoundError) {
+    return httpError(404, error.message);
+  } else if (error instanceof PackageNotFoundError) {
+    return httpError(404, error.message);
+  } else if (error instanceof ModelNotFoundError) {
+    return httpError(404, error.message);
+  } else if (error instanceof MalloyError) {
+    return httpError(400, error.message);
+  } else if (error instanceof ConnectionNotFoundError) {
+    return httpError(404, error.message);
+  } else if (error instanceof ConnectionAuthError) {
+    return httpError(422, error.message);
+  } else if (error instanceof ModelCompilationError) {
+    return httpError(424, error.message);
+  } else if (error instanceof ConnectionError) {
+    return httpError(502, error.message);
+  } else if (error instanceof MaterializationNotFoundError) {
+    return httpError(404, error.message);
+  } else if (error instanceof MaterializationConflictError) {
+    return httpError(409, error.message);
+  } else if (error instanceof InvalidStateTransitionError) {
+    return httpError(409, error.message);
+  } else if (error instanceof ServiceUnavailableError) {
+    return httpError(503, error.message);
+  } else {
+    return httpError(500, error.message);
+  }
+}
+function httpError(code, message) {
+  return {
+    status: code,
+    json: {
+      code,
+      message
+    }
+  };
+}
+var NotImplementedError, BadRequestError, EnvironmentNotFoundError, PackageNotFoundError, ModelNotFoundError, ConnectionNotFoundError, ConnectionError, ConnectionAuthError, ModelCompilationError, FrozenConfigError, MaterializationNotFoundError, MaterializationConflictError, InvalidStateTransitionError, ServiceUnavailableError;
+var init_errors = __esm(() => {
+  init_constants();
+  NotImplementedError = class NotImplementedError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  BadRequestError = class BadRequestError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  EnvironmentNotFoundError = class EnvironmentNotFoundError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  PackageNotFoundError = class PackageNotFoundError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  ModelNotFoundError = class ModelNotFoundError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  ConnectionNotFoundError = class ConnectionNotFoundError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  ConnectionError = class ConnectionError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  ConnectionAuthError = class ConnectionAuthError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  ModelCompilationError = class ModelCompilationError extends Error {
+    constructor(error) {
+      super(error.message);
+    }
+  };
+  FrozenConfigError = class FrozenConfigError extends Error {
+    constructor(message = `Publisher config can't be updated when ${PUBLISHER_CONFIG_NAME} has { "frozenConfig": true }`) {
+      super(message);
+    }
+  };
+  MaterializationNotFoundError = class MaterializationNotFoundError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  MaterializationConflictError = class MaterializationConflictError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  InvalidStateTransitionError = class InvalidStateTransitionError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  ServiceUnavailableError = class ServiceUnavailableError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+});
+
 // ../../node_modules/delayed-stream/lib/delayed_stream.js
 var require_delayed_stream = __commonJS((exports, module) => {
   var Stream = __require("stream").Stream;
@@ -199156,6 +199368,464 @@ var require_dist12 = __commonJS((exports) => {
   exports.default = deferred;
 });
 
+// src/compile/compile_pool.ts
+var exports_compile_pool = {};
+__export(exports_compile_pool, {
+  getCompileWorkerCount: () => getCompileWorkerCount,
+  getCompilePool: () => getCompilePool,
+  __setCompilePoolForTests: () => __setCompilePoolForTests,
+  CompileWorkerPool: () => CompileWorkerPool
+});
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname3, join as join3 } from "path";
+import { Worker } from "node:worker_threads";
+function getCompileWorkerCount() {
+  const raw = process.env.MALLOY_COMPILE_WORKERS;
+  if (raw === undefined)
+    return 0;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0)
+    return 0;
+  return parsed;
+}
+function resolveWorkerScript() {
+  const thisFile = fileURLToPath2(import.meta.url);
+  const thisDir = dirname3(thisFile);
+  const distCandidate = join3(thisDir, "compile_worker.mjs");
+  if (thisFile.endsWith(".mjs") || thisFile.endsWith(".js")) {
+    return new URL(`file://${distCandidate}`);
+  }
+  const tsCandidate = join3(thisDir, "compile_worker.ts");
+  return new URL(`file://${tsCandidate}`);
+}
+
+class CompileWorkerPool {
+  workers = [];
+  maxWorkers;
+  nextWorkerId = 0;
+  jobs = new Map;
+  nextJobId = 0;
+  shuttingDown = false;
+  workerScript;
+  constructor(maxWorkers, workerScript) {
+    this.maxWorkers = maxWorkers;
+    this.workerScript = workerScript ?? resolveWorkerScript();
+  }
+  get enabled() {
+    return this.maxWorkers > 0;
+  }
+  get size() {
+    return this.workers.filter((w) => !w.exited).length;
+  }
+  async compile(request) {
+    return this.dispatchJob({
+      label: `model=${request.modelPath}`,
+      malloyConfig: request.malloyConfig,
+      urlReader: request.urlReader,
+      buildMessage: (jobId) => ({
+        type: "compile",
+        requestId: jobId,
+        packagePath: request.packagePath,
+        modelPath: request.modelPath,
+        defaultConnectionName: request.defaultConnectionName,
+        buildManifest: request.buildManifest
+      })
+    });
+  }
+  async compileInline(request) {
+    return this.dispatchJob({
+      label: "inline-source",
+      malloyConfig: request.malloyConfig,
+      urlReader: request.urlReader,
+      buildMessage: (jobId) => ({
+        type: "compile",
+        requestId: jobId,
+        packagePath: request.packagePath,
+        inlineSource: request.source,
+        importBaseURL: request.importBaseURL,
+        defaultConnectionName: request.defaultConnectionName,
+        buildManifest: request.buildManifest
+      })
+    });
+  }
+  async dispatchJob(opts) {
+    if (!this.enabled) {
+      throw new Error("CompileWorkerPool called while disabled (MALLOY_COMPILE_WORKERS=0)");
+    }
+    if (this.shuttingDown) {
+      throw new Error("CompileWorkerPool is shutting down");
+    }
+    const worker = await this.acquireWorker();
+    this.nextJobId += 1;
+    const jobId = `job-${this.nextJobId}`;
+    return new Promise((resolve3, reject) => {
+      const timeout = setTimeout(() => {
+        this.failJob(jobId, new Error(`Compile job timed out after ${COMPILE_JOB_TIMEOUT_MS}ms (${opts.label})`));
+      }, COMPILE_JOB_TIMEOUT_MS);
+      this.jobs.set(jobId, {
+        jobId,
+        connections: opts.malloyConfig.connections,
+        urlReader: opts.urlReader ?? defaultUrlReader,
+        resolve: (result) => {
+          clearTimeout(timeout);
+          resolve3(adaptResult(result));
+        },
+        reject: (err) => {
+          clearTimeout(timeout);
+          reject(err);
+        },
+        timeout
+      });
+      worker.inFlight.add(jobId);
+      worker.worker.postMessage(opts.buildMessage(jobId));
+    });
+  }
+  async shutdown() {
+    if (this.shuttingDown)
+      return;
+    this.shuttingDown = true;
+    const exits = this.workers.map((pw) => new Promise((resolve3) => {
+      if (pw.exited) {
+        resolve3();
+        return;
+      }
+      pw.worker.once("exit", () => resolve3());
+      const msg = { type: "shutdown" };
+      pw.worker.postMessage(msg);
+      setTimeout(() => {
+        if (!pw.exited) {
+          pw.worker.terminate().finally(() => resolve3());
+        }
+      }, 1e4);
+    }));
+    await Promise.all(exits);
+  }
+  async acquireWorker() {
+    this.workers.splice(0, this.workers.length, ...this.workers.filter((w) => !w.exited));
+    if (this.workers.length < this.maxWorkers) {
+      const pw = this.spawnWorker();
+      this.workers.push(pw);
+      await pw.ready;
+      return pw;
+    }
+    const alive = this.workers.filter((w) => !w.exited);
+    let best = alive[0];
+    for (const candidate of alive) {
+      if (candidate.inFlight.size < best.inFlight.size) {
+        best = candidate;
+      }
+    }
+    await best.ready;
+    return best;
+  }
+  spawnWorker() {
+    this.nextWorkerId += 1;
+    const id = this.nextWorkerId;
+    logger.info(`CompileWorkerPool: spawning worker #${id} (script=${this.workerScript.toString()})`);
+    const worker = new Worker(this.workerScript, {
+      name: `malloy-compile-worker-${id}`
+    });
+    let readyResolve;
+    const ready = new Promise((r) => readyResolve = r);
+    const pw = {
+      id,
+      worker,
+      ready,
+      inFlight: new Set,
+      exited: false
+    };
+    worker.on("message", (msg) => {
+      this.handleWorkerMessage(pw, msg, readyResolve);
+    });
+    worker.on("error", (err) => {
+      logger.error(`CompileWorkerPool: worker #${id} errored`, {
+        error: err
+      });
+    });
+    worker.on("exit", (code) => {
+      pw.exited = true;
+      logger.warn(`CompileWorkerPool: worker #${id} exited (code=${code}, inFlight=${pw.inFlight.size})`);
+      for (const jobId of pw.inFlight) {
+        this.failJob(jobId, new Error(`Compile worker #${id} exited unexpectedly (code=${code})`));
+      }
+      pw.inFlight.clear();
+    });
+    return pw;
+  }
+  handleWorkerMessage(pw, msg, markReady) {
+    switch (msg.type) {
+      case "ready":
+        markReady();
+        return;
+      case "compile-result":
+        this.completeJob(pw, msg);
+        return;
+      case "compile-error":
+        this.errorJob(pw, msg);
+        return;
+      case "connection-metadata":
+        this.handleConnectionMetadata(pw, msg);
+        return;
+      case "schema-for-tables":
+        this.handleSchemaForTables(pw, msg);
+        return;
+      case "schema-for-sql":
+        this.handleSchemaForSql(pw, msg);
+        return;
+      case "read-url":
+        this.handleReadUrl(pw, msg);
+        return;
+      default: {
+        const exhaustive = msg;
+        return;
+      }
+    }
+  }
+  async handleConnectionMetadata(pw, msg) {
+    const ctx = this.jobs.get(msg.jobId);
+    const reply = (response) => {
+      pw.worker.postMessage(response);
+    };
+    if (!ctx) {
+      reply({
+        type: "rpc-error",
+        requestId: msg.requestId,
+        ok: false,
+        error: { name: "Error", message: `Unknown jobId ${msg.jobId}` }
+      });
+      return;
+    }
+    try {
+      const conn = await ctx.connections.lookupConnection(msg.connectionName);
+      reply({
+        type: "connection-metadata-response",
+        requestId: msg.requestId,
+        ok: true,
+        metadata: {
+          name: msg.connectionName,
+          dialectName: conn.dialectName,
+          digest: typeof conn.getDigest === "function" ? conn.getDigest() : msg.connectionName
+        }
+      });
+    } catch (error) {
+      reply({
+        type: "rpc-error",
+        requestId: msg.requestId,
+        ok: false,
+        error: serializeError(error)
+      });
+    }
+  }
+  completeJob(pw, msg) {
+    const ctx = this.jobs.get(msg.requestId);
+    if (!ctx)
+      return;
+    this.jobs.delete(msg.requestId);
+    pw.inFlight.delete(msg.requestId);
+    ctx.resolve(msg);
+  }
+  errorJob(pw, msg) {
+    const ctx = this.jobs.get(msg.requestId);
+    if (!ctx)
+      return;
+    this.jobs.delete(msg.requestId);
+    pw.inFlight.delete(msg.requestId);
+    ctx.reject(deserializeError(msg.error));
+  }
+  failJob(jobId, error) {
+    const ctx = this.jobs.get(jobId);
+    if (!ctx)
+      return;
+    this.jobs.delete(jobId);
+    ctx.reject(error);
+  }
+  async handleSchemaForTables(pw, msg) {
+    const ctx = this.jobs.get(msg.jobId);
+    const reply = (response) => {
+      pw.worker.postMessage(response);
+    };
+    if (!ctx) {
+      reply({
+        type: "rpc-error",
+        requestId: msg.requestId,
+        ok: false,
+        error: { name: "Error", message: `Unknown jobId ${msg.jobId}` }
+      });
+      return;
+    }
+    try {
+      const conn = await ctx.connections.lookupConnection(msg.connectionName);
+      const result = await conn.fetchSchemaForTables(msg.tables, buildFetchOptions(msg.options));
+      reply({
+        type: "schema-for-tables-response",
+        requestId: msg.requestId,
+        ok: true,
+        schemas: result.schemas,
+        errors: result.errors
+      });
+    } catch (error) {
+      reply({
+        type: "rpc-error",
+        requestId: msg.requestId,
+        ok: false,
+        error: serializeError(error)
+      });
+    }
+  }
+  async handleSchemaForSql(pw, msg) {
+    const ctx = this.jobs.get(msg.jobId);
+    const reply = (response) => {
+      pw.worker.postMessage(response);
+    };
+    if (!ctx) {
+      reply({
+        type: "rpc-error",
+        requestId: msg.requestId,
+        ok: false,
+        error: { name: "Error", message: `Unknown jobId ${msg.jobId}` }
+      });
+      return;
+    }
+    try {
+      const conn = await ctx.connections.lookupConnection(msg.connectionName);
+      const result = await conn.fetchSchemaForSQLStruct(msg.sentence, buildFetchOptions(msg.options));
+      if (result.error !== undefined) {
+        reply({
+          type: "schema-for-sql-response",
+          requestId: msg.requestId,
+          ok: true,
+          error: result.error
+        });
+      } else {
+        reply({
+          type: "schema-for-sql-response",
+          requestId: msg.requestId,
+          ok: true,
+          structDef: result.structDef
+        });
+      }
+    } catch (error) {
+      reply({
+        type: "rpc-error",
+        requestId: msg.requestId,
+        ok: false,
+        error: serializeError(error)
+      });
+    }
+  }
+  async handleReadUrl(pw, msg) {
+    const ctx = this.jobs.get(msg.jobId);
+    const reply = (response) => {
+      pw.worker.postMessage(response);
+    };
+    if (!ctx) {
+      reply({
+        type: "rpc-error",
+        requestId: msg.requestId,
+        ok: false,
+        error: { name: "Error", message: `Unknown jobId ${msg.jobId}` }
+      });
+      return;
+    }
+    try {
+      const raw = await ctx.urlReader.readURL(new URL(msg.url));
+      const contents = typeof raw === "string" ? raw : raw.contents;
+      reply({
+        type: "read-url-response",
+        requestId: msg.requestId,
+        ok: true,
+        contents
+      });
+    } catch (error) {
+      reply({
+        type: "rpc-error",
+        requestId: msg.requestId,
+        ok: false,
+        error: serializeError(error)
+      });
+    }
+  }
+}
+function buildFetchOptions(options) {
+  const out = {};
+  if (options.refreshTimestamp !== undefined) {
+    out.refreshTimestamp = options.refreshTimestamp;
+  }
+  if (options.modelAnnotation !== undefined) {
+    out.modelAnnotation = options.modelAnnotation;
+  }
+  return out;
+}
+function adaptResult(result) {
+  return {
+    modelDef: result.modelDef,
+    sourceInfos: result.sourceInfos,
+    sources: result.sources,
+    queries: result.queries,
+    filterMap: new Map(result.filterMap.map(([k, v]) => [k, v])),
+    givens: result.givens,
+    compileDurationMs: result.compileDurationMs
+  };
+}
+function serializeError(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    };
+  }
+  return { name: "Error", message: String(error) };
+}
+function deserializeError(serialized) {
+  const err = new Error(serialized.message);
+  err.name = serialized.name;
+  if (serialized.stack)
+    err.stack = serialized.stack;
+  if (serialized.malloyProblems) {
+    err.problems = serialized.malloyProblems;
+  }
+  if (serialized.isCompilationError) {
+    const wrapped = new ModelCompilationError(err);
+    if (serialized.stack)
+      wrapped.stack = serialized.stack;
+    return wrapped;
+  }
+  return err;
+}
+function getCompilePool() {
+  if (singleton === null) {
+    const n = getCompileWorkerCount();
+    singleton = new CompileWorkerPool(n);
+    if (n > 0) {
+      logger.info(`Malloy compile worker pool enabled (size=${n}). Set MALLOY_COMPILE_WORKERS=0 to disable.`);
+    } else {
+      logger.info("Malloy compile worker pool DISABLED (MALLOY_COMPILE_WORKERS=0). Compile runs on the main event loop.");
+    }
+  }
+  return singleton;
+}
+async function __setCompilePoolForTests(pool) {
+  if (singleton && singleton !== pool) {
+    await singleton.shutdown();
+  }
+  singleton = pool;
+}
+var COMPILE_JOB_TIMEOUT_MS, defaultUrlReader, singleton = null;
+var init_compile_pool = __esm(() => {
+  init_errors();
+  init_logger();
+  COMPILE_JOB_TIMEOUT_MS = Number.parseInt(process.env.MALLOY_COMPILE_JOB_TIMEOUT_MS ?? "120000", 10);
+  defaultUrlReader = {
+    readURL: async (url2) => {
+      const { promises: fs3 } = await import("fs");
+      const { fileURLToPath: fileURLToPath3 } = await import("url");
+      const filePath = url2.protocol === "file:" ? fileURLToPath3(url2) : url2.toString();
+      return fs3.readFile(filePath, "utf8");
+    }
+  };
+});
+
 // ../../node_modules/concat-map/index.js
 var require_concat_map = __commonJS((exports, module) => {
   module.exports = function(xs, fn) {
@@ -209122,7 +209792,7 @@ var require_util14 = __commonJS((exports) => {
     return path12;
   }
   exports.normalize = normalize2;
-  function join8(aRoot, aPath) {
+  function join9(aRoot, aPath) {
     if (aRoot === "") {
       aRoot = ".";
     }
@@ -209154,7 +209824,7 @@ var require_util14 = __commonJS((exports) => {
     }
     return joined;
   }
-  exports.join = join8;
+  exports.join = join9;
   exports.isAbsolute = function(aPath) {
     return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
   };
@@ -209327,7 +209997,7 @@ var require_util14 = __commonJS((exports) => {
           parsed.path = parsed.path.substring(0, index + 1);
         }
       }
-      sourceURL = join8(urlGenerate(parsed), sourceURL);
+      sourceURL = join9(urlGenerate(parsed), sourceURL);
     }
     return normalize2(sourceURL);
   }
@@ -211725,6 +212395,7 @@ var require_lib8 = __commonJS((exports, module) => {
 });
 
 // src/instrumentation.ts
+init_logger();
 var import_api = __toESM(require_src(), 1);
 var import_auto_instrumentations_node = __toESM(require_src59(), 1);
 var import_exporter_logs_otlp_proto = __toESM(require_src66(), 1);
@@ -211736,94 +212407,6 @@ var import_sdk_logs = __toESM(require_src75(), 1);
 var import_sdk_node = __toESM(require_src106(), 1);
 var import_sdk_trace_base = __toESM(require_src82(), 1);
 var import_semantic_conventions = __toESM(require_src2(), 1);
-import { monitorEventLoopDelay } from "node:perf_hooks";
-
-// src/logger.ts
-var import_winston = __toESM(require_winston(), 1);
-var isTelemetryEnabled = Boolean(process.env.OTEL_EXPORTER_OTLP_ENDPOINT);
-var VALID_LOG_LEVELS = ["error", "warn", "info", "verbose", "debug", "silly"];
-var getLogLevel = () => {
-  if (process.env.LOG_LEVEL) {
-    const logLevel = process.env.LOG_LEVEL.toLowerCase();
-    if (VALID_LOG_LEVELS.includes(logLevel)) {
-      return logLevel;
-    } else {
-      console.error(`Invalid log level: ${process.env.LOG_LEVEL}. Valid log levels are: ${VALID_LOG_LEVELS.join(", ")}. Defaulting to "debug".`);
-    }
-  }
-  return "debug";
-};
-var logger = import_winston.default.createLogger({
-  level: getLogLevel(),
-  format: isTelemetryEnabled ? import_winston.default.format.combine(import_winston.default.format.uncolorize(), import_winston.default.format.timestamp(), import_winston.default.format.errors({ stack: true }), import_winston.default.format.json()) : import_winston.default.format.combine(import_winston.default.format.colorize(), import_winston.default.format.simple()),
-  transports: [new import_winston.default.transports.Console]
-});
-function extractTraceIdFromTraceparent(traceparent) {
-  if (!traceparent) {
-    return;
-  }
-  const parts = traceparent.split("-");
-  const traceId = parts.length >= 2 ? parts[1] : parts.length == 1 ? parts[0] : undefined;
-  if (traceId && traceId.length === 32 && /^[0-9a-fA-F]{32}$/.test(traceId)) {
-    return traceId;
-  }
-  return;
-}
-var DISABLE_RESPONSE_LOGGING = process.env.DISABLE_RESPONSE_LOGGING === "true" || process.env.DISABLE_RESPONSE_LOGGING === "1";
-function formatDuration(durationMs) {
-  if (durationMs >= 1000) {
-    const seconds = durationMs / 1000;
-    return `${seconds.toFixed(2)}s`;
-  }
-  return `${durationMs.toFixed(2)}ms`;
-}
-var loggerMiddleware = (req, res, next) => {
-  const startTime = performance.now();
-  const resJson = res.json;
-  res.json = (body) => {
-    res.locals.body = body;
-    return resJson.call(res, body);
-  };
-  res.on("finish", () => {
-    const endTime = performance.now();
-    const durationMs = endTime - startTime;
-    const traceparent = req.headers["traceparent"];
-    const traceId = extractTraceIdFromTraceparent(traceparent);
-    const logMetadata = {
-      statusCode: res.statusCode,
-      duration: formatDuration(durationMs),
-      payload: req.body,
-      params: req.params,
-      query: req.query
-    };
-    if (!DISABLE_RESPONSE_LOGGING) {
-      logMetadata.response = res.locals.body;
-    }
-    if (traceId) {
-      logMetadata.traceId = traceId;
-    }
-    if (req.url !== "/metrics" && req.url !== "/health" && req.url !== "/health/liveness" && req.url !== "/health/readiness") {
-      logger.info(`${req.method} ${req.url}`, logMetadata);
-    }
-  });
-  next();
-};
-var logAxiosError = (error) => {
-  if (error.response) {
-    logger.error("Axios server-side error", {
-      url: error.response.config.url,
-      status: error.response.status,
-      headers: error.response.headers,
-      data: error.response.data
-    });
-  } else if (error.request) {
-    logger.error("Axios client-side error", { error: error.request });
-  } else {
-    logger.error("Axios unknown error", { error });
-  }
-};
-
-// src/instrumentation.ts
 var prometheusExporter = null;
 var sdk = null;
 function getPrometheusMetricsHandler() {
@@ -211905,26 +212488,6 @@ var httpRequestDuration = meter.createHistogram("http_server_request_duration_ms
 var httpRequestCount = meter.createCounter("http_server_requests_total", {
   description: "Total number of HTTP requests"
 });
-var eventLoopHistogram = monitorEventLoopDelay({ resolution: 20 });
-eventLoopHistogram.enable();
-var eventLoopLagP50 = meter.createObservableGauge("publisher_event_loop_lag_p50_ms", {
-  description: "Event loop delay p50 since the last scrape, in milliseconds",
-  unit: "ms"
-});
-var eventLoopLagP99 = meter.createObservableGauge("publisher_event_loop_lag_p99_ms", {
-  description: "Event loop delay p99 since the last scrape, in milliseconds",
-  unit: "ms"
-});
-var eventLoopLagMax = meter.createObservableGauge("publisher_event_loop_lag_max_ms", {
-  description: "Event loop delay max since the last scrape, in milliseconds",
-  unit: "ms"
-});
-meter.addBatchObservableCallback((observableResult) => {
-  observableResult.observe(eventLoopLagP50, eventLoopHistogram.percentile(50) / 1e6);
-  observableResult.observe(eventLoopLagP99, eventLoopHistogram.percentile(99) / 1e6);
-  observableResult.observe(eventLoopLagMax, eventLoopHistogram.max / 1e6);
-  eventLoopHistogram.reset();
-}, [eventLoopLagP50, eventLoopLagP99, eventLoopLagMax]);
 var IGNORED_PATHS = new Set([
   "/health",
   "/health/liveness",
@@ -216966,7 +217529,7 @@ var import_express = __toESM(require_express(), 1);
 var import_http_proxy_middleware = __toESM(require_dist4(), 1);
 import * as http2 from "http";
 import * as path12 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/controller/compile.controller.ts
 class CompileController {
@@ -216986,148 +217549,9 @@ class CompileController {
   }
 }
 
-// src/errors.ts
-import { MalloyError } from "@malloydata/malloy";
-
-// src/constants.ts
-import os from "os";
-var API_PREFIX = "/api/v0";
-var README_NAME = "README.md";
-var PUBLISHER_CONFIG_NAME = "publisher.config.json";
-var PACKAGE_MANIFEST_NAME = "publisher.json";
-var MODEL_FILE_SUFFIX = ".malloy";
-var NOTEBOOK_FILE_SUFFIX = ".malloynb";
-var ROW_LIMIT = 1000;
-var TEMP_DIR_PATH = os.tmpdir();
-var PUBLISHER_DATA_DIR = "publisher_data";
-
-// src/errors.ts
-function internalErrorToHttpError(error) {
-  if (error instanceof BadRequestError) {
-    return httpError(400, error.message);
-  } else if (error instanceof FrozenConfigError) {
-    return httpError(403, error.message);
-  } else if (error instanceof EnvironmentNotFoundError) {
-    return httpError(404, error.message);
-  } else if (error instanceof PackageNotFoundError) {
-    return httpError(404, error.message);
-  } else if (error instanceof ModelNotFoundError) {
-    return httpError(404, error.message);
-  } else if (error instanceof MalloyError) {
-    return httpError(400, error.message);
-  } else if (error instanceof ConnectionNotFoundError) {
-    return httpError(404, error.message);
-  } else if (error instanceof ConnectionAuthError) {
-    return httpError(422, error.message);
-  } else if (error instanceof ModelCompilationError) {
-    return httpError(424, error.message);
-  } else if (error instanceof ConnectionError) {
-    return httpError(502, error.message);
-  } else if (error instanceof MaterializationNotFoundError) {
-    return httpError(404, error.message);
-  } else if (error instanceof MaterializationConflictError) {
-    return httpError(409, error.message);
-  } else if (error instanceof InvalidStateTransitionError) {
-    return httpError(409, error.message);
-  } else if (error instanceof ServiceUnavailableError) {
-    return httpError(503, error.message);
-  } else {
-    return httpError(500, error.message);
-  }
-}
-function httpError(code, message) {
-  return {
-    status: code,
-    json: {
-      code,
-      message
-    }
-  };
-}
-
-class NotImplementedError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class BadRequestError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class EnvironmentNotFoundError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class PackageNotFoundError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class ModelNotFoundError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class ConnectionNotFoundError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class ConnectionError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class ConnectionAuthError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class ModelCompilationError extends Error {
-  constructor(error) {
-    super(error.message);
-  }
-}
-
-class FrozenConfigError extends Error {
-  constructor(message = `Publisher config can't be updated when ${PUBLISHER_CONFIG_NAME} has { "frozenConfig": true }`) {
-    super(message);
-  }
-}
-
-class MaterializationNotFoundError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class MaterializationConflictError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class InvalidStateTransitionError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class ServiceUnavailableError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
+// src/controller/connection.controller.ts
+init_errors();
+init_logger();
 
 // src/service/connection.ts
 import"@malloydata/db-bigquery";
@@ -220412,10 +220836,12 @@ var {
 } = axios_default;
 
 // src/service/connection.ts
+init_logger();
 import fs from "fs/promises";
 import path2 from "path";
 
 // src/pg_helpers.ts
+init_errors();
 function pgConnectTimeoutSeconds() {
   const raw = process.env.PG_CONNECT_TIMEOUT_SECONDS;
   if (!raw)
@@ -221666,6 +222092,8 @@ async function testConnectionConfig(connectionConfig) {
 }
 
 // src/service/connection_service.ts
+init_errors();
+init_logger();
 async function runEnvironmentConnectionUpdate(environment, fn) {
   if (environment.runConnectionUpdateExclusive) {
     return environment.runConnectionUpdateExclusive(fn);
@@ -221777,11 +222205,13 @@ class ConnectionService {
 }
 
 // src/service/db_utils.ts
+init_logger();
 var import_bigquery = __toESM(require_src121(), 1);
 import { ClientSecretCredential } from "@azure/identity";
 import { ContainerClient } from "@azure/storage-blob";
 
 // src/service/gcs_s3_utils.ts
+init_logger();
 var import_client_s3 = __toESM(require_dist_cjs75(), 1);
 function gcsConnectionToCredentials(gcsConnection) {
   return {
@@ -223129,6 +223559,8 @@ class DatabaseController {
 }
 
 // src/controller/model.controller.ts
+init_errors();
+
 class ModelController {
   environmentStore;
   constructor(environmentStore) {
@@ -223190,6 +223622,9 @@ class ModelController {
 }
 
 // src/controller/package.controller.ts
+init_errors();
+init_logger();
+
 class PackageController {
   environmentStore;
   manifestService;
@@ -223302,6 +223737,8 @@ class PackageController {
 }
 
 // src/controller/query.controller.ts
+init_constants();
+init_errors();
 var import_render_validator = __toESM(require_dist10(), 1);
 function bigIntReplacer(_key, value) {
   if (typeof value === "bigint") {
@@ -224905,6 +225342,7 @@ function watch(paths, options = {}) {
 var esm_default = { watch, FSWatcher };
 
 // src/controller/watch-mode.controller.ts
+init_logger();
 import path11 from "path";
 
 // src/service/environment_store.ts
@@ -225137,7 +225575,7 @@ var __defProp2 = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames2 = Object.getOwnPropertyNames;
 var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
+var __esm2 = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
 };
 var __commonJS2 = (cb, mod2) => function __require2() {
@@ -225168,13 +225606,13 @@ function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
 }
 var cache;
-var init_pathspec = __esm({
+var init_pathspec = __esm2({
   "src/lib/args/pathspec.ts"() {
     cache = /* @__PURE__ */ new WeakMap;
   }
 });
 var GitError;
-var init_git_error = __esm({
+var init_git_error = __esm2({
   "src/lib/errors/git-error.ts"() {
     GitError = class extends Error {
       constructor(task, message) {
@@ -225186,7 +225624,7 @@ var init_git_error = __esm({
   }
 });
 var GitResponseError;
-var init_git_response_error = __esm({
+var init_git_response_error = __esm2({
   "src/lib/errors/git-response-error.ts"() {
     init_git_error();
     GitResponseError = class extends GitError {
@@ -225198,7 +225636,7 @@ var init_git_response_error = __esm({
   }
 });
 var TaskConfigurationError;
-var init_task_configuration_error = __esm({
+var init_task_configuration_error = __esm2({
   "src/lib/errors/task-configuration-error.ts"() {
     init_git_error();
     TaskConfigurationError = class extends GitError {
@@ -225321,7 +225759,7 @@ function orVoid(input) {
 var NULL;
 var NOOP;
 var objectToString;
-var init_util = __esm({
+var init_util = __esm2({
   "src/lib/utils/util.ts"() {
     NULL = "\x00";
     NOOP = () => {};
@@ -225349,7 +225787,7 @@ var filterString;
 var filterStringArray;
 var filterStringOrStringArray;
 var filterHasLength;
-var init_argument_filters = __esm({
+var init_argument_filters = __esm2({
   "src/lib/utils/argument-filters.ts"() {
     init_util();
     init_pathspec();
@@ -225374,7 +225812,7 @@ var init_argument_filters = __esm({
   }
 });
 var ExitCodes;
-var init_exit_codes = __esm({
+var init_exit_codes = __esm2({
   "src/lib/utils/exit-codes.ts"() {
     ExitCodes = /* @__PURE__ */ ((ExitCodes2) => {
       ExitCodes2[ExitCodes2["SUCCESS"] = 0] = "SUCCESS";
@@ -225386,7 +225824,7 @@ var init_exit_codes = __esm({
   }
 });
 var GitOutputStreams;
-var init_git_output_streams = __esm({
+var init_git_output_streams = __esm2({
   "src/lib/utils/git-output-streams.ts"() {
     GitOutputStreams = class _GitOutputStreams {
       constructor(stdOut, stdErr) {
@@ -225401,7 +225839,7 @@ var init_git_output_streams = __esm({
 });
 var LineParser;
 var RemoteLineParser;
-var init_line_parser = __esm({
+var init_line_parser = __esm2({
   "src/lib/utils/line-parser.ts"() {
     LineParser = class {
       constructor(regExp, useMatches) {
@@ -225458,7 +225896,7 @@ function createInstanceConfig(...options) {
   return config;
 }
 var defaultOptions2;
-var init_simple_git_options = __esm({
+var init_simple_git_options = __esm2({
   "src/lib/utils/simple-git-options.ts"() {
     defaultOptions2 = {
       binary: "git",
@@ -225515,7 +225953,7 @@ function trailingFunctionArgument(args, includeNoop = true) {
   const callback = asFunction(last(args));
   return includeNoop || isUserFunction(callback) ? callback : undefined;
 }
-var init_task_options = __esm({
+var init_task_options = __esm2({
   "src/lib/utils/task-options.ts"() {
     init_argument_filters();
     init_util();
@@ -225539,7 +225977,7 @@ function parseStringResponse(result, parsers12, texts, trim2 = true) {
   });
   return result;
 }
-var init_task_parser = __esm({
+var init_task_parser = __esm2({
   "src/lib/utils/task-parser.ts"() {
     init_util();
   }
@@ -225590,7 +226028,7 @@ __export2(utils_exports, {
   trailingFunctionArgument: () => trailingFunctionArgument,
   trailingOptionsArgument: () => trailingOptionsArgument
 });
-var init_utils = __esm({
+var init_utils = __esm2({
   "src/lib/utils/index.ts"() {
     init_argument_filters();
     init_exit_codes();
@@ -225650,7 +226088,7 @@ function isNotRepoMessage(error) {
 var CheckRepoActions;
 var onError;
 var parser;
-var init_check_is_repo = __esm({
+var init_check_is_repo = __esm2({
   "src/lib/tasks/check-is-repo.ts"() {
     init_utils();
     CheckRepoActions = /* @__PURE__ */ ((CheckRepoActions2) => {
@@ -225684,7 +226122,7 @@ var CleanResponse;
 var removalRegexp;
 var dryRunRemovalRegexp;
 var isFolderRegexp;
-var init_CleanSummary = __esm({
+var init_CleanSummary = __esm2({
   "src/lib/responses/CleanSummary.ts"() {
     init_utils();
     CleanResponse = class {
@@ -225751,7 +226189,7 @@ function isEmptyTask(task) {
   return task.format === "empty" || !task.commands.length;
 }
 var EMPTY_COMMANDS;
-var init_task = __esm({
+var init_task = __esm2({
   "src/lib/tasks/task.ts"() {
     init_task_configuration_error();
     EMPTY_COMMANDS = [];
@@ -225829,7 +226267,7 @@ var CONFIG_ERROR_MODE_REQUIRED;
 var CONFIG_ERROR_UNKNOWN_OPTION;
 var CleanOptions;
 var CleanOptionValues;
-var init_clean = __esm({
+var init_clean = __esm2({
   "src/lib/tasks/clean.ts"() {
     init_CleanSummary();
     init_utils();
@@ -225902,7 +226340,7 @@ function* configParser(text, requestedKey = null) {
   }
 }
 var ConfigList;
-var init_ConfigList = __esm({
+var init_ConfigList = __esm2({
   "src/lib/responses/ConfigList.ts"() {
     init_utils();
     ConfigList = class {
@@ -226000,7 +226438,7 @@ function config_default() {
   };
 }
 var GitConfigScope;
-var init_config = __esm({
+var init_config = __esm2({
   "src/lib/tasks/config.ts"() {
     init_ConfigList();
     init_utils();
@@ -226018,7 +226456,7 @@ function isDiffNameStatus(input) {
 }
 var DiffNameStatus;
 var diffNameStatus;
-var init_diff_name_status = __esm({
+var init_diff_name_status = __esm2({
   "src/lib/tasks/diff-name-status.ts"() {
     DiffNameStatus = /* @__PURE__ */ ((DiffNameStatus2) => {
       DiffNameStatus2["ADDED"] = "A";
@@ -226083,7 +226521,7 @@ var disallowedOptions;
 var Query;
 var _a;
 var GrepQuery;
-var init_grep = __esm({
+var init_grep = __esm2({
   "src/lib/tasks/grep.ts"() {
     init_utils();
     init_task();
@@ -226139,7 +226577,7 @@ function isValidResetMode(mode) {
 }
 var ResetMode;
 var ResetModes;
-var init_reset = __esm({
+var init_reset = __esm2({
   "src/lib/tasks/reset.ts"() {
     init_task();
     ResetMode = /* @__PURE__ */ ((ResetMode2) => {
@@ -226201,7 +226639,7 @@ function createLogger(label, verbose, initialStep, infoDebugger = createLog()) {
     });
   }
 }
-var init_git_logger = __esm({
+var init_git_logger = __esm2({
   "src/lib/git-logger.ts"() {
     init_utils();
     import_debug.default.formatters.L = (value) => String(filterHasLength(value) ? value.length : "-");
@@ -226214,7 +226652,7 @@ var init_git_logger = __esm({
   }
 });
 var TasksPendingQueue;
-var init_tasks_pending_queue = __esm({
+var init_tasks_pending_queue = __esm2({
   "src/lib/runners/tasks-pending-queue.ts"() {
     init_git_error();
     init_git_logger();
@@ -226298,7 +226736,7 @@ function onDataReceived(target, name, logger2, output) {
   };
 }
 var GitExecutorChain;
-var init_git_executor_chain = __esm({
+var init_git_executor_chain = __esm2({
   "src/lib/runners/git-executor-chain.ts"() {
     init_git_error();
     init_task();
@@ -226463,7 +226901,7 @@ __export2(git_executor_exports, {
   GitExecutor: () => GitExecutor
 });
 var GitExecutor;
-var init_git_executor = __esm({
+var init_git_executor = __esm2({
   "src/lib/runners/git-executor.ts"() {
     init_git_executor_chain();
     GitExecutor = class {
@@ -226514,7 +226952,7 @@ function addDeprecationNoticeToError(err) {
     return all3;
   }
 }
-var init_task_callback = __esm({
+var init_task_callback = __esm2({
   "src/lib/task-callback.ts"() {
     init_git_response_error();
     init_utils();
@@ -226528,7 +226966,7 @@ function changeWorkingDirectoryTask(directory, root) {
     return (root || instance).cwd = directory;
   });
 }
-var init_change_working_directory = __esm({
+var init_change_working_directory = __esm2({
   "src/lib/tasks/change-working-directory.ts"() {
     init_utils();
     init_task();
@@ -226554,7 +226992,7 @@ function checkout_default() {
     }
   };
 }
-var init_checkout = __esm({
+var init_checkout = __esm2({
   "src/lib/tasks/checkout.ts"() {
     init_utils();
     init_task();
@@ -226586,7 +227024,7 @@ function count_objects_default() {
   };
 }
 var parser2;
-var init_count_objects = __esm({
+var init_count_objects = __esm2({
   "src/lib/tasks/count-objects.ts"() {
     init_utils();
     parser2 = new LineParser(/([a-z-]+): (\d+)$/, (result, [key, value]) => {
@@ -226612,7 +227050,7 @@ function parseCommitResult(stdOut) {
   return parseStringResponse(result, parsers, stdOut);
 }
 var parsers;
-var init_parse_commit = __esm({
+var init_parse_commit = __esm2({
   "src/lib/parsers/parse-commit.ts"() {
     init_utils();
     parsers = [
@@ -226676,7 +227114,7 @@ function commit_default() {
     return !filterStringOrStringArray(message) && configurationErrorTask(`git.commit: requires the commit message to be supplied as a string/string[]`);
   }
 }
-var init_commit = __esm({
+var init_commit = __esm2({
   "src/lib/tasks/commit.ts"() {
     init_parse_commit();
     init_utils();
@@ -226690,7 +227128,7 @@ function first_commit_default() {
     }
   };
 }
-var init_first_commit = __esm({
+var init_first_commit = __esm2({
   "src/lib/tasks/first-commit.ts"() {
     init_utils();
     init_task();
@@ -226703,7 +227141,7 @@ function hashObjectTask(filePath, write) {
   }
   return straightThroughStringTask(commands, true);
 }
-var init_hash_object = __esm({
+var init_hash_object = __esm2({
   "src/lib/tasks/hash-object.ts"() {
     init_task();
   }
@@ -226731,7 +227169,7 @@ function parseInit(bare, path3, text) {
 var InitSummary;
 var initResponseRegex;
 var reInitResponseRegex;
-var init_InitSummary = __esm({
+var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     InitSummary = class {
       constructor(bare, path3, existing, gitDir) {
@@ -226762,7 +227200,7 @@ function initTask(bare = false, path3, customArgs) {
   };
 }
 var bareCommand;
-var init_init = __esm({
+var init_init = __esm2({
   "src/lib/tasks/init.ts"() {
     init_InitSummary();
     bareCommand = "--bare";
@@ -226781,13 +227219,13 @@ function isLogFormat(customArg) {
   return logFormatRegex.test(customArg);
 }
 var logFormatRegex;
-var init_log_format = __esm({
+var init_log_format = __esm2({
   "src/lib/args/log-format.ts"() {
     logFormatRegex = /^--(stat|numstat|name-only|name-status)(=|$)/;
   }
 });
 var DiffSummary;
-var init_DiffSummary = __esm({
+var init_DiffSummary = __esm2({
   "src/lib/responses/DiffSummary.ts"() {
     DiffSummary = class {
       constructor() {
@@ -226808,7 +227246,7 @@ var numStatParser;
 var nameOnlyParser;
 var nameStatusParser;
 var diffSummaryParsers;
-var init_parse_diff_summary = __esm({
+var init_parse_diff_summary = __esm2({
   "src/lib/parsers/parse-diff-summary.ts"() {
     init_log_format();
     init_DiffSummary();
@@ -226929,7 +227367,7 @@ var START_BOUNDARY;
 var COMMIT_BOUNDARY;
 var SPLITTER;
 var defaultFieldNames;
-var init_parse_list_log_summary = __esm({
+var init_parse_list_log_summary = __esm2({
   "src/lib/parsers/parse-list-log-summary.ts"() {
     init_utils();
     init_parse_diff_summary();
@@ -226968,7 +227406,7 @@ function validateLogFormatConfig(customArgs) {
     return configurationErrorTask(`Summary flag ${flags} parsing is not compatible with null termination option '-z'`);
   }
 }
-var init_diff = __esm({
+var init_diff = __esm2({
   "src/lib/tasks/diff.ts"() {
     init_log_format();
     init_parse_diff_summary();
@@ -227052,7 +227490,7 @@ function log_default() {
   }
 }
 var excludeOptions;
-var init_log = __esm({
+var init_log = __esm2({
   "src/lib/tasks/log.ts"() {
     init_log_format();
     init_pathspec();
@@ -227080,7 +227518,7 @@ var init_log = __esm({
 });
 var MergeSummaryConflict;
 var MergeSummaryDetail;
-var init_MergeSummary = __esm({
+var init_MergeSummary = __esm2({
   "src/lib/responses/MergeSummary.ts"() {
     MergeSummaryConflict = class {
       constructor(reason, file = null, meta) {
@@ -227115,7 +227553,7 @@ var init_MergeSummary = __esm({
 });
 var PullSummary;
 var PullFailedSummary;
-var init_PullSummary = __esm({
+var init_PullSummary = __esm2({
   "src/lib/responses/PullSummary.ts"() {
     PullSummary = class {
       constructor() {
@@ -227172,7 +227610,7 @@ function asObjectCount(source) {
   };
 }
 var remoteMessagesObjectParsers;
-var init_parse_remote_objects = __esm({
+var init_parse_remote_objects = __esm2({
   "src/lib/parsers/parse-remote-objects.ts"() {
     init_utils();
     remoteMessagesObjectParsers = [
@@ -227200,7 +227638,7 @@ function parseRemoteMessages(_stdOut, stdErr) {
 }
 var parsers2;
 var RemoteMessageSummary;
-var init_parse_remote_messages = __esm({
+var init_parse_remote_messages = __esm2({
   "src/lib/parsers/parse-remote-messages.ts"() {
     init_utils();
     init_parse_remote_objects();
@@ -227239,7 +227677,7 @@ var parsers3;
 var errorParsers;
 var parsePullDetail;
 var parsePullResult;
-var init_parse_pull = __esm({
+var init_parse_pull = __esm2({
   "src/lib/parsers/parse-pull.ts"() {
     init_PullSummary();
     init_utils();
@@ -227292,7 +227730,7 @@ var init_parse_pull = __esm({
 var parsers4;
 var parseMergeResult;
 var parseMergeDetail;
-var init_parse_merge = __esm({
+var init_parse_merge = __esm2({
   "src/lib/parsers/parse-merge.ts"() {
     init_MergeSummary();
     init_utils();
@@ -227338,7 +227776,7 @@ function mergeTask(customArgs) {
     }
   };
 }
-var init_merge = __esm({
+var init_merge = __esm2({
   "src/lib/tasks/merge.ts"() {
     init_git_response_error();
     init_parse_merge();
@@ -227362,7 +227800,7 @@ function pushResultPushedItem(local, remote, status) {
 var parsers5;
 var parsePushResult;
 var parsePushDetail;
-var init_parse_push = __esm({
+var init_parse_push = __esm2({
   "src/lib/parsers/parse-push.ts"() {
     init_utils();
     init_parse_remote_messages();
@@ -227439,7 +227877,7 @@ function pushTask(ref = {}, customArgs) {
     parser: parsePushResult
   };
 }
-var init_push = __esm({
+var init_push = __esm2({
   "src/lib/tasks/push.ts"() {
     init_parse_push();
     init_utils();
@@ -227460,7 +227898,7 @@ function show_default() {
     }
   };
 }
-var init_show = __esm({
+var init_show = __esm2({
   "src/lib/tasks/show.ts"() {
     init_utils();
     init_task();
@@ -227468,7 +227906,7 @@ var init_show = __esm({
 });
 var fromPathRegex;
 var FileStatusSummary;
-var init_FileStatusSummary = __esm({
+var init_FileStatusSummary = __esm2({
   "src/lib/responses/FileStatusSummary.ts"() {
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
@@ -227522,7 +227960,7 @@ function splitLine(result, lineStr) {
 var StatusSummary;
 var parsers6;
 var parseStatusSummary;
-var init_StatusSummary = __esm({
+var init_StatusSummary = __esm2({
   "src/lib/responses/StatusSummary.ts"() {
     init_utils();
     init_FileStatusSummary();
@@ -227629,7 +228067,7 @@ function statusTask(customArgs) {
   };
 }
 var ignoredOptions;
-var init_status = __esm({
+var init_status = __esm2({
   "src/lib/tasks/status.ts"() {
     init_StatusSummary();
     ignoredOptions = ["--null", "-z"];
@@ -227678,7 +228116,7 @@ function versionParser(stdOut) {
 }
 var NOT_INSTALLED;
 var parsers7;
-var init_version = __esm({
+var init_version = __esm2({
   "src/lib/tasks/version.ts"() {
     init_utils();
     NOT_INSTALLED = "installed=false";
@@ -227697,7 +228135,7 @@ __export2(simple_git_api_exports, {
   SimpleGitApi: () => SimpleGitApi
 });
 var SimpleGitApi;
-var init_simple_git_api = __esm({
+var init_simple_git_api = __esm2({
   "src/lib/simple-git-api.ts"() {
     init_task_callback();
     init_change_working_directory();
@@ -227788,7 +228226,7 @@ __export2(scheduler_exports, {
 });
 var createScheduledTask;
 var Scheduler;
-var init_scheduler = __esm({
+var init_scheduler = __esm2({
   "src/lib/runners/scheduler.ts"() {
     init_utils();
     init_git_logger();
@@ -227841,7 +228279,7 @@ __export2(apply_patch_exports, {
 function applyPatchTask(patches, customArgs) {
   return straightThroughStringTask(["apply", ...customArgs, ...patches]);
 }
-var init_apply_patch = __esm({
+var init_apply_patch = __esm2({
   "src/lib/tasks/apply-patch.ts"() {
     init_task();
   }
@@ -227861,7 +228299,7 @@ function branchDeletionFailure(branch) {
   };
 }
 var BranchDeletionBatch;
-var init_BranchDeleteSummary = __esm({
+var init_BranchDeleteSummary = __esm2({
   "src/lib/responses/BranchDeleteSummary.ts"() {
     BranchDeletionBatch = class {
       constructor() {
@@ -227882,7 +228320,7 @@ var deleteSuccessRegex;
 var deleteErrorRegex;
 var parsers8;
 var parseBranchDeletions;
-var init_parse_branch_delete = __esm({
+var init_parse_branch_delete = __esm2({
   "src/lib/parsers/parse-branch-delete.ts"() {
     init_BranchDeleteSummary();
     init_utils();
@@ -227907,7 +228345,7 @@ var init_parse_branch_delete = __esm({
   }
 });
 var BranchSummaryResult;
-var init_BranchSummary = __esm({
+var init_BranchSummary = __esm2({
   "src/lib/responses/BranchSummary.ts"() {
     BranchSummaryResult = class {
       constructor() {
@@ -227940,7 +228378,7 @@ function parseBranchSummary(stdOut) {
   return parseStringResponse(new BranchSummaryResult, parsers9, stdOut);
 }
 var parsers9;
-var init_parse_branch = __esm({
+var init_parse_branch = __esm2({
   "src/lib/parsers/parse-branch.ts"() {
     init_BranchSummary();
     init_utils();
@@ -228025,7 +228463,7 @@ function deleteBranchTask(branch, forceDelete = false) {
   };
   return task;
 }
-var init_branch = __esm({
+var init_branch = __esm2({
   "src/lib/tasks/branch.ts"() {
     init_git_response_error();
     init_parse_branch_delete();
@@ -228034,7 +228472,7 @@ var init_branch = __esm({
   }
 });
 var parseCheckIgnore;
-var init_CheckIgnore = __esm({
+var init_CheckIgnore = __esm2({
   "src/lib/responses/CheckIgnore.ts"() {
     parseCheckIgnore = (text) => {
       return text.split(/\n/g).map((line) => line.trim()).filter((file) => !!file);
@@ -228052,7 +228490,7 @@ function checkIgnoreTask(paths) {
     parser: parseCheckIgnore
   };
 }
-var init_check_ignore = __esm({
+var init_check_ignore = __esm2({
   "src/lib/tasks/check-ignore.ts"() {
     init_CheckIgnore();
   }
@@ -228079,7 +228517,7 @@ function cloneMirrorTask(repo, directory, customArgs) {
   append2(customArgs, "--mirror");
   return cloneTask(repo, directory, customArgs);
 }
-var init_clone = __esm({
+var init_clone = __esm2({
   "src/lib/tasks/clone.ts"() {
     init_task();
     init_utils();
@@ -228097,7 +228535,7 @@ function parseFetchResult(stdOut, stdErr) {
   return parseStringResponse(result, parsers10, [stdOut, stdErr]);
 }
 var parsers10;
-var init_parse_fetch = __esm({
+var init_parse_fetch = __esm2({
   "src/lib/parsers/parse-fetch.ts"() {
     init_utils();
     parsers10 = [
@@ -228154,7 +228592,7 @@ function fetchTask(remote, branch, customArgs) {
     parser: parseFetchResult
   };
 }
-var init_fetch = __esm({
+var init_fetch = __esm2({
   "src/lib/tasks/fetch.ts"() {
     init_parse_fetch();
     init_task();
@@ -228164,7 +228602,7 @@ function parseMoveResult(stdOut) {
   return parseStringResponse({ moves: [] }, parsers11, stdOut);
 }
 var parsers11;
-var init_parse_move = __esm({
+var init_parse_move = __esm2({
   "src/lib/parsers/parse-move.ts"() {
     init_utils();
     parsers11 = [
@@ -228185,7 +228623,7 @@ function moveTask(from, to) {
     parser: parseMoveResult
   };
 }
-var init_move = __esm({
+var init_move = __esm2({
   "src/lib/tasks/move.ts"() {
     init_parse_move();
     init_utils();
@@ -228215,7 +228653,7 @@ function pullTask(remote, branch, customArgs) {
     }
   };
 }
-var init_pull = __esm({
+var init_pull = __esm2({
   "src/lib/tasks/pull.ts"() {
     init_git_response_error();
     init_parse_pull();
@@ -228245,7 +228683,7 @@ function parseGetRemotesVerbose(text) {
 function forEach2(text, handler) {
   forEachLineWithContent(text, (line) => handler(line.split(/\s+/)));
 }
-var init_GetRemoteSummary = __esm({
+var init_GetRemoteSummary = __esm2({
   "src/lib/responses/GetRemoteSummary.ts"() {
     init_utils();
   }
@@ -228289,7 +228727,7 @@ function remoteTask(customArgs) {
 function removeRemoteTask(remoteName) {
   return straightThroughStringTask(["remote", "remove", remoteName]);
 }
-var init_remote = __esm({
+var init_remote = __esm2({
   "src/lib/tasks/remote.ts"() {
     init_GetRemoteSummary();
     init_task();
@@ -228309,7 +228747,7 @@ function stashListTask(opt = {}, customArgs) {
     parser: parser4
   };
 }
-var init_stash_list = __esm({
+var init_stash_list = __esm2({
   "src/lib/tasks/stash-list.ts"() {
     init_log_format();
     init_parse_list_log_summary();
@@ -228340,7 +228778,7 @@ function subModuleTask(customArgs) {
 function updateSubModuleTask(customArgs) {
   return subModuleTask(["update", ...customArgs]);
 }
-var init_sub_module = __esm({
+var init_sub_module = __esm2({
   "src/lib/tasks/sub-module.ts"() {
     init_task();
   }
@@ -228367,7 +228805,7 @@ function toNumber(input) {
 }
 var TagList;
 var parseTagList;
-var init_TagList = __esm({
+var init_TagList = __esm2({
   "src/lib/responses/TagList.ts"() {
     TagList = class {
       constructor(all3, latest) {
@@ -228433,7 +228871,7 @@ function addAnnotatedTagTask(name, tagMessage) {
     }
   };
 }
-var init_tag = __esm({
+var init_tag = __esm2({
   "src/lib/tasks/tag.ts"() {
     init_TagList();
   }
@@ -229109,6 +229547,8 @@ var esm_default2 = gitInstanceFactory;
 import { Writable } from "stream";
 
 // src/config.ts
+init_constants();
+init_logger();
 import fs2 from "fs";
 import path3 from "path";
 import { fileURLToPath } from "url";
@@ -229366,7 +229806,12 @@ var getProcessedPublisherConfig = (serverRoot) => {
   };
 };
 
+// src/service/environment_store.ts
+init_constants();
+init_errors();
+
 // src/health.ts
+init_logger();
 var operationalState = "initializing";
 var ready = false;
 var preGracefulShutdownCompleted = false;
@@ -229422,6 +229867,11 @@ async function performGracefulShutdownAfterDrain(server, mcpServer, shutdownGrac
     await shutdownSDK();
     logger.info("OpenTelemetry SDK shut down");
   } catch (_error) {}
+  try {
+    const { getCompilePool: getCompilePool2 } = await Promise.resolve().then(() => (init_compile_pool(), exports_compile_pool));
+    await getCompilePool2().shutdown();
+    logger.info("Malloy compile worker pool shut down");
+  } catch (_error) {}
   if (shutdownGracefulCloseTimeoutSeconds > 0) {
     logger.info(`Waiting ${shutdownGracefulCloseTimeoutSeconds} seconds after server close before exit...`);
     await new Promise((resolve3) => setTimeout(resolve3, shutdownGracefulCloseTimeoutSeconds * 1000));
@@ -229463,7 +229913,12 @@ function registerHealthEndpoints(app) {
   });
 }
 
+// src/service/environment_store.ts
+init_logger();
+
 // src/storage/StorageManager.ts
+init_errors();
+init_logger();
 import * as crypto3 from "crypto";
 
 // src/storage/duckdb/DuckDBConnection.ts
@@ -230270,6 +230725,7 @@ class DuckDBRepository {
 }
 
 // src/storage/duckdb/schema.ts
+init_logger();
 async function initializeSchema(db, force = false) {
   const initialized = await db.isInitialized();
   if (initialized && !force) {
@@ -230398,6 +230854,8 @@ async function dropAllTables(db) {
 }
 
 // src/storage/ducklake/DuckLakeManifestStore.ts
+init_logger();
+
 class DuckLakeManifestStore {
   db;
   table;
@@ -230625,11 +231083,15 @@ class StorageManager {
 
 // src/service/environment.ts
 import { MalloyError as MalloyError3, Runtime as Runtime2 } from "@malloydata/malloy";
+init_constants();
+init_errors();
+init_logger();
 import crypto4 from "crypto";
 import * as fs6 from "fs";
 import * as path9 from "path";
 
 // src/path_safety.ts
+init_errors();
 import * as path5 from "path";
 var SAFE_NAME_RE = /^(?!\.\.?$)(?!\.)[A-Za-z0-9._-]{1,255}$/;
 var MAX_MODEL_PATH_LEN = 1024;
@@ -230684,12 +231146,12 @@ function safeJoinUnderRoot(root, ...segments) {
 // src/utils.ts
 import * as fs3 from "fs";
 import * as path6 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var URL_READER = {
   readURL: (url2) => {
     let path7 = url2.toString();
     if (url2.protocol == "file:") {
-      path7 = fileURLToPath2(url2);
+      path7 = fileURLToPath3(url2);
     }
     return fs3.promises.readFile(path7, "utf8");
   }
@@ -230699,17 +231161,27 @@ function ignoreDotfiles(file) {
 }
 
 // src/service/package.ts
+init_compile_pool();
+init_constants();
+init_errors();
+init_logger();
 var import_api3 = __toESM(require_src(), 1);
 var import_recursive_readdir = __toESM(require_recursive_readdir(), 1);
 import * as fs5 from "fs/promises";
 import * as path8 from "path";
+import { DuckDBConnection as DuckDBConnection3 } from "@malloydata/db-duckdb";
+import"@malloydata/db-duckdb/native";
 import {
+  ConnectionRuntime,
   contextOverlay as contextOverlay2,
+  EmptyURLReader,
   FixedConnectionMap as FixedConnectionMap2,
   MalloyConfig as MalloyConfig3
 } from "@malloydata/malloy";
 
 // src/service/model.ts
+init_compile_pool();
+init_constants();
 var import_api2 = __toESM(require_src(), 1);
 import {
   API,
@@ -230729,6 +231201,7 @@ import { createRequire as createRequire2 } from "module";
 import * as path7 from "path";
 
 // src/data_styles.ts
+init_logger();
 function compileDataStyles(styles) {
   try {
     return JSON.parse(styles);
@@ -230775,6 +231248,10 @@ class HackyDataStylesAccumulator {
   }
 }
 
+// src/service/model.ts
+init_errors();
+init_logger();
+
 // src/service/filter.ts
 var VALID_FILTER_TYPES = new Set([
   "equal",
@@ -230983,6 +231460,8 @@ class Model {
   dataStyles;
   modelType;
   modelMaterializer;
+  materializerBuilder;
+  materializerBuildPromise;
   modelDef;
   modelInfo;
   sources;
@@ -230992,18 +231471,20 @@ class Model {
   compilationError;
   filterMap;
   givens;
+  cachedStandardModel;
   meter = import_api2.metrics.getMeter("publisher");
   queryExecutionHistogram = this.meter.createHistogram("malloy_model_query_duration", {
     description: "How long it takes to execute a Malloy model query",
     unit: "ms"
   });
-  constructor(packageName, modelPath, dataStyles, modelType, modelMaterializer, modelDef, sources, queries, sourceInfos, runnableNotebookCells, compilationError, filterMap, givens) {
+  constructor(packageName, modelPath, dataStyles, modelType, modelMaterializer, modelDef, sources, queries, sourceInfos, runnableNotebookCells, compilationError, filterMap, givens, materializerBuilder) {
     this.packageName = packageName;
     this.modelPath = modelPath;
     this.dataStyles = dataStyles;
     this.modelType = modelType;
     this.modelDef = modelDef;
     this.modelMaterializer = modelMaterializer;
+    this.materializerBuilder = materializerBuilder;
     this.sources = sources;
     this.queries = queries;
     this.sourceInfos = sourceInfos;
@@ -231013,6 +231494,20 @@ class Model {
     this.givens = givens;
     this.modelInfo = this.modelDef ? modelDefToModelInfo(this.modelDef) : undefined;
   }
+  async ensureMaterializer() {
+    if (this.modelMaterializer)
+      return this.modelMaterializer;
+    if (!this.materializerBuilder) {
+      throw new BadRequestError("Model has no queryable entities.");
+    }
+    if (!this.materializerBuildPromise) {
+      this.materializerBuildPromise = this.materializerBuilder().then((mm) => {
+        this.modelMaterializer = mm;
+        return mm;
+      });
+    }
+    return this.materializerBuildPromise;
+  }
   getFilters(sourceName) {
     return this.filterMap.get(sourceName) ?? [];
   }
@@ -231024,6 +231519,40 @@ class Model {
     return runMatch?.[1] ?? arrowMatch?.[1];
   }
   static async create(packageName, packagePath, modelPath, malloyConfig, options) {
+    const pool = getCompilePool();
+    if (pool.enabled && modelPath.endsWith(MODEL_FILE_SUFFIX)) {
+      try {
+        return await Model.createViaWorker(packageName, packagePath, modelPath, malloyConfig, pool, options);
+      } catch (poolError) {
+        if (poolError instanceof ModelCompilationError || poolError instanceof MalloyError2) {
+          return Model.makeErrorModel(packageName, modelPath, poolError instanceof MalloyError2 ? new ModelCompilationError(poolError) : poolError);
+        }
+        logger.warn("Compile worker failed; falling back to in-process compile", { packageName, modelPath, error: poolError });
+      }
+    }
+    return Model.createInProcess(packageName, packagePath, modelPath, malloyConfig, options);
+  }
+  static async createViaWorker(packageName, packagePath, modelPath, malloyConfig, pool, options) {
+    const resolvedConfig = Model.toMalloyConfig(malloyConfig);
+    const outcome = await pool.compile({
+      packagePath,
+      modelPath,
+      malloyConfig: resolvedConfig,
+      defaultConnectionName: "duckdb",
+      urlReader: URL_READER,
+      buildManifest: options?.buildManifest
+    });
+    const materializerBuilder = async () => {
+      const { runtime, modelURL, importBaseURL } = await Model.getModelRuntime(packagePath, modelPath, malloyConfig, options);
+      return Model.getStandardModelMaterializer(runtime, importBaseURL, modelURL, modelPath);
+    };
+    return new Model(packageName, modelPath, {}, "model", undefined, outcome.modelDef, outcome.sources, outcome.queries, outcome.sourceInfos.length > 0 ? outcome.sourceInfos : undefined, undefined, undefined, outcome.filterMap, outcome.givens, materializerBuilder);
+  }
+  static makeErrorModel(packageName, modelPath, error) {
+    const isNotebook = modelPath.endsWith(NOTEBOOK_FILE_SUFFIX);
+    return new Model(packageName, modelPath, {}, isNotebook ? "notebook" : "model", undefined, undefined, undefined, undefined, undefined, undefined, error);
+  }
+  static async createInProcess(packageName, packagePath, modelPath, malloyConfig, options) {
     const { runtime, modelURL, importBaseURL, dataStyles, modelType } = await Model.getModelRuntime(packagePath, modelPath, malloyConfig, options);
     try {
       const { modelMaterializer, runnableNotebookCells } = await Model.getModelMaterializer(runtime, importBaseURL, modelURL, modelPath);
@@ -231134,8 +231663,18 @@ class Model {
       throw new BadRequestError(`Model compilation failed: ${this.compilationError.message}`);
     }
     let runnable;
-    if (!this.modelMaterializer || !this.modelDef || !this.modelInfo)
+    if (!this.modelDef || !this.modelInfo)
       throw new BadRequestError("Model has no queryable entities.");
+    let materializer;
+    try {
+      materializer = await this.ensureMaterializer();
+    } catch (error) {
+      if (error instanceof BadRequestError)
+        throw error;
+      if (error instanceof MalloyError2)
+        throw error;
+      throw new BadRequestError(error instanceof Error ? `Failed to prepare model: ${error.message}` : "Failed to prepare model.");
+    }
     try {
       let queryString;
       if (!sourceName && !queryName && query) {
@@ -231166,7 +231705,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
           }
         }
       }
-      runnable = this.modelMaterializer.loadQuery(queryString);
+      runnable = materializer.loadQuery(queryString);
     } catch (error) {
       if (error instanceof BadRequestError) {
         throw error;
@@ -231238,7 +231777,9 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
     };
   }
   getStandardModel() {
-    return {
+    if (this.cachedStandardModel)
+      return this.cachedStandardModel;
+    const compiled = {
       type: "source",
       packageName: this.packageName,
       modelPath: this.modelPath,
@@ -231251,6 +231792,8 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
       queries: this.queries,
       givens: this.givens
     };
+    this.cachedStandardModel = compiled;
+    return compiled;
   }
   async getNotebookModel() {
     const notebookCells = this.runnableNotebookCells.map((cell) => {
@@ -231576,167 +232119,6 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
   }
 }
 
-// src/service/schema_worker_pool.ts
-import { Worker } from "worker_threads";
-var DEFAULT_POOL_SIZE = 2;
-
-class SchemaWorkerPool {
-  workerUrl;
-  size;
-  workers = [];
-  queue = [];
-  inFlight = new Map;
-  workerCurrentId = new Map;
-  nextId = 1;
-  stopped = false;
-  constructor(workerUrl, size = DEFAULT_POOL_SIZE) {
-    this.workerUrl = workerUrl;
-    this.size = size;
-  }
-  start() {
-    if (this.workers.length > 0)
-      return;
-    for (let i = 0;i < this.size; i++) {
-      this.workers.push(this.spawn(i));
-    }
-    logger.info(`SchemaWorkerPool started (size=${this.size})`);
-  }
-  async stop() {
-    this.stopped = true;
-    const shutdownError = new Error("SchemaWorkerPool stopped");
-    for (const req of this.queue.splice(0))
-      req.reject(shutdownError);
-    for (const req of this.inFlight.values())
-      req.reject(shutdownError);
-    this.inFlight.clear();
-    await Promise.all(this.workers.map(async (slot) => {
-      try {
-        await slot.worker.terminate();
-      } catch {}
-    }));
-    this.workers.length = 0;
-  }
-  submit(packagePath, databasePath) {
-    if (this.stopped) {
-      return Promise.reject(new Error("SchemaWorkerPool stopped"));
-    }
-    if (this.workers.length === 0) {
-      return Promise.reject(new Error("SchemaWorkerPool.submit called before start()"));
-    }
-    return new Promise((resolve4, reject) => {
-      const req = {
-        id: this.nextId++,
-        packagePath,
-        databasePath,
-        resolve: resolve4,
-        reject
-      };
-      this.queue.push(req);
-      this.drain();
-    });
-  }
-  drain() {
-    for (let i = 0;i < this.workers.length; i++) {
-      if (this.queue.length === 0)
-        return;
-      const slot = this.workers[i];
-      if (slot.busy)
-        continue;
-      const req = this.queue.shift();
-      slot.busy = true;
-      this.inFlight.set(req.id, req);
-      this.workerCurrentId.set(i, req.id);
-      slot.worker.postMessage({
-        id: req.id,
-        packagePath: req.packagePath,
-        databasePath: req.databasePath
-      });
-    }
-  }
-  spawn(index) {
-    const worker = new Worker(this.workerUrl);
-    const slot = { worker, busy: false };
-    worker.on("message", (msg) => {
-      const req = this.inFlight.get(msg.id);
-      if (!req) {
-        logger.warn("SchemaWorkerPool: response for unknown request", {
-          id: msg.id,
-          workerIndex: index
-        });
-        return;
-      }
-      this.inFlight.delete(msg.id);
-      this.workerCurrentId.delete(index);
-      slot.busy = false;
-      if (msg.ok && msg.result) {
-        req.resolve(msg.result);
-      } else {
-        const err = new Error(msg.error?.message ?? "Unknown error");
-        if (msg.error?.stack)
-          err.stack = msg.error.stack;
-        req.reject(err);
-      }
-      this.drain();
-    });
-    worker.on("error", (err) => {
-      const inFlightId = this.workerCurrentId.get(index);
-      if (inFlightId !== undefined) {
-        const req = this.inFlight.get(inFlightId);
-        if (req) {
-          this.inFlight.delete(inFlightId);
-          req.reject(err);
-        }
-        this.workerCurrentId.delete(index);
-      }
-      logger.error("SchemaWorkerPool: worker errored, respawning", {
-        workerIndex: index,
-        error: err
-      });
-      if (!this.stopped) {
-        this.workers[index] = this.spawn(index);
-        this.drain();
-      }
-    });
-    worker.on("exit", (code) => {
-      if (this.stopped)
-        return;
-      if (code !== 0) {
-        logger.warn("SchemaWorkerPool: worker exited unexpectedly", {
-          workerIndex: index,
-          code
-        });
-        const inFlightId = this.workerCurrentId.get(index);
-        if (inFlightId !== undefined) {
-          const req = this.inFlight.get(inFlightId);
-          if (req) {
-            this.inFlight.delete(inFlightId);
-            req.reject(new Error(`SchemaWorker exited with code ${code}`));
-          }
-          this.workerCurrentId.delete(index);
-        }
-        this.workers[index] = this.spawn(index);
-        this.drain();
-      }
-    });
-    return slot;
-  }
-}
-var singleton = null;
-function getSchemaWorkerPool() {
-  if (!singleton) {
-    const url2 = resolveWorkerUrl();
-    const size = Number(process.env.PUBLISHER_SCHEMA_WORKER_POOL_SIZE) || 2;
-    singleton = new SchemaWorkerPool(url2, size);
-    singleton.start();
-  }
-  return singleton;
-}
-function resolveWorkerUrl() {
-  const base = new URL(import.meta.url);
-  const isBundled = base.pathname.endsWith(".mjs");
-  return new URL(isBundled ? "./service/schema_worker.mjs" : "./schema_worker.ts", base);
-}
-
 // src/service/package.ts
 var ENABLE_LIST_MODEL_COMPILATION = true;
 
@@ -231770,7 +232152,6 @@ class Package {
       packageName,
       duration: formatDuration(manifestValidationTime - startTime)
     });
-    let packageMalloyConfig;
     try {
       const packageConfig = await Package.readPackageConfig(packagePath);
       const packageConfigTime = performance.now();
@@ -231831,13 +232212,6 @@ class Package {
         malloy_package_name: packageName,
         status: "error"
       });
-      if (packageMalloyConfig) {
-        try {
-          await packageMalloyConfig.shutdown("close");
-        } catch (releaseError) {
-          logger.warn(`Failed to release package-local DuckDB for ${packageName}`, { error: releaseError });
-        }
-      }
       try {
         await fs5.rm(packagePath, {
           recursive: true,
@@ -231999,29 +232373,14 @@ class Package {
     };
   }
   static async readDatabases(packagePath) {
-    const databasePaths = await Package.getDatabasePaths(packagePath);
-    if (databasePaths.length === 0)
-      return [];
-    const pool = getSchemaWorkerPool();
-    const settled = await Promise.allSettled(databasePaths.map((databasePath) => pool.submit(packagePath, databasePath)));
-    const results = [];
-    for (let i = 0;i < settled.length; i++) {
-      const outcome = settled[i];
-      if (outcome.status === "fulfilled") {
-        results.push({
-          path: databasePaths[i],
-          info: outcome.value,
-          type: "embedded"
-        });
-      } else {
-        logger.warn("Schema introspection failed for database", {
-          packagePath,
-          databasePath: databasePaths[i],
-          error: outcome.reason
-        });
-      }
-    }
-    return results;
+    return await Promise.all((await Package.getDatabasePaths(packagePath)).map(async (databasePath) => {
+      const databaseInfo = await Package.getDatabaseInfo(packagePath, databasePath);
+      return {
+        path: databasePath,
+        info: databaseInfo,
+        type: "embedded"
+      };
+    }));
   }
   static async getDatabasePaths(packagePath) {
     const files = await import_recursive_readdir.default(packagePath, [ignoreDotfiles]);
@@ -232029,6 +232388,60 @@ class Package {
       return path8.relative(packagePath, fullPath).replace(/\\/g, "/");
     }).filter((modelPath) => modelPath.endsWith(".parquet") || modelPath.endsWith(".csv"));
   }
+  static async getDatabaseInfo(packagePath, databasePath) {
+    const fullPath = path8.join(packagePath, databasePath);
+    const normalizedPath = fullPath.replace(/\\/g, "/");
+    const conn = new DuckDBConnection3("duckdb");
+    const pool = getCompilePool();
+    let schema;
+    if (pool.enabled) {
+      schema = await Package.getSchemaViaPool(pool, packagePath, normalizedPath, conn);
+    } else {
+      schema = await Package.getSchemaInProcess(normalizedPath, conn);
+    }
+    const escapedPath = normalizedPath.replace(/'/g, "''");
+    const sqlResult = await conn.runSQL(`SELECT count(*)::BIGINT AS row_count FROM '${escapedPath}'`);
+    const firstRow = sqlResult.rows[0];
+    const rowCount = Number(firstRow.row_count ?? 0);
+    return { name: databasePath, rowCount, columns: schema };
+  }
+  static async getSchemaInProcess(normalizedPath, conn) {
+    const runtime = new ConnectionRuntime({
+      urlReader: new EmptyURLReader,
+      connections: [conn]
+    });
+    const model = runtime.loadModel(`source: temp is duckdb.table('${normalizedPath}')`);
+    const modelDef = await model.getModel();
+    const fields = modelDef._modelDef.contents["temp"].fields;
+    return fields.map((field) => {
+      return { type: field.type, name: field.name };
+    });
+  }
+  static async getSchemaViaPool(pool, packagePath, normalizedPath, conn) {
+    const malloyConfig = new MalloyConfig3({ connections: {} }, { config: contextOverlay2({ rootDirectory: packagePath }) });
+    malloyConfig.wrapConnections(() => ({
+      lookupConnection: async (_name) => conn
+    }));
+    try {
+      const outcome = await pool.compileInline({
+        packagePath,
+        source: `source: temp is duckdb.table('${normalizedPath}')`,
+        malloyConfig,
+        defaultConnectionName: "duckdb"
+      });
+      const modelDef = outcome.modelDef;
+      const fields = modelDef.contents["temp"].fields;
+      return fields.map((field) => {
+        return { type: field.type, name: field.name };
+      });
+    } catch (error) {
+      if (error instanceof Error && !/timed out|exited unexpectedly|shutting down/i.test(error.message)) {
+        throw error;
+      }
+      logger.warn("Compile worker failed for database probe; falling back to in-process", { normalizedPath, error: error.message });
+      return Package.getSchemaInProcess(normalizedPath, conn);
+    }
+  }
   setName(name) {
     this.packageName = name;
   }
@@ -232997,10 +233410,6 @@ class EnvironmentStore {
     return Promise.all(Array.from(this.environments.values()).map((environment) => environment.serialize()));
   }
   async getStatus() {
-    const memoryGovernorStatus = this.memoryGovernor?.getStatus() ?? null;
-    logger.info("Memory governor status", {
-      memoryGovernor: memoryGovernorStatus
-    });
     const status = {
       timestamp: Date.now(),
       environments: [],
@@ -233644,7 +234053,12 @@ class WatchModeController {
   };
 }
 
+// src/server.ts
+init_errors();
+init_logger();
+
 // src/service/resolve_environment.ts
+init_errors();
 async function resolveEnvironmentId(repository, environmentName) {
   const dbEnvironment = await repository.getEnvironmentByName(environmentName);
   if (!dbEnvironment) {
@@ -233676,6 +234090,8 @@ class ManifestController {
 }
 
 // src/controller/materialization.controller.ts
+init_errors();
+
 class MaterializationController {
   materializationService;
   constructor(materializationService) {
@@ -236362,6 +236778,12 @@ var EMPTY_COMPLETION_RESULT = {
   }
 };
 
+// src/mcp/server.ts
+init_logger();
+
+// src/mcp/prompts/prompt_service.ts
+init_logger();
+
 // src/mcp/prompts/handlers.ts
 var import_handlebars = __toESM(require_lib8(), 1);
 
@@ -236556,6 +236978,9 @@ function registerPromptCapability(mcpServer, environmentStore) {
   logger.info(`[MCP Init] Finished registering prompts. Registered: ${registeredCount}`, { duration: endTime - startTime });
 }
 
+// src/mcp/resources/environment_resource.ts
+init_logger();
+
 // src/mcp/error_messages.ts
 function getNotFoundError(resourceUriOrContext) {
   const baseMessage = `Resource not found: ${resourceUriOrContext}`;
@@ -236645,6 +237070,9 @@ function getMalloyErrorDetails(operation, modelIdentifier, error) {
 }
 
 // src/mcp/handler_utils.ts
+init_errors();
+init_logger();
+
 class McpGetResourceError extends Error {
   details;
   constructor(details) {
@@ -236857,6 +237285,7 @@ function registerEnvironmentResource(mcpServer, environmentStore) {
 }
 
 // src/mcp/resources/model_resource.ts
+init_errors();
 function registerModelResource(mcpServer, environmentStore) {
   mcpServer.resource("model", new ResourceTemplate("malloy://environment/{environmentName}/package/{packageName}/models/{modelPath}", { list: undefined }), (uri, params) => handleResourceGet(uri, params, "model", async ({
     environmentName,
@@ -236916,6 +237345,8 @@ function registerModelResource(mcpServer, environmentStore) {
 }
 
 // src/mcp/resources/notebook_resource.ts
+init_errors();
+init_logger();
 function registerNotebookResource(mcpServer, environmentStore) {
   mcpServer.resource("notebook", new ResourceTemplate("malloy://environment/{environmentName}/package/{packageName}/notebooks/{notebookName}", { list: undefined }), (uri, params) => handleResourceGet(uri, params, "notebook", async ({ environmentName, packageName, notebookName }, uri2) => {
     if (typeof environmentName !== "string" || typeof packageName !== "string" || typeof notebookName !== "string") {
@@ -236955,6 +237386,8 @@ function registerNotebookResource(mcpServer, environmentStore) {
 }
 
 // src/mcp/resources/package_resource.ts
+init_errors();
+init_logger();
 async function handleGetPackageContents(uri, params, environmentStore) {
   try {
     const { environmentName, packageName } = params;
@@ -237147,6 +237580,8 @@ function registerPackageResource(mcpServer, environmentStore) {
 }
 
 // src/mcp/resources/query_resource.ts
+init_errors();
+init_logger();
 function registerQueryResource(mcpServer, environmentStore) {
   mcpServer.resource("query", new ResourceTemplate("malloy://environment/{environmentName}/package/{packageName}/models/{modelPath}/queries/{queryName}", { list: undefined }), (uri, params) => handleResourceGet(uri, params, "query", async ({
     environmentName,
@@ -237189,6 +237624,8 @@ function registerQueryResource(mcpServer, environmentStore) {
 }
 
 // src/mcp/resources/source_resource.ts
+init_errors();
+init_logger();
 function registerSourceResource(mcpServer, environmentStore) {
   mcpServer.resource("source", new ResourceTemplate("malloy://environment/{environmentName}/package/{packageName}/models/{modelPath}/sources/{sourceName}", { list: undefined }), (uri, params) => handleResourceGet(uri, params, "source", async ({
     environmentName,
@@ -237234,6 +237671,8 @@ function registerSourceResource(mcpServer, environmentStore) {
 }
 
 // src/mcp/resources/view_resource.ts
+init_errors();
+init_logger();
 function registerViewResource(mcpServer, environmentStore) {
   mcpServer.resource("view", new ResourceTemplate("malloy://environment/{environmentName}/package/{packageName}/models/{modelPath}/sources/{sourceName}/views/{viewName}", { list: undefined }), (uri, params) => handleResourceGet(uri, params, "view", async ({
     environmentName,
@@ -237431,6 +237870,9 @@ function registerTools(mcpServer, environmentStore) {
   });
 }
 
+// src/mcp/tools/execute_query_tool.ts
+init_logger();
+
 // src/mcp/mcp_constants.ts
 var MCP_ERROR_MESSAGES = {
   MISSING_REQUIRED_PARAMS: "Either 'query' or both 'sourceName' and 'queryName' must be provided",
@@ -237637,6 +238079,8 @@ function initializeMcpServer(environmentStore) {
 }
 
 // src/server-old.ts
+init_errors();
+init_logger();
 var import_body_parser = __toESM(require_body_parser(), 1);
 var LEGACY_API_PREFIX = "/api/v0";
 function remapMaterializationResponse(mat) {
@@ -238212,6 +238656,8 @@ function registerLegacyRoutes(app, controllers) {
 }
 
 // src/service/manifest_service.ts
+init_logger();
+
 class ManifestService {
   environmentStore;
   constructor(environmentStore) {
@@ -238247,9 +238693,12 @@ class ManifestService {
 }
 
 // src/service/materialization_service.ts
+init_errors();
+init_logger();
 import { Manifest } from "@malloydata/malloy";
 
 // src/service/materialized_table_gc.ts
+init_logger();
 import {
   DatabricksDialect,
   DuckDBDialect,
@@ -238851,6 +239300,7 @@ class MaterializationService {
 }
 
 // src/service/package_memory_governor.ts
+init_logger();
 var import_api4 = __toESM(require_src(), 1);
 var DEFAULT_RSS_SAMPLER = () => process.memoryUsage().rss;
 
@@ -238951,118 +239401,6 @@ class PackageMemoryGovernor {
   }
 }
 
-// src/service/process_stats_reporter.ts
-import * as fs8 from "fs";
-var DEFAULT_INTERVAL_MS = 30000;
-function readLinuxProcStatus() {
-  try {
-    const raw = fs8.readFileSync("/proc/self/status", "utf8");
-    const out = {};
-    for (const line of raw.split(`
-`)) {
-      const [keyRaw, valueRaw] = line.split(":");
-      if (!keyRaw || !valueRaw)
-        continue;
-      const key = keyRaw.trim();
-      const value = valueRaw.trim();
-      switch (key) {
-        case "Threads":
-          out.threads = Number(value);
-          break;
-        case "VmRSS":
-          out.vmRssBytes = kBToBytes(value);
-          break;
-        case "VmSize":
-          out.vmSizeBytes = kBToBytes(value);
-          break;
-        case "VmPeak":
-          out.vmPeakBytes = kBToBytes(value);
-          break;
-        case "VmData":
-          out.vmDataBytes = kBToBytes(value);
-          break;
-        case "voluntary_ctxt_switches":
-          out.voluntaryCtxSwitches = Number(value);
-          break;
-        case "nonvoluntary_ctxt_switches":
-          out.nonvoluntaryCtxSwitches = Number(value);
-          break;
-      }
-    }
-    return out;
-  } catch {
-    return null;
-  }
-}
-function kBToBytes(value) {
-  const num = Number(value.replace(/\s*kB$/, ""));
-  if (!Number.isFinite(num))
-    return;
-  return num * 1024;
-}
-async function readBunJscStats() {
-  if (typeof globalThis.Bun === "undefined") {
-    return null;
-  }
-  try {
-    const jsc = await import("bun:jsc");
-    const heap = jsc.heapStats?.();
-    const mem = jsc.memoryUsage?.();
-    if (!heap && !mem)
-      return null;
-    return { ...heap ?? {}, ...mem ?? {} };
-  } catch {
-    return null;
-  }
-}
-
-class ProcessStatsReporter {
-  timer = null;
-  intervalMs;
-  memoryGovernor;
-  constructor(memoryGovernor, intervalMs = DEFAULT_INTERVAL_MS) {
-    this.memoryGovernor = memoryGovernor;
-    this.intervalMs = intervalMs;
-  }
-  start() {
-    if (this.timer !== null)
-      return;
-    this.tick();
-    this.timer = setInterval(() => void this.tick(), this.intervalMs);
-    this.timer.unref?.();
-    logger.info(`ProcessStatsReporter started (intervalMs=${this.intervalMs})`);
-  }
-  stop() {
-    if (this.timer !== null) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-  }
-  async tick() {
-    try {
-      const mem = process.memoryUsage();
-      const proc = process.platform === "linux" ? readLinuxProcStatus() : null;
-      const bun = await readBunJscStats();
-      const governor = this.memoryGovernor?.getStatus() ?? null;
-      logger.info("process stats", {
-        uptimeSeconds: Math.round(process.uptime()),
-        nodeMemory: {
-          rssBytes: mem.rss,
-          heapTotalBytes: mem.heapTotal,
-          heapUsedBytes: mem.heapUsed,
-          externalBytes: mem.external,
-          arrayBuffersBytes: mem.arrayBuffers
-        },
-        linux: proc,
-        bunJsc: bun,
-        memoryGovernor: governor
-      });
-    } catch (err) {
-      logger.warn("ProcessStatsReporter tick failed", { error: err });
-    }
-  }
-}
-
 // src/server.ts
 function normalizeQueryArray(value) {
   if (value === undefined || value === null)
@@ -239131,7 +239469,7 @@ var MCP_PORT = Number(process.env.MCP_PORT || 4040);
 var MCP_ENDPOINT = "/mcp";
 var SHUTDOWN_DRAIN_DURATION_SECONDS = Number(process.env.SHUTDOWN_DRAIN_DURATION_SECONDS || 0);
 var SHUTDOWN_GRACEFUL_CLOSE_TIMEOUT_SECONDS = Number(process.env.SHUTDOWN_GRACEFUL_CLOSE_TIMEOUT_SECONDS || 0);
-var __filename_esm = fileURLToPath3(import.meta.url);
+var __filename_esm = fileURLToPath4(import.meta.url);
 var ROOT = path12.join(path12.dirname(__filename_esm), "app");
 var SERVER_ROOT = path12.resolve(process.cwd(), process.env.SERVER_ROOT || ".");
 var API_PREFIX2 = "/api/v0";
@@ -239148,8 +239486,6 @@ var memoryGovernorConfig = getMemoryGovernorConfig();
 var memoryGovernor = memoryGovernorConfig ? new PackageMemoryGovernor(memoryGovernorConfig) : null;
 memoryGovernor?.start();
 environmentStore.setMemoryGovernor(memoryGovernor);
-var processStatsReporter = new ProcessStatsReporter(memoryGovernor);
-processStatsReporter.start();
 var packageController = new PackageController(environmentStore, manifestService);
 var databaseController = new DatabaseController(environmentStore);
 var queryController = new QueryController(environmentStore);