@malloy-publisher/server 0.0.198-dev3 → 0.0.198-dev6

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;
@@ -198501,6 +198713,504 @@ var require_dist12 = __commonJS((exports) => {
   exports.default = deferred;
 });
 
+// src/package_load/package_load_pool.ts
+var exports_package_load_pool = {};
+__export(exports_package_load_pool, {
+  getPackageLoadWorkerCount: () => getPackageLoadWorkerCount,
+  getPackageLoadPool: () => getPackageLoadPool,
+  deserializeError: () => deserializeError,
+  __setPackageLoadPoolForTests: () => __setPackageLoadPoolForTests,
+  PackageLoadPool: () => PackageLoadPool
+});
+import { Worker } from "node:worker_threads";
+import { dirname as dirname3, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
+function getPackageLoadWorkerCount() {
+  const raw = process.env.PACKAGE_LOAD_WORKERS;
+  if (raw === undefined)
+    return 1;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 1) {
+    throw new Error(`PACKAGE_LOAD_WORKERS must be a positive integer (got ${JSON.stringify(raw)}). ` + `Refusing to start without a package-load worker pool.`);
+  }
+  return parsed;
+}
+function resolveWorkerScript() {
+  const thisFile = fileURLToPath2(import.meta.url);
+  const thisDir = dirname3(thisFile);
+  const distCandidate = join3(thisDir, "package_load_worker.mjs");
+  if (thisFile.endsWith(".mjs") || thisFile.endsWith(".js")) {
+    return pathToFileURL(distCandidate);
+  }
+  const tsCandidate = join3(thisDir, "package_load_worker.ts");
+  return pathToFileURL(tsCandidate);
+}
+
+class PackageLoadPool {
+  workers = [];
+  queue = [];
+  jobs = new Map;
+  maxWorkers;
+  nextWorkerId = 0;
+  nextJobId = 0;
+  shuttingDown = false;
+  workerScript;
+  constructor(maxWorkers, workerScript) {
+    if (!Number.isFinite(maxWorkers) || maxWorkers < 1) {
+      throw new Error(`PackageLoadPool requires maxWorkers >= 1 (got ${maxWorkers}). ` + `The in-process compile fallback was removed in favour of a hard ` + `dependency on the worker pool; see getPackageLoadWorkerCount().`);
+    }
+    this.maxWorkers = maxWorkers;
+    this.workerScript = workerScript ?? resolveWorkerScript();
+  }
+  get size() {
+    return this.workers.filter((w) => !w.exited).length;
+  }
+  async loadPackage(request) {
+    if (this.shuttingDown) {
+      throw new Error("PackageLoadPool is shutting down");
+    }
+    return new Promise((resolve3, reject) => {
+      this.queue.push({ request, resolve: resolve3, reject });
+      this.tryDispatch();
+    });
+  }
+  async shutdown() {
+    if (this.shuttingDown)
+      return;
+    this.shuttingDown = true;
+    const queued = this.queue.splice(0, this.queue.length);
+    for (const qj of queued) {
+      qj.reject(new Error("PackageLoadPool: shutdown before dispatch"));
+    }
+    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);
+  }
+  tryDispatch() {
+    if (this.shuttingDown)
+      return;
+    while (this.queue.length > 0) {
+      const worker = this.findIdleOrSpawnable();
+      if (!worker)
+        return;
+      const qj = this.queue.shift();
+      if (!qj)
+        return;
+      this.dispatchToWorker(worker, qj);
+    }
+  }
+  findIdleOrSpawnable() {
+    const alive = this.workers.filter((w) => !w.exited);
+    const idle = alive.find((w) => w.inFlight.size === 0);
+    if (idle)
+      return idle;
+    if (alive.length < this.maxWorkers) {
+      const pw = this.spawnWorker();
+      this.workers.push(pw);
+      return pw;
+    }
+    return null;
+  }
+  async dispatchToWorker(pw, qj) {
+    try {
+      await pw.ready;
+    } catch (err) {
+      qj.reject(err);
+      this.tryDispatch();
+      return;
+    }
+    this.nextJobId += 1;
+    const jobId = `job-${this.nextJobId}`;
+    const timeout = setTimeout(() => {
+      this.handleJobTimeout(pw, jobId, qj.request.packagePath);
+    }, PACKAGE_LOAD_JOB_TIMEOUT_MS);
+    this.jobs.set(jobId, {
+      jobId,
+      pw,
+      connections: qj.request.malloyConfig.connections,
+      urlReader: qj.request.urlReader ?? defaultUrlReader,
+      resolve: (result) => {
+        clearTimeout(timeout);
+        qj.resolve(adaptResult(result));
+      },
+      reject: (err) => {
+        clearTimeout(timeout);
+        qj.reject(err);
+      },
+      timeout
+    });
+    pw.inFlight.add(jobId);
+    const message = {
+      type: "load-package",
+      requestId: jobId,
+      packagePath: qj.request.packagePath,
+      packageName: qj.request.packageName,
+      defaultConnectionName: qj.request.defaultConnectionName,
+      buildManifest: qj.request.buildManifest
+    };
+    pw.worker.postMessage(message);
+  }
+  handleJobTimeout(pw, jobId, packagePath) {
+    logger.error(`PackageLoadPool: job ${jobId} (${packagePath}) timed out after ${PACKAGE_LOAD_JOB_TIMEOUT_MS}ms; terminating worker #${pw.id}`);
+    this.failJob(jobId, new Error(`Package-load worker timed out after ${PACKAGE_LOAD_JOB_TIMEOUT_MS}ms (package=${packagePath})`));
+    pw.worker.terminate();
+  }
+  spawnWorker() {
+    this.nextWorkerId += 1;
+    const id = this.nextWorkerId;
+    logger.info(`PackageLoadPool: spawning worker #${id} (script=${this.workerScript.toString()})`);
+    const worker = new Worker(this.workerScript, {
+      name: `malloy-package-load-worker-${id}`
+    });
+    let readyResolve;
+    let readyReject;
+    let readySettled = false;
+    const ready = new Promise((resolve3, reject) => {
+      readyResolve = () => {
+        if (readySettled)
+          return;
+        readySettled = true;
+        resolve3();
+      };
+      readyReject = (err) => {
+        if (readySettled)
+          return;
+        readySettled = true;
+        reject(err);
+      };
+    });
+    ready.catch(() => {});
+    const spawnTimer = setTimeout(() => {
+      readyReject(new Error(`Package-load worker #${id} failed to become ready within ${WORKER_SPAWN_TIMEOUT_MS}ms`));
+      worker.terminate();
+    }, WORKER_SPAWN_TIMEOUT_MS);
+    const pw = {
+      id,
+      worker,
+      ready,
+      inFlight: new Set,
+      exited: false
+    };
+    worker.on("message", (msg) => {
+      this.handleWorkerMessage(pw, msg, readyResolve, spawnTimer);
+    });
+    worker.on("error", (err) => {
+      logger.error(`PackageLoadPool: worker #${id} errored`, {
+        error: err
+      });
+      clearTimeout(spawnTimer);
+      readyReject(err);
+    });
+    worker.on("exit", (code) => {
+      pw.exited = true;
+      clearTimeout(spawnTimer);
+      readyReject(new Error(`Package-load worker #${id} exited before becoming ready (code=${code})`));
+      logger.warn(`PackageLoadPool: worker #${id} exited (code=${code}, inFlight=${pw.inFlight.size})`);
+      for (const jobId of Array.from(pw.inFlight)) {
+        this.failJob(jobId, new Error(`Package-load worker #${id} exited unexpectedly (code=${code})`));
+      }
+      pw.inFlight.clear();
+      const idx = this.workers.indexOf(pw);
+      if (idx >= 0)
+        this.workers.splice(idx, 1);
+      this.tryDispatch();
+    });
+    return pw;
+  }
+  handleWorkerMessage(pw, msg, markReady, spawnTimer) {
+    switch (msg.type) {
+      case "ready":
+        clearTimeout(spawnTimer);
+        markReady();
+        return;
+      case "load-package-result":
+        this.completeJob(pw, msg);
+        return;
+      case "load-package-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;
+      }
+    }
+  }
+  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);
+    this.tryDispatch();
+  }
+  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));
+    this.tryDispatch();
+  }
+  failJob(jobId, error) {
+    const ctx = this.jobs.get(jobId);
+    if (!ctx)
+      return;
+    this.jobs.delete(jobId);
+    ctx.pw.inFlight.delete(jobId);
+    ctx.reject(error);
+  }
+  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)
+      });
+    }
+  }
+  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 {
+    packageMetadata: result.packageMetadata,
+    models: result.models.map((m) => ({
+      ...m,
+      modelDef: m.modelDef,
+      sourceInfos: m.sourceInfos
+    })),
+    loadDurationMs: result.loadDurationMs
+  };
+}
+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 getPackageLoadPool() {
+  if (singleton === null) {
+    const n = getPackageLoadWorkerCount();
+    singleton = new PackageLoadPool(n);
+    logger.info(`Malloy package-load worker pool enabled (size=${n}). Override with PACKAGE_LOAD_WORKERS=N (N >= 1).`);
+  }
+  return singleton;
+}
+async function __setPackageLoadPoolForTests(pool) {
+  if (singleton && singleton !== pool) {
+    await singleton.shutdown();
+  }
+  singleton = pool;
+}
+var PACKAGE_LOAD_JOB_TIMEOUT_MS, WORKER_SPAWN_TIMEOUT_MS = 30000, defaultUrlReader, singleton = null;
+var init_package_load_pool = __esm(() => {
+  init_errors();
+  init_logger();
+  PACKAGE_LOAD_JOB_TIMEOUT_MS = (() => {
+    const raw = process.env.PACKAGE_LOAD_JOB_TIMEOUT_MS;
+    if (raw === undefined)
+      return 120000;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+      return 120000;
+    return parsed;
+  })();
+  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) {
@@ -208467,7 +209177,7 @@ var require_util13 = __commonJS((exports) => {
     return path12;
   }
   exports.normalize = normalize2;
-  function join8(aRoot, aPath) {
+  function join9(aRoot, aPath) {
     if (aRoot === "") {
       aRoot = ".";
     }
@@ -208499,7 +209209,7 @@ var require_util13 = __commonJS((exports) => {
     }
     return joined;
   }
-  exports.join = join8;
+  exports.join = join9;
   exports.isAbsolute = function(aPath) {
     return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
   };
@@ -208672,7 +209382,7 @@ var require_util13 = __commonJS((exports) => {
           parsed.path = parsed.path.substring(0, index + 1);
         }
       }
-      sourceURL = join8(urlGenerate(parsed), sourceURL);
+      sourceURL = join9(urlGenerate(parsed), sourceURL);
     }
     return normalize2(sourceURL);
   }
@@ -211070,6 +211780,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);
@@ -211082,93 +211793,6 @@ 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() {
@@ -216311,7 +216935,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 {
@@ -216331,148 +216955,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";
@@ -219757,10 +220242,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)
@@ -221011,6 +221498,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);
@@ -221122,11 +221611,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 {
@@ -222474,6 +222965,8 @@ class DatabaseController {
 }
 
 // src/controller/model.controller.ts
+init_errors();
+
 class ModelController {
   environmentStore;
   constructor(environmentStore) {
@@ -222535,6 +223028,9 @@ class ModelController {
 }
 
 // src/controller/package.controller.ts
+init_errors();
+init_logger();
+
 class PackageController {
   environmentStore;
   manifestService;
@@ -222647,6 +223143,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") {
@@ -224250,6 +224748,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
@@ -224482,7 +224981,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() {
@@ -224513,13 +225012,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) {
@@ -224531,7 +225030,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 {
@@ -224543,7 +225042,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 {
@@ -224666,7 +225165,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 = () => {};
@@ -224694,7 +225193,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();
@@ -224719,7 +225218,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";
@@ -224731,7 +225230,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) {
@@ -224746,7 +225245,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) {
@@ -224803,7 +225302,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",
@@ -224860,7 +225359,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();
@@ -224884,7 +225383,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();
   }
@@ -224935,7 +225434,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();
@@ -224995,7 +225494,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) => {
@@ -225029,7 +225528,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 {
@@ -225096,7 +225595,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 = [];
@@ -225174,7 +225673,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();
@@ -225247,7 +225746,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 {
@@ -225345,7 +225844,7 @@ function config_default() {
   };
 }
 var GitConfigScope;
-var init_config = __esm({
+var init_config = __esm2({
   "src/lib/tasks/config.ts"() {
     init_ConfigList();
     init_utils();
@@ -225363,7 +225862,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";
@@ -225428,7 +225927,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();
@@ -225484,7 +225983,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) => {
@@ -225546,7 +226045,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 : "-");
@@ -225559,7 +226058,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();
@@ -225643,7 +226142,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();
@@ -225808,7 +226307,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 {
@@ -225859,7 +226358,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();
@@ -225873,7 +226372,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();
@@ -225899,7 +226398,7 @@ function checkout_default() {
     }
   };
 }
-var init_checkout = __esm({
+var init_checkout = __esm2({
   "src/lib/tasks/checkout.ts"() {
     init_utils();
     init_task();
@@ -225931,7 +226430,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]) => {
@@ -225957,7 +226456,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 = [
@@ -226021,7 +226520,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();
@@ -226035,7 +226534,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();
@@ -226048,7 +226547,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();
   }
@@ -226076,7 +226575,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) {
@@ -226107,7 +226606,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";
@@ -226126,13 +226625,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() {
@@ -226153,7 +226652,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();
@@ -226274,7 +226773,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();
@@ -226313,7 +226812,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();
@@ -226397,7 +226896,7 @@ function log_default() {
   }
 }
 var excludeOptions;
-var init_log = __esm({
+var init_log = __esm2({
   "src/lib/tasks/log.ts"() {
     init_log_format();
     init_pathspec();
@@ -226425,7 +226924,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) {
@@ -226460,7 +226959,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() {
@@ -226517,7 +227016,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 = [
@@ -226545,7 +227044,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();
@@ -226584,7 +227083,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();
@@ -226637,7 +227136,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();
@@ -226683,7 +227182,7 @@ function mergeTask(customArgs) {
     }
   };
 }
-var init_merge = __esm({
+var init_merge = __esm2({
   "src/lib/tasks/merge.ts"() {
     init_git_response_error();
     init_parse_merge();
@@ -226707,7 +227206,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();
@@ -226784,7 +227283,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();
@@ -226805,7 +227304,7 @@ function show_default() {
     }
   };
 }
-var init_show = __esm({
+var init_show = __esm2({
   "src/lib/tasks/show.ts"() {
     init_utils();
     init_task();
@@ -226813,7 +227312,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 {
@@ -226867,7 +227366,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();
@@ -226974,7 +227473,7 @@ function statusTask(customArgs) {
   };
 }
 var ignoredOptions;
-var init_status = __esm({
+var init_status = __esm2({
   "src/lib/tasks/status.ts"() {
     init_StatusSummary();
     ignoredOptions = ["--null", "-z"];
@@ -227023,7 +227522,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";
@@ -227042,7 +227541,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();
@@ -227133,7 +227632,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();
@@ -227186,7 +227685,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();
   }
@@ -227206,7 +227705,7 @@ function branchDeletionFailure(branch) {
   };
 }
 var BranchDeletionBatch;
-var init_BranchDeleteSummary = __esm({
+var init_BranchDeleteSummary = __esm2({
   "src/lib/responses/BranchDeleteSummary.ts"() {
     BranchDeletionBatch = class {
       constructor() {
@@ -227227,7 +227726,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();
@@ -227252,7 +227751,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() {
@@ -227285,7 +227784,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();
@@ -227370,7 +227869,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();
@@ -227379,7 +227878,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);
@@ -227397,7 +227896,7 @@ function checkIgnoreTask(paths) {
     parser: parseCheckIgnore
   };
 }
-var init_check_ignore = __esm({
+var init_check_ignore = __esm2({
   "src/lib/tasks/check-ignore.ts"() {
     init_CheckIgnore();
   }
@@ -227424,7 +227923,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();
@@ -227442,7 +227941,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 = [
@@ -227499,7 +227998,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();
@@ -227509,7 +228008,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 = [
@@ -227530,7 +228029,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();
@@ -227560,7 +228059,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();
@@ -227590,7 +228089,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();
   }
@@ -227634,7 +228133,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();
@@ -227654,7 +228153,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();
@@ -227685,7 +228184,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();
   }
@@ -227712,7 +228211,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) {
@@ -227778,7 +228277,7 @@ function addAnnotatedTagTask(name, tagMessage) {
     }
   };
 }
-var init_tag = __esm({
+var init_tag = __esm2({
   "src/lib/tasks/tag.ts"() {
     init_TagList();
   }
@@ -228454,6 +228953,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";
@@ -228711,7 +229212,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;
@@ -228767,6 +229273,11 @@ async function performGracefulShutdownAfterDrain(server, mcpServer, shutdownGrac
     await shutdownSDK();
     logger.info("OpenTelemetry SDK shut down");
   } catch (_error) {}
+  try {
+    const { getPackageLoadPool: getPackageLoadPool2 } = await Promise.resolve().then(() => (init_package_load_pool(), exports_package_load_pool));
+    await getPackageLoadPool2().shutdown();
+    logger.info("Package-load 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));
@@ -228808,7 +229319,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
@@ -229615,6 +230131,7 @@ class DuckDBRepository {
 }
 
 // src/storage/duckdb/schema.ts
+init_logger();
 async function initializeSchema(db, force = false) {
   const initialized = await db.isInitialized();
   if (initialized && !force) {
@@ -229743,6 +230260,8 @@ async function dropAllTables(db) {
 }
 
 // src/storage/ducklake/DuckLakeManifestStore.ts
+init_logger();
+
 class DuckLakeManifestStore {
   db;
   table;
@@ -229969,12 +230488,16 @@ class StorageManager {
 }
 
 // src/service/environment.ts
-import { MalloyError as MalloyError3, Runtime as Runtime2 } from "@malloydata/malloy";
+import { MalloyError as MalloyError4, 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;
@@ -230029,12 +230552,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");
   }
@@ -230044,17 +230567,27 @@ function ignoreDotfiles(file) {
 }
 
 // src/service/package.ts
+init_package_load_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"@malloydata/db-duckdb/native";
 import {
+  ConnectionRuntime,
   contextOverlay as contextOverlay2,
+  EmptyURLReader,
   FixedConnectionMap as FixedConnectionMap2,
-  MalloyConfig as MalloyConfig3
+  MalloyConfig as MalloyConfig3,
+  MalloyError as MalloyError3
 } from "@malloydata/malloy";
 
 // src/service/model.ts
+init_package_load_pool();
+init_constants();
 var import_api2 = __toESM(require_src(), 1);
 import {
   API,
@@ -230074,6 +230607,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);
@@ -230120,6 +230654,10 @@ class HackyDataStylesAccumulator {
   }
 }
 
+// src/service/model.ts
+init_errors();
+init_logger();
+
 // src/service/filter.ts
 var VALID_FILTER_TYPES = new Set([
   "equal",
@@ -230310,8 +230848,7 @@ function tokenize(input) {
   return tokens;
 }
 
-// src/service/model.ts
-var MALLOY_VERSION = createRequire2(import.meta.url)("@malloydata/malloy/package.json").version;
+// src/service/given.ts
 function malloyGivenToApi(given) {
   const type = given.type;
   const renderedType = type.type === "filter expression" ? `filter<${type.filterType}>` : type.type;
@@ -230322,6 +230859,9 @@ function malloyGivenToApi(given) {
   };
 }
 
+// src/service/model.ts
+var MALLOY_VERSION = createRequire2(import.meta.url)("@malloydata/malloy/package.json").version;
+
 class Model {
   packageName;
   modelPath;
@@ -230342,7 +230882,7 @@ class Model {
     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, modelInfo) {
     this.packageName = packageName;
     this.modelPath = modelPath;
     this.dataStyles = dataStyles;
@@ -230356,7 +230896,7 @@ class Model {
     this.compilationError = compilationError;
     this.filterMap = filterMap ?? new Map;
     this.givens = givens;
-    this.modelInfo = this.modelDef ? modelDefToModelInfo(this.modelDef) : undefined;
+    this.modelInfo = modelInfo ?? (this.modelDef ? modelDefToModelInfo(this.modelDef) : undefined);
   }
   getFilters(sourceName) {
     return this.filterMap.get(sourceName) ?? [];
@@ -230432,6 +230972,27 @@ class Model {
       return new Model(packageName, modelPath, dataStyles, modelType, undefined, undefined, undefined, undefined, undefined, undefined, computedError);
     }
   }
+  static fromSerialized(packageName, _packagePath, malloyConfig, data) {
+    const modelDef = data.modelDef;
+    const modelInfo = data.modelInfo;
+    const dataStyles = data.dataStyles ?? {};
+    const sources = data.sources;
+    const queries = data.queries;
+    const sourceInfos = data.sourceInfos;
+    const givens = data.givens;
+    const filterMap = data.filterMap ? new Map(data.filterMap) : undefined;
+    if (!modelDef) {
+      return new Model(packageName, data.modelPath, dataStyles, data.modelType, undefined, undefined, sources, queries, sourceInfos, data.modelType === "notebook" ? hydrateMarkdownOnlyCells(data.notebookCells) : undefined, undefined, filterMap, givens, modelInfo);
+    }
+    const runtime = makeHydrationRuntime(malloyConfig);
+    const modelMaterializer = runtime._loadModelFromModelDef(modelDef);
+    const runnableNotebookCells = data.modelType === "notebook" ? hydrateNotebookCells(runtime, data.notebookCells) : undefined;
+    return new Model(packageName, data.modelPath, dataStyles, data.modelType, modelMaterializer, modelDef, sources, queries, sourceInfos, runnableNotebookCells, undefined, filterMap, givens, modelInfo);
+  }
+  static fromCompilationError(packageName, modelPath, modelType, error) {
+    return new Model(packageName, modelPath, {}, modelType, undefined, undefined, undefined, undefined, undefined, undefined, error);
+  }
+  static deserializeCompilationError = deserializeError;
   getPath() {
     return this.modelPath;
   }
@@ -230590,7 +231151,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
       malloyVersion: MALLOY_VERSION,
       dataStyles: JSON.stringify(this.dataStyles),
       modelDef: JSON.stringify(this.modelDef),
-      modelInfo: JSON.stringify(this.modelDef ? modelDefToModelInfo(this.modelDef) : {}),
+      modelInfo: JSON.stringify(this.modelInfo ?? {}),
       sourceInfos: this.getSourceInfos()?.map((sourceInfo) => JSON.stringify(sourceInfo)),
       sources: this.sources,
       queries: this.queries,
@@ -230622,7 +231183,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
       packageName: this.packageName,
       modelPath: this.modelPath,
       malloyVersion: MALLOY_VERSION,
-      modelInfo: JSON.stringify(this.modelDef ? modelDefToModelInfo(this.modelDef) : {}),
+      modelInfo: JSON.stringify(this.modelInfo ?? {}),
       sources: this.modelDef && this.sources,
       queries: this.modelDef && this.queries,
       annotations: allAnnotations,
@@ -230920,166 +231481,55 @@ 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
-      });
+function makeHydrationRuntime(malloyConfig) {
+  const urlReader = new HackyDataStylesAccumulator(URL_READER);
+  const config = malloyConfig instanceof MalloyConfig2 ? malloyConfig : (() => {
+    const c = new MalloyConfig2({ connections: {} });
+    c.wrapConnections(() => new FixedConnectionMap(malloyConfig, "duckdb"));
+    return c;
+  })();
+  return new Runtime({ urlReader, config });
+}
+function hydrateNotebookCells(runtime, notebookCells) {
+  if (!notebookCells)
+    return [];
+  return notebookCells.map((sc) => {
+    if (sc.type === "markdown") {
+      return { type: "markdown", text: sc.text };
     }
-  }
-  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", {
-        workerIndex: index,
-        error: err
-      });
-    });
-    worker.on("exit", (code) => {
-      if (this.stopped)
-        return;
-      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}`));
+    const cellModelDef = sc.cellModelDef;
+    let modelMaterializer;
+    let runnable;
+    if (cellModelDef) {
+      modelMaterializer = runtime._loadModelFromModelDef(cellModelDef);
+      if (sc.cellQueryDef !== undefined) {
+        try {
+          runnable = modelMaterializer._loadQueryFromQueryDef(sc.cellQueryDef);
+        } catch (error) {
+          logger.warn("Failed to hydrate notebook cell queryDef", {
+            error
+          });
         }
-        this.workerCurrentId.delete(index);
       }
-      if (code !== 0) {
-        logger.warn("SchemaWorkerPool: worker exited unexpectedly", {
-          workerIndex: index,
-          code
-        });
-      } else {
-        logger.info("SchemaWorkerPool: worker exited cleanly, respawning", {
-          workerIndex: 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;
+    }
+    return {
+      type: "code",
+      text: sc.text,
+      runnable,
+      modelMaterializer,
+      newSources: sc.newSources,
+      queryInfo: sc.queryInfo
+    };
+  });
 }
-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);
+function hydrateMarkdownOnlyCells(notebookCells) {
+  if (!notebookCells)
+    return;
+  return notebookCells.map((sc) => {
+    if (sc.type === "markdown")
+      return { type: "markdown", text: sc.text };
+    return { type: "code", text: sc.text };
+  });
 }
 
 // src/service/package.ts
@@ -231115,74 +231565,19 @@ class Package {
       packageName,
       duration: formatDuration(manifestValidationTime - startTime)
     });
-    let packageMalloyConfig;
     try {
-      const packageConfig = await Package.readPackageConfig(packagePath);
-      const packageConfigTime = performance.now();
-      logger.info("Package config read completed", {
-        packageName,
-        duration: formatDuration(packageConfigTime - manifestValidationTime)
-      });
-      packageConfig.resource = `${API_PREFIX}/environments/${environmentName}/packages/${packageName}`;
-      const databases = await Package.readDatabases(packagePath);
-      const databasesTime = performance.now();
-      logger.info("Databases read completed", {
-        packageName,
-        databaseCount: databases.length,
-        duration: formatDuration(databasesTime - packageConfigTime)
-      });
       const malloyConfig = Package.buildPackageMalloyConfig(packagePath, typeof environmentMalloyConfig === "function" ? environmentMalloyConfig : () => Package.toMalloyConfig(environmentMalloyConfig));
-      const models = await Package.loadModels(packageName, packagePath, malloyConfig);
-      const modelsTime = performance.now();
-      logger.info("Models loaded", {
-        packageName,
-        modelCount: models.size,
-        duration: formatDuration(modelsTime - databasesTime)
-      });
-      for (const [modelPath, model] of models.entries()) {
-        const maybeModel = model;
-        if (maybeModel.compilationError) {
-          const err = maybeModel.compilationError;
-          const message = err instanceof Error ? err.message : `Unknown compilation error in ${modelPath}`;
-          logger.error("Model compilation failed", {
-            packageName,
-            modelPath,
-            error: message
-          });
-          this.packageLoadHistogram.record(performance.now() - startTime, {
-            malloy_package_name: packageName,
-            status: "compilation_error"
-          });
-          throw err;
-        }
-      }
-      const endTime = performance.now();
-      const executionTime = endTime - startTime;
-      this.packageLoadHistogram.record(executionTime, {
-        malloy_package_name: packageName,
-        status: "success"
-      });
-      logger.info(`Successfully loaded package ${packageName}`, {
-        packageName,
-        duration: formatDuration(executionTime)
-      });
-      return new Package(environmentName, packageName, packagePath, packageConfig, databases, models, malloyConfig);
+      return await Package.loadViaWorker(environmentName, packageName, packagePath, malloyConfig, startTime, manifestValidationTime);
     } catch (error) {
       logger.error(`Error loading package ${packageName}`, { error });
       console.error(error);
       const endTime = performance.now();
       const executionTime = endTime - startTime;
+      const status = error instanceof ModelCompilationError || error instanceof MalloyError3 ? "compilation_error" : error instanceof ServiceUnavailableError ? "pool_unavailable" : "error";
       this.packageLoadHistogram.record(executionTime, {
         malloy_package_name: packageName,
-        status: "error"
+        status
       });
-      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,
@@ -231197,6 +231592,64 @@ class Package {
       throw error;
     }
   }
+  static async loadViaWorker(environmentName, packageName, packagePath, malloyConfig, startTime, manifestValidationTime) {
+    const pool = getPackageLoadPool();
+    const dispatchTime = performance.now();
+    const workerOutcome = pool.loadPackage({
+      packagePath,
+      packageName,
+      malloyConfig,
+      defaultConnectionName: "duckdb"
+    }).catch((err) => {
+      const realError = err instanceof Error ? err : new Error(`Package-load worker pool failure: ${String(err)}`);
+      if (realError instanceof MalloyError3 || realError instanceof ModelCompilationError) {
+        throw realError;
+      }
+      throw new ServiceUnavailableError(`Package-load worker pool unavailable: ${realError.message}`);
+    });
+    const [outcome, databases] = await Promise.all([
+      workerOutcome,
+      Package.readDatabases(packagePath, malloyConfig)
+    ]);
+    const workerDoneTime = performance.now();
+    logger.info("Package load via worker pool completed", {
+      packageName,
+      manifestValidationMs: dispatchTime - manifestValidationTime,
+      workerDurationMs: outcome.loadDurationMs,
+      dispatchOverheadMs: workerDoneTime - dispatchTime - outcome.loadDurationMs,
+      modelCount: outcome.models.length,
+      databaseCount: databases.length
+    });
+    const packageConfig = {
+      name: outcome.packageMetadata.name,
+      description: outcome.packageMetadata.description,
+      resource: `${API_PREFIX}/environments/${environmentName}/packages/${packageName}`
+    };
+    const models = new Map;
+    for (const sm of outcome.models) {
+      if (sm.compilationError) {
+        const err = Model.deserializeCompilationError(sm.compilationError);
+        logger.error("Model compilation failed", {
+          packageName,
+          modelPath: sm.modelPath,
+          error: err.message
+        });
+        throw err;
+      }
+      models.set(sm.modelPath, Model.fromSerialized(packageName, packagePath, malloyConfig, sm));
+    }
+    const endTime = performance.now();
+    const executionTime = endTime - startTime;
+    this.packageLoadHistogram.record(executionTime, {
+      malloy_package_name: packageName,
+      status: "success"
+    });
+    logger.info(`Successfully loaded package ${packageName}`, {
+      packageName,
+      duration: formatDuration(executionTime)
+    });
+    return new Package(environmentName, packageName, packagePath, packageConfig, databases, models, malloyConfig);
+  }
   getPackageName() {
     return this.packageName;
   }
@@ -231228,10 +231681,36 @@ class Package {
       modelCount: modelPaths.length,
       manifestEntryCount: Object.keys(buildManifest).length
     });
-    const reloaded = await Promise.all(modelPaths.map((modelPath) => Model.create(this.packageName, this.packagePath, modelPath, this.malloyConfig, { buildManifest })));
+    const pool = getPackageLoadPool();
+    let outcome;
+    try {
+      outcome = await pool.loadPackage({
+        packagePath: this.packagePath,
+        packageName: this.packageName,
+        malloyConfig: this.malloyConfig,
+        defaultConnectionName: "duckdb",
+        buildManifest
+      });
+    } catch (err) {
+      const realError = err instanceof Error ? err : new Error(`Package-load worker pool failure: ${String(err)}`);
+      if (realError instanceof MalloyError3 || realError instanceof ModelCompilationError) {
+        throw realError;
+      }
+      throw new ServiceUnavailableError(`Package-load worker pool unavailable: ${realError.message}`);
+    }
     const nextModels = new Map;
-    for (const model of reloaded) {
-      nextModels.set(model.getPath(), model);
+    for (const sm of outcome.models) {
+      if (sm.compilationError) {
+        const err = Model.deserializeCompilationError(sm.compilationError);
+        logger.warn("Model compilation failed during reload", {
+          packageName: this.packageName,
+          modelPath: sm.modelPath,
+          error: err.message
+        });
+        nextModels.set(sm.modelPath, Model.fromCompilationError(this.packageName, sm.modelPath, sm.modelType, err));
+      } else {
+        nextModels.set(sm.modelPath, Model.fromSerialized(this.packageName, this.packagePath, this.malloyConfig, sm));
+      }
     }
     this.models = nextModels;
   }
@@ -231279,11 +231758,6 @@ class Package {
       };
     }));
   }
-  static async loadModels(packageName, packagePath, malloyConfig) {
-    const modelPaths = await Package.getModelPaths(packagePath);
-    const models = await Promise.all(modelPaths.map((modelPath) => Model.create(packageName, packagePath, modelPath, malloyConfig)));
-    return new Map(models.map((model) => [model.getPath(), model]));
-  }
   static buildPackageMalloyConfig(packagePath, getEnvironmentMalloyConfig) {
     const malloyConfig = new MalloyConfig3({
       connections: {
@@ -231313,18 +231787,6 @@ class Package {
     malloyConfig.wrapConnections(() => new FixedConnectionMap2(input, "duckdb"));
     return malloyConfig;
   }
-  static async getModelPaths(packagePath) {
-    let files = undefined;
-    try {
-      files = await import_recursive_readdir.default(packagePath, [ignoreDotfiles]);
-    } catch (error) {
-      logger.error(error);
-      throw new PackageNotFoundError(`Package config for ${packagePath} does not exist.`);
-    }
-    return files.map((fullPath) => {
-      return path8.relative(packagePath, fullPath).replace(/\\/g, "/");
-    }).filter((modelPath) => modelPath.endsWith(MODEL_FILE_SUFFIX) || modelPath.endsWith(NOTEBOOK_FILE_SUFFIX));
-  }
   static async validatePackageManifestExistsOrThrowError(packagePath) {
     const packageConfigPath = path8.join(packagePath, PACKAGE_MANIFEST_NAME);
     try {
@@ -231334,39 +231796,17 @@ class Package {
       throw new PackageNotFoundError(`Package manifest for ${packagePath} does not exist.`);
     }
   }
-  static async readPackageConfig(packagePath) {
-    const packageConfigPath = path8.join(packagePath, PACKAGE_MANIFEST_NAME);
-    const packageConfigContents = await fs5.readFile(packageConfigPath);
-    const packageManifest = JSON.parse(packageConfigContents.toString());
-    return {
-      name: packageManifest.name,
-      description: packageManifest.description
-    };
-  }
-  static async readDatabases(packagePath) {
+  static async readDatabases(packagePath, malloyConfig) {
     const databasePaths = await Package.getDatabasePaths(packagePath);
-    if (databasePaths.length === 0)
+    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;
+    const conn = await malloyConfig.connections.lookupConnection("duckdb");
+    return await Promise.all(databasePaths.map(async (databasePath) => ({
+      path: databasePath,
+      info: await Package.getDatabaseInfo(packagePath, databasePath, conn),
+      type: "embedded"
+    })));
   }
   static async getDatabasePaths(packagePath) {
     const files = await import_recursive_readdir.default(packagePath, [ignoreDotfiles]);
@@ -231374,6 +231814,24 @@ class Package {
       return path8.relative(packagePath, fullPath).replace(/\\/g, "/");
     }).filter((modelPath) => modelPath.endsWith(".parquet") || modelPath.endsWith(".csv"));
   }
+  static async getDatabaseInfo(packagePath, databasePath, conn) {
+    const fullPath = path8.join(packagePath, databasePath);
+    const runtime = new ConnectionRuntime({
+      urlReader: new EmptyURLReader,
+      connections: [conn]
+    });
+    const normalizedPath = fullPath.replace(/\\/g, "/");
+    const model = runtime.loadModel(`source: temp is duckdb.table('${normalizedPath}')`);
+    const modelDef = await model.getModel();
+    const fields = modelDef._modelDef.contents["temp"].fields;
+    const schema = fields.map((field) => {
+      return { type: field.type, name: field.name };
+    });
+    const runner = model.loadQuery("run: temp->{aggregate: row_count is count()}");
+    const result = await runner.run();
+    const rowCount = result.data.value[0].row_count?.valueOf();
+    return { name: databasePath, rowCount, columns: schema };
+  }
   setName(name) {
     this.packageName = name;
   }
@@ -231515,7 +231973,7 @@ ${source}` : source;
         }
         return { problems: model.problems, sql };
       } catch (error) {
-        if (error instanceof MalloyError3) {
+        if (error instanceof MalloyError4) {
           return { problems: error.problems };
         }
         throw error;
@@ -232342,10 +232800,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: [],
@@ -232999,7 +233453,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) {
@@ -233031,6 +233490,8 @@ class ManifestController {
 }
 
 // src/controller/materialization.controller.ts
+init_errors();
+
 class MaterializationController {
   materializationService;
   constructor(materializationService) {
@@ -235717,6 +236178,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);
 
@@ -235911,6 +236378,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}`;
@@ -236000,6 +236470,9 @@ function getMalloyErrorDetails(operation, modelIdentifier, error) {
 }
 
 // src/mcp/handler_utils.ts
+init_errors();
+init_logger();
+
 class McpGetResourceError extends Error {
   details;
   constructor(details) {
@@ -236212,6 +236685,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,
@@ -236271,6 +236745,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") {
@@ -236310,6 +236786,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;
@@ -236502,6 +236980,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,
@@ -236544,6 +237024,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,
@@ -236589,6 +237071,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,
@@ -236786,6 +237270,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",
@@ -236992,6 +237479,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) {
@@ -237567,6 +238056,8 @@ function registerLegacyRoutes(app, controllers) {
 }
 
 // src/service/manifest_service.ts
+init_logger();
+
 class ManifestService {
   environmentStore;
   constructor(environmentStore) {
@@ -237602,9 +238093,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,
@@ -238206,6 +238700,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;
 
@@ -238306,118 +238801,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)
@@ -238486,7 +238869,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";
@@ -238503,8 +238886,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);
@@ -239200,6 +239581,10 @@ app.use((err, _req, res, _next) => {
   const { json, status } = internalErrorToHttpError(err);
   res.status(status).json(json);
 });
+{
+  const { getPackageLoadPool: getPackageLoadPool2 } = await Promise.resolve().then(() => (init_package_load_pool(), exports_package_load_pool));
+  getPackageLoadPool2();
+}
 var mainServer = http2.createServer({ maxHeaderSize: 262144 }, app);
 mainServer.timeout = 600000;
 mainServer.keepAliveTimeout = 600000;