@malloy-publisher/server 0.0.209 → 0.0.210

package/dist/server.mjs

@@ -237892,7 +237892,6 @@ import {
 init_logger();
 
 // src/service/model.ts
-init_package_load_pool();
 var import_api5 = __toESM(require_src(), 1);
 import {
   Annotations as Annotations2,
@@ -237963,6 +237962,150 @@ class HackyDataStylesAccumulator {
 // src/service/model.ts
 init_errors();
 init_logger();
+init_package_load_pool();
+
+// src/service/annotations.ts
+import { Annotations } from "@malloydata/malloy";
+function isReservedRoute(route) {
+  return route === "" || !/[\p{L}\p{N}]/u.test(route);
+}
+function modelAnnotations(modelDef) {
+  const registry = modelDef.modelAnnotations ?? {};
+  const visited = new Set;
+  const order = [];
+  const visit = (id) => {
+    if (visited.has(id))
+      return;
+    visited.add(id);
+    const entry = registry[id];
+    if (!entry)
+      return;
+    for (const dep of entry.inheritsFrom)
+      visit(dep);
+    order.push(id);
+  };
+  visit(modelDef.modelID);
+  let folded;
+  for (const id of order) {
+    const own = registry[id].ownNotes;
+    if (!own.notes?.length && !own.blockNotes?.length)
+      continue;
+    folded = {
+      notes: own.notes,
+      blockNotes: own.blockNotes,
+      inherits: folded
+    };
+  }
+  return folded ?? {};
+}
+function annotationTexts(annote) {
+  const texts = new Annotations(annote).texts();
+  return texts.length > 0 ? texts : undefined;
+}
+
+// src/service/authorize.ts
+init_errors();
+var SOURCE_PREFIX = "#(authorize)";
+var FILE_PREFIX = "##(authorize)";
+function buildAuthorizeProbe(exprs) {
+  const selects = exprs.map((expr, i) => `__auth_${i} is (${expr})`).join(`
+      `);
+  return `run: duckdb.sql("SELECT 1 AS __authorize_probe_row") -> {
+    select:
+      ${selects}
+    limit: 1
+  }`;
+}
+function isProbeTrue(cell) {
+  return cell === true || cell === 1 || cell === "true";
+}
+async function evaluateAuthorize(executor, exprs, givens) {
+  for (const expr of exprs) {
+    try {
+      const result = await executor.loadQuery(buildAuthorizeProbe([expr])).run({ rowLimit: 1, givens });
+      const row = result?.data?.value?.[0];
+      if (row && isProbeTrue(row.__auth_0)) {
+        return true;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+async function validateAuthorizeProbes(compiler, sources) {
+  for (const source of sources) {
+    const exprs = source.authorize;
+    if (!exprs || exprs.length === 0)
+      continue;
+    try {
+      await compiler.loadQuery(buildAuthorizeProbe(exprs)).getPreparedQuery();
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new ModelCompilationError({
+        message: `Invalid #(authorize) annotation on source "${source.name ?? "(unnamed)"}" [${exprs.join(" | ")}]: ${detail}`
+      });
+    }
+  }
+}
+function parseAuthorizeAnnotation(annotation) {
+  const trimmed2 = annotation.trim();
+  let body;
+  if (trimmed2.startsWith(FILE_PREFIX)) {
+    body = trimmed2.slice(FILE_PREFIX.length).trim();
+  } else if (trimmed2.startsWith(SOURCE_PREFIX)) {
+    body = trimmed2.slice(SOURCE_PREFIX.length).trim();
+  } else {
+    return null;
+  }
+  return unwrapQuotedExpression(body);
+}
+function collectAuthorizeExprs(annotations) {
+  const exprs = [];
+  for (const annotation of annotations) {
+    const expr = parseAuthorizeAnnotation(annotation);
+    if (expr !== null) {
+      exprs.push(expr);
+    }
+  }
+  return exprs;
+}
+function unwrapQuotedExpression(body) {
+  if (body.length < 2 || body[0] !== '"') {
+    throw new Error(`authorize annotation expression must be a double-quoted string, got: ${body || "(empty)"}`);
+  }
+  let expr = "";
+  let i = 1;
+  let closed = false;
+  for (;i < body.length; i++) {
+    const ch = body[i];
+    if (ch === "\\" && i + 1 < body.length) {
+      const next = body[i + 1];
+      if (next === '"' || next === "\\") {
+        expr += next;
+        i++;
+        continue;
+      }
+    }
+    if (ch === '"') {
+      closed = true;
+      i++;
+      break;
+    }
+    expr += ch;
+  }
+  if (!closed) {
+    throw new Error(`authorize annotation has mismatched quotes: ${body}`);
+  }
+  const rest = body.slice(i).trim();
+  if (rest.length > 0) {
+    throw new Error(`authorize annotation has unexpected content after the expression: ${rest}`);
+  }
+  if (expr.trim().length === 0) {
+    throw new Error("authorize annotation has an empty expression body");
+  }
+  return expr;
+}
 
 // src/service/filter.ts
 var VALID_FILTER_TYPES = new Set([
@@ -238155,149 +238298,6 @@ function tokenize(input) {
   return tokens;
 }
 
-// src/service/authorize.ts
-init_errors();
-var SOURCE_PREFIX = "#(authorize)";
-var FILE_PREFIX = "##(authorize)";
-function buildAuthorizeProbe(exprs) {
-  const selects = exprs.map((expr, i) => `__auth_${i} is (${expr})`).join(`
-      `);
-  return `run: duckdb.sql("SELECT 1 AS __authorize_probe_row") -> {
-    select:
-      ${selects}
-    limit: 1
-  }`;
-}
-function isProbeTrue(cell) {
-  return cell === true || cell === 1 || cell === "true";
-}
-async function evaluateAuthorize(executor, exprs, givens) {
-  for (const expr of exprs) {
-    try {
-      const result = await executor.loadQuery(buildAuthorizeProbe([expr])).run({ rowLimit: 1, givens });
-      const row = result?.data?.value?.[0];
-      if (row && isProbeTrue(row.__auth_0)) {
-        return true;
-      }
-    } catch {
-      continue;
-    }
-  }
-  return false;
-}
-async function validateAuthorizeProbes(compiler, sources) {
-  for (const source of sources) {
-    const exprs = source.authorize;
-    if (!exprs || exprs.length === 0)
-      continue;
-    try {
-      await compiler.loadQuery(buildAuthorizeProbe(exprs)).getPreparedQuery();
-    } catch (err) {
-      const detail = err instanceof Error ? err.message : String(err);
-      throw new ModelCompilationError({
-        message: `Invalid #(authorize) annotation on source "${source.name ?? "(unnamed)"}" [${exprs.join(" | ")}]: ${detail}`
-      });
-    }
-  }
-}
-function parseAuthorizeAnnotation(annotation) {
-  const trimmed2 = annotation.trim();
-  let body;
-  if (trimmed2.startsWith(FILE_PREFIX)) {
-    body = trimmed2.slice(FILE_PREFIX.length).trim();
-  } else if (trimmed2.startsWith(SOURCE_PREFIX)) {
-    body = trimmed2.slice(SOURCE_PREFIX.length).trim();
-  } else {
-    return null;
-  }
-  return unwrapQuotedExpression(body);
-}
-function collectAuthorizeExprs(annotations) {
-  const exprs = [];
-  for (const annotation of annotations) {
-    const expr = parseAuthorizeAnnotation(annotation);
-    if (expr !== null) {
-      exprs.push(expr);
-    }
-  }
-  return exprs;
-}
-function unwrapQuotedExpression(body) {
-  if (body.length < 2 || body[0] !== '"') {
-    throw new Error(`authorize annotation expression must be a double-quoted string, got: ${body || "(empty)"}`);
-  }
-  let expr = "";
-  let i = 1;
-  let closed = false;
-  for (;i < body.length; i++) {
-    const ch = body[i];
-    if (ch === "\\" && i + 1 < body.length) {
-      const next = body[i + 1];
-      if (next === '"' || next === "\\") {
-        expr += next;
-        i++;
-        continue;
-      }
-    }
-    if (ch === '"') {
-      closed = true;
-      i++;
-      break;
-    }
-    expr += ch;
-  }
-  if (!closed) {
-    throw new Error(`authorize annotation has mismatched quotes: ${body}`);
-  }
-  const rest = body.slice(i).trim();
-  if (rest.length > 0) {
-    throw new Error(`authorize annotation has unexpected content after the expression: ${rest}`);
-  }
-  if (expr.trim().length === 0) {
-    throw new Error("authorize annotation has an empty expression body");
-  }
-  return expr;
-}
-
-// src/service/annotations.ts
-import { Annotations } from "@malloydata/malloy";
-function isReservedRoute(route) {
-  return route === "" || !/[\p{L}\p{N}]/u.test(route);
-}
-function modelAnnotations(modelDef) {
-  const registry = modelDef.modelAnnotations ?? {};
-  const visited = new Set;
-  const order = [];
-  const visit = (id) => {
-    if (visited.has(id))
-      return;
-    visited.add(id);
-    const entry = registry[id];
-    if (!entry)
-      return;
-    for (const dep of entry.inheritsFrom)
-      visit(dep);
-    order.push(id);
-  };
-  visit(modelDef.modelID);
-  let folded;
-  for (const id of order) {
-    const own = registry[id].ownNotes;
-    if (!own.notes?.length && !own.blockNotes?.length)
-      continue;
-    folded = {
-      notes: own.notes,
-      blockNotes: own.blockNotes,
-      inherits: folded
-    };
-  }
-  return folded ?? {};
-}
-function annotationTexts(annote) {
-  const texts = new Annotations(annote).texts();
-  return texts.length > 0 ? texts : undefined;
-}
-
 // src/service/given.ts
 function malloyGivenToApi(given) {
   const type = given.type;
@@ -238310,6 +238310,25 @@ function malloyGivenToApi(given) {
   };
 }
 
+// src/service/model_limits.ts
+init_errors();
+function resolveModelQueryRowLimit(userLimit, { defaultLimit, maxRows }) {
+  const requested = userLimit && userLimit > 0 ? userLimit : defaultLimit;
+  if (maxRows <= 0)
+    return requested;
+  return Math.min(requested, maxRows + 1);
+}
+function assertWithinModelResponseLimits(rowCount, serializedBytes, { maxRows, maxBytes }, source) {
+  if (maxRows > 0 && rowCount > maxRows) {
+    recordQueryCapExceeded("rows", source);
+    throw new PayloadTooLargeError(`Query returned more than ${maxRows} rows. Refine the query (add a LIMIT or more selective WHERE) or raise PUBLISHER_MAX_QUERY_ROWS.`);
+  }
+  if (maxBytes > 0 && serializedBytes > maxBytes) {
+    recordQueryCapExceeded("bytes", source);
+    throw new PayloadTooLargeError(`Query response exceeded ${maxBytes} bytes (was ${serializedBytes}). Project fewer columns, add a LIMIT, or raise PUBLISHER_MAX_RESPONSE_BYTES.`);
+  }
+}
+
 // src/service/source_extraction.ts
 import {
   isSourceDef
@@ -238388,25 +238407,6 @@ function extractQueriesFromModelDef(modelDef) {
   }));
 }
 
-// src/service/model_limits.ts
-init_errors();
-function resolveModelQueryRowLimit(userLimit, { defaultLimit, maxRows }) {
-  const requested = userLimit && userLimit > 0 ? userLimit : defaultLimit;
-  if (maxRows <= 0)
-    return requested;
-  return Math.min(requested, maxRows + 1);
-}
-function assertWithinModelResponseLimits(rowCount, serializedBytes, { maxRows, maxBytes }, source) {
-  if (maxRows > 0 && rowCount > maxRows) {
-    recordQueryCapExceeded("rows", source);
-    throw new PayloadTooLargeError(`Query returned more than ${maxRows} rows. Refine the query (add a LIMIT or more selective WHERE) or raise PUBLISHER_MAX_QUERY_ROWS.`);
-  }
-  if (maxBytes > 0 && serializedBytes > maxBytes) {
-    recordQueryCapExceeded("bytes", source);
-    throw new PayloadTooLargeError(`Query response exceeded ${maxBytes} bytes (was ${serializedBytes}). Project fewer columns, add a LIMIT, or raise PUBLISHER_MAX_RESPONSE_BYTES.`);
-  }
-}
-
 // src/service/model.ts
 var MALLOY_VERSION = createRequire2(import.meta.url)("@malloydata/malloy/package.json").version;
 function quoteMalloyIdentifier(name) {
@@ -238788,9 +238788,7 @@ class Model {
       }
       const errors2 = validateRenderTags2(result).filter((log) => log.severity === "error");
       if (errors2.length > 0) {
-        throw new ModelCompilationError({
-          message: `Invalid renderer configuration on '${target.label}': ${errors2.map((e) => e.message).join("; ")}`
-        });
+        logger.warn(`Invalid renderer configuration on '${target.label}': ${errors2.map((e) => e.message).join("; ")}`);
       }
     }
   }

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "@malloy-publisher/server",
    "description": "Malloy Publisher Server",
-   "version": "0.0.209",
+   "version": "0.0.210",
    "main": "dist/server.mjs",
    "bin": {
       "malloy-publisher": "dist/server.mjs"

package/src/service/model.ts

@@ -25,11 +25,6 @@ import * as fs from "fs/promises";
 import { createRequire } from "module";
 import * as path from "path";
 import { components } from "../api";
-import { deserializeError } from "../package_load/package_load_pool";
-import type {
-   SerializedModel,
-   SerializedNotebookCell,
-} from "../package_load/protocol";
 import {
    getDefaultQueryRowLimit,
    getMaxQueryRows,
@@ -46,8 +41,19 @@ import {
    PayloadTooLargeError,
 } from "../errors";
 import { logger } from "../logger";
+import { deserializeError } from "../package_load/package_load_pool";
+import type {
+   SerializedModel,
+   SerializedNotebookCell,
+} from "../package_load/protocol";
 import { BuildManifest } from "../storage/DatabaseInterface";
 import { URL_READER } from "../utils";
+import { modelAnnotations } from "./annotations";
+import {
+   collectAuthorizeExprs,
+   evaluateAuthorize,
+   validateAuthorizeProbes,
+} from "./authorize";
 import {
    buildFilterClause,
    FilterValidationError,
@@ -55,21 +61,15 @@ import {
    type FilterDefinition,
    type FilterParams,
 } from "./filter";
-import {
-   collectAuthorizeExprs,
-   evaluateAuthorize,
-   validateAuthorizeProbes,
-} from "./authorize";
-import { modelAnnotations } from "./annotations";
 import { malloyGivenToApi, type MalloyGiven } from "./given";
-import {
-   extractQueriesFromModelDef,
-   extractSourcesFromModelDef,
-} from "./source_extraction";
 import {
    assertWithinModelResponseLimits,
    resolveModelQueryRowLimit,
 } from "./model_limits";
+import {
+   extractQueriesFromModelDef,
+   extractSourcesFromModelDef,
+} from "./source_extraction";
 
 type ApiCompiledModel = components["schemas"]["CompiledModel"];
 type ApiNotebookCell = components["schemas"]["NotebookCell"];
@@ -980,13 +980,13 @@ export class Model {
     * annotated source view (`run: <source> -> <view>`) compile-only -- no
     * execution -- to get a stable result schema, then runs the renderer's
     * headless `validateRenderTags`. Targets with no annotations carry no render
-    * tags, so they are skipped without compiling. Any
-    * error-severity finding throws a `ModelCompilationError` (HTTP 424) so a
-    * misconfigured tag (e.g. a child-only `# big_value { sparkline=... }` placed
-    * on a view with no activating big_value) fails the package load with a clear
-    * message instead of rendering as "[object Object]" at query time. Warnings
-    * (e.g. unread tags) are left for the query-time `renderLogs` surface so a
-    * benign render lint never blocks a load.
+    * tags, so they are skipped without compiling. Any error-severity finding
+    * (e.g. a child-only `# big_value { sparkline=... }` placed on a view with no
+    * activating big_value) is logged as a warning naming the offending target;
+    * it does not fail the package load. Such a tag still renders as
+    * "[object Object]" at query time, so the warning is the operator-facing
+    * signal. Lower-severity findings are left for the query-time `renderLogs`
+    * surface.
     */
    public async validateRenderTags(): Promise<void> {
       const mm = this.modelMaterializer;
@@ -1053,11 +1053,11 @@ export class Model {
             (log) => log.severity === "error",
          );
          if (errors.length > 0) {
-            throw new ModelCompilationError({
-               message: `Invalid renderer configuration on '${target.label}': ${errors
+            logger.warn(
+               `Invalid renderer configuration on '${target.label}': ${errors
                   .map((e) => e.message)
                   .join("; ")}`,
-            });
+            );
          }
       }
    }

package/src/service/package.ts

@@ -359,8 +359,7 @@ export class Package {
          );
          // Validate renderer tags on the main thread (the renderer is too heavy
          // to load inside the pure-CPU package-load worker). A misconfigured tag
-         // throws a ModelCompilationError (424), aborting the whole load like any
-         // other per-model compile error above.
+         // is logged as a warning naming the target; it does not fail the load.
          await model.validateRenderTags();
          models.set(sm.modelPath, model);
       }
@@ -709,9 +708,10 @@ export class Package {
                { buildManifest },
             );
             // Validate renderer tags here too (loadViaWorker does it for the
-            // create path). Reload keeps per-model placeholders rather than
-            // aborting the whole package, so a render-tag error is recorded as
-            // this model's compilationError instead of thrown.
+            // create path). Render-tag findings are logged as warnings inside
+            // validateRenderTags and never throw. The catch is defensive: an
+            // unexpected internal failure is recorded as this model's
+            // compilationError rather than aborting the whole reload.
             try {
                await model.validateRenderTags();
                nextModels.set(sm.modelPath, model);

package/src/service/package_worker_path.spec.ts

@@ -28,10 +28,12 @@ import {
    describe,
    expect,
    it,
+   spyOn,
 } from "bun:test";
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
+import { logger } from "../logger";
 import {
    PackageLoadPool,
    __setPackageLoadPoolForTests,
@@ -280,14 +282,13 @@ source: gated is duckdb.sql("select 1 as id")`,
       }
    });
 
-   it("rejects a package whose view carries an invalid renderer tag", async () => {
+   it("logs a warning for a package whose view carries an invalid renderer tag", async () => {
       writeManifest();
       // `# big_value { sparkline=... }` is a child-only renderer config placed on
       // the view itself, with no activating big_value. The renderer declines to
-      // match it; without compile-time validation it renders as "[object Object]"
-      // at query time. Render-tag validation runs on the main thread after the
-      // worker hydrates the model, so the load must reject with a 424
-      // ModelCompilationError naming the offending view.
+      // match it. Render-tag validation runs on the main thread after the worker
+      // hydrates the model. The misconfiguration is logged as a warning naming
+      // the offending view; it does not fail the package load.
       fs.writeFileSync(
          path.join(tempDir, "bad_render.malloy"),
          `source: nums is duckdb.sql("select 1 as a, 2 as b") extend {
@@ -302,21 +303,21 @@ source: gated is duckdb.sql("select 1 as id")`,
 }`,
       );
 
-      const { ModelCompilationError } = await import("../errors");
+      const warnSpy = spyOn(logger, "warn");
       const { malloyConfig, duckdb } = await makeMalloyConfig();
       try {
-         let caught: unknown;
-         try {
-            await Package.create("env", "pkg", tempDir, malloyConfig);
-         } catch (err) {
-            caught = err;
-         }
-         expect(caught).toBeInstanceOf(ModelCompilationError);
-         expect((caught as Error).message).toContain(
-            "Invalid renderer configuration",
-         );
-         expect((caught as Error).message).toContain("nums -> card");
+         const pkg = await Package.create("env", "pkg", tempDir, malloyConfig);
+         expect(pkg.getModelPaths()).toEqual(["bad_render.malloy"]);
+         const warnings = warnSpy.mock.calls.map((c) => String(c[0]));
+         expect(
+            warnings.some(
+               (m) =>
+                  m.includes("Invalid renderer configuration") &&
+                  m.includes("nums -> card"),
+            ),
+         ).toBe(true);
       } finally {
+         warnSpy.mockRestore();
          await duckdb.close();
       }
    });
@@ -341,7 +342,7 @@ source: gated is duckdb.sql("select 1 as id")`,
       }
    });
 
-   it("rejects a package whose backtick-quoted (hyphenated) source has a bad view render tag", async () => {
+   it("logs a warning for a backtick-quoted (hyphenated) source with a bad view render tag", async () => {
       writeManifest();
       // A source whose name needs Malloy backtick-quoting (here, a hyphen). The
       // validation target must quote the identifier; otherwise `run: bad-source
@@ -363,26 +364,26 @@ source: gated is duckdb.sql("select 1 as id")`,
 }`,
       );
 
-      const { ModelCompilationError } = await import("../errors");
+      const warnSpy = spyOn(logger, "warn");
       const { malloyConfig, duckdb } = await makeMalloyConfig();
       try {
-         let caught: unknown;
-         try {
-            await Package.create("env", "pkg", tempDir, malloyConfig);
-         } catch (err) {
-            caught = err;
-         }
-         expect(caught).toBeInstanceOf(ModelCompilationError);
-         expect((caught as Error).message).toContain(
-            "Invalid renderer configuration",
-         );
-         expect((caught as Error).message).toContain("bad-source -> card");
+         const pkg = await Package.create("env", "pkg", tempDir, malloyConfig);
+         expect(pkg.getModelPaths()).toEqual(["hyphen_render.malloy"]);
+         const warnings = warnSpy.mock.calls.map((c) => String(c[0]));
+         expect(
+            warnings.some(
+               (m) =>
+                  m.includes("Invalid renderer configuration") &&
+                  m.includes("bad-source -> card"),
+            ),
+         ).toBe(true);
       } finally {
+         warnSpy.mockRestore();
          await duckdb.close();
       }
    });
 
-   it("rejects a package whose source name contains an escaped backtick with a bad view render tag", async () => {
+   it("logs a warning for a source name containing an escaped backtick with a bad view render tag", async () => {
       writeManifest();
       // Source name with a literal backtick (written escaped in Malloy as
       // `wei\`rd`). The validation target must re-escape it; a bare wrap would
@@ -403,26 +404,26 @@ source: gated is duckdb.sql("select 1 as id")`,
 }`,
       );
 
-      const { ModelCompilationError } = await import("../errors");
+      const warnSpy = spyOn(logger, "warn");
       const { malloyConfig, duckdb } = await makeMalloyConfig();
       try {
-         let caught: unknown;
-         try {
-            await Package.create("env", "pkg", tempDir, malloyConfig);
-         } catch (err) {
-            caught = err;
-         }
-         expect(caught).toBeInstanceOf(ModelCompilationError);
-         expect((caught as Error).message).toContain(
-            "Invalid renderer configuration",
-         );
-         expect((caught as Error).message).toContain("card");
+         const pkg = await Package.create("env", "pkg", tempDir, malloyConfig);
+         expect(pkg.getModelPaths()).toEqual(["backtick_render.malloy"]);
+         const warnings = warnSpy.mock.calls.map((c) => String(c[0]));
+         expect(
+            warnings.some(
+               (m) =>
+                  m.includes("Invalid renderer configuration") &&
+                  m.includes("card"),
+            ),
+         ).toBe(true);
       } finally {
+         warnSpy.mockRestore();
          await duckdb.close();
       }
    });
 
-   it("rejects a .malloynb notebook whose source view carries an invalid renderer tag", async () => {
+   it("logs a warning for a .malloynb notebook whose source view carries an invalid renderer tag", async () => {
       writeManifest();
       fs.writeFileSync(
          path.join(tempDir, "bad_render.malloynb"),
@@ -439,18 +440,22 @@ source: nums is duckdb.sql("select 1 as a, 2 as b") extend {
 }`,
       );
 
-      const { ModelCompilationError } = await import("../errors");
+      const warnSpy = spyOn(logger, "warn");
       const { malloyConfig, duckdb } = await makeMalloyConfig();
       try {
-         await expect(
-            Package.create("env", "pkg", tempDir, malloyConfig),
-         ).rejects.toBeInstanceOf(ModelCompilationError);
+         const pkg = await Package.create("env", "pkg", tempDir, malloyConfig);
+         expect(pkg.getModelPaths()).toEqual(["bad_render.malloynb"]);
+         const warnings = warnSpy.mock.calls.map((c) => String(c[0]));
+         expect(
+            warnings.some((m) => m.includes("Invalid renderer configuration")),
+         ).toBe(true);
       } finally {
+         warnSpy.mockRestore();
          await duckdb.close();
       }
    });
 
-   it("re-validates renderer tags on reload, recording a model that develops a bad tag as a per-model error", async () => {
+   it("re-validates renderer tags on reload, logging a warning for a model that develops a bad tag", async () => {
       writeManifest();
       // Start valid so Package.create succeeds.
       fs.writeFileSync(
@@ -463,13 +468,15 @@ source: nums is duckdb.sql("select 1 as a, 2 as b") extend {
       );
 
       const { malloyConfig, duckdb } = await makeMalloyConfig();
+      const warnSpy = spyOn(logger, "warn");
       try {
          const pkg = await Package.create("env", "pkg", tempDir, malloyConfig);
          expect(pkg.getModel("m.malloy")).toBeDefined();
+         warnSpy.mockClear();
 
-         // The model now develops a misconfigured render tag. Reload must catch
-         // it (not just Package.create) and surface it as the model's error,
-         // without aborting the whole reload.
+         // The model now develops a misconfigured render tag. Reload re-validates
+         // (not just Package.create) and logs a warning for it, without aborting
+         // the reload or failing the model.
          fs.writeFileSync(
             path.join(tempDir, "m.malloy"),
             `source: nums is duckdb.sql("select 1 as a, 2 as b") extend {
@@ -487,10 +494,13 @@ source: nums is duckdb.sql("select 1 as a, 2 as b") extend {
 
          const reloaded = pkg.getModel("m.malloy");
          expect(reloaded).toBeDefined();
-         await expect(reloaded!.getModel()).rejects.toThrow(
-            "Invalid renderer configuration",
-         );
+         await expect(reloaded!.getModel()).resolves.toBeDefined();
+         const warnings = warnSpy.mock.calls.map((c) => String(c[0]));
+         expect(
+            warnings.some((m) => m.includes("Invalid renderer configuration")),
+         ).toBe(true);
       } finally {
+         warnSpy.mockRestore();
          await duckdb.close();
       }
    });