@malloy-publisher/server 0.0.225 → 0.0.226

package/src/service/package.ts

@@ -386,6 +386,10 @@ export class Package {
             schedule: null,
             freshness: null,
          },
+         // Package-level persist scope mode, applied uniformly to every persist
+         // source/index. Defaults to "package" (cross-version reuse) when the
+         // manifest omits it.
+         scope: outcome.packageMetadata.scope ?? "package",
       };
 
       // Build live `Model`s from worker output. Any per-model compile
@@ -492,15 +496,19 @@ export class Package {
             detail: invalidMsg,
          });
       }
-      // Same fail-safe split for the materialization cron gate: an existing
-      // package whose manifest violates the private-only cron rule still loads
-      // (warn), but a publish of it is rejected (see package.controller).
-      const invalidSchedule = pkg.formatInvalidSchedule();
-      if (invalidSchedule) {
-         logger.warn(`Package ${packageName} has an invalid cron schedule`, {
-            packageName,
-            detail: invalidSchedule,
-         });
+      // Same fail-safe split for the persistence-policy gate: an existing
+      // package whose manifest violates the scope/schedule/freshness rules
+      // still loads (warn), but a publish of it is rejected (see
+      // package.controller).
+      const invalidPolicy = pkg.formatInvalidPersistencePolicy();
+      if (invalidPolicy) {
+         logger.warn(
+            `Package ${packageName} has an invalid persistence policy`,
+            {
+               packageName,
+               detail: invalidPolicy,
+            },
+         );
       }
       pkg.logEmptyDiscoveryWarnings();
 
@@ -717,56 +725,84 @@ export class Package {
    }
 
    /**
-    * Publish-gate for materialization crons (Phase A carve-out, persistence.md
-    * §9.4). A cron is the power tier of artifact-anchored scheduling and is
-    * valid only over `sharing="private"` artifacts; a cron on a shared (or unset
-    * ⇒ shared) artifact is rejected, pointing at `freshness.window` as the
-    * shared-tier replacement. Two grains, both enforced off the resolved build
-    * plan (per-source `sharing`/`schedule` are effective, most-specific-wins):
+    * Publish-gate for the package's Malloy Persistence policy (persistence.md
+    * §3.1, §9.2–§9.5). Scope is a single package-level mode (`Package.scope`)
+    * and a materialization cron is package-root-only and version-scope-only.
+    * The rules, read off the resolved build plan + manifest:
+    *
+    *  1. Per-source `#@ persist ... sharing=`/`schedule=` are retired — declaring
+    *     either on a source is an error (scope is package-level; a schedule is
+    *     package-root-only). Detected via the raw `annotationFields`.
+    *  2. `materialization.schedule` is legal only when `scope: version` (a
+    *     package-scoped lineage is reused across versions, so a single
+    *     per-version cadence is meaningless).
+    *  3. `materialization.schedule` and freshness (package `materialization.freshness`
+    *     or any source `freshness`) are mutually exclusive — declare either the
+    *     power tier or the objective tier, never both.
     *
-    *  - Per-source: a source's own `schedule` is valid only when that source
-    *    resolves to explicit `sharing="private"`.
-    *  - Package: `materialization.schedule` governs every persist source, so it
-    *    is valid only when every governed source resolves to explicit
-    *    `sharing="private"` (a mixed/shared/unset package cannot carry it).
+    * The cross-package dependency rule (a `scope: version` scheduled package may
+    * not depend on a package-scoped upstream) is not enforced here: scope is
+    * uniform within a package, so an intra-package dependency can never violate
+    * it, and the publisher's build plan is intra-package only — a cross-package
+    * upstream's scope is not resolvable from the single `Package` served. It is
+    * deferred to the scheduler slice (R1–R3), which resolves cross-package scope.
     *
     * Strict at publish (package.controller), warn-only at load/reload
     * (loadViaWorker) — same split as explores.
     */
-   public scheduleWarnings(): string[] {
+   public persistencePolicyWarnings(): string[] {
       const warnings: string[] = [];
       const sources = this.buildPlan?.sources
          ? Object.values(this.buildPlan.sources)
          : [];
+      const materialization = this.packageMetadata.materialization;
+      const packageSchedule = materialization?.schedule ?? null;
+      const packageFreshness = materialization?.freshness ?? null;
+      const scope = this.packageMetadata.scope ?? "package";
 
+      // Rule 1: per-source sharing/schedule are no longer part of the model.
       for (const source of sources) {
-         if (source.schedule && source.sharing !== "private") {
+         const fields = source.annotationFields ?? {};
+         if (fields.sharing !== undefined) {
             warnings.push(
-               `#@ persist source "${source.name}" declares a schedule (cron) but ` +
-                  `resolves to sharing="${
-                     source.sharing ?? "shared (unset default)"
-                  }": a per-source cron is valid only for sharing="private". ` +
-                  `Declare 'freshness.window' instead (the control plane schedules ` +
-                  `refreshes from it).`,
+               `#@ persist source "${source.name}" declares sharing=... which is ` +
+                  `no longer supported: scope is a single package-level mode. Set ` +
+                  `the root-level "scope": "version" | "package" in ` +
+                  `${PACKAGE_MANIFEST_NAME} instead.`,
             );
          }
+         if (fields.schedule !== undefined) {
+            warnings.push(
+               `#@ persist source "${source.name}" declares schedule=... which is ` +
+                  `no longer supported: a schedule is package-root-only. Declare ` +
+                  `"materialization.schedule" at the ${PACKAGE_MANIFEST_NAME} root ` +
+                  `(requires "scope": "version") instead.`,
+            );
+         }
+      }
+
+      // Rule 2: a package-level cron is legal only with scope: version.
+      if (packageSchedule && scope !== "version") {
+         warnings.push(
+            `materialization.schedule (cron) in ${PACKAGE_MANIFEST_NAME} requires ` +
+               `"scope": "version": a package-scoped lineage is reused across ` +
+               `versions, so a single per-version cadence is meaningless. Set ` +
+               `"scope": "version", or remove the schedule.`,
+         );
       }
 
-      const packageSchedule = this.packageMetadata.materialization?.schedule;
+      // Rule 3: schedule and freshness are mutually exclusive.
       if (packageSchedule) {
-         const nonPrivate = sources.filter((s) => s.sharing !== "private");
-         if (sources.length === 0 || nonPrivate.length > 0) {
-            const detail =
-               sources.length === 0
-                  ? "the package declares no persist source for it to govern"
-                  : `sources [${nonPrivate
-                       .map((s) => s.name)
-                       .join(", ")}] resolve to shared/unset`;
+         const freshnessDeclared =
+            !!(
+               packageFreshness &&
+               (packageFreshness.window || packageFreshness.fallback)
+            ) || sources.some((s) => s.freshness != null);
+         if (freshnessDeclared) {
             warnings.push(
-               `materialization.schedule (cron) in ${PACKAGE_MANIFEST_NAME} is valid ` +
-                  `only when every persist source resolves to sharing="private": ` +
-                  `${detail}. Declare 'materialization.freshness.window' instead ` +
-                  `(the control plane schedules refreshes from it).`,
+               `materialization.schedule and freshness are mutually exclusive in ` +
+                  `${PACKAGE_MANIFEST_NAME}: declare either a schedule (power tier) ` +
+                  `or freshness (objective tier), never both.`,
             );
          }
       }
@@ -774,9 +810,12 @@ export class Package {
       return warnings;
    }
 
-   /** The {@link scheduleWarnings} joined into one string, or "" if none. */
-   public formatInvalidSchedule(): string {
-      return this.scheduleWarnings().join("\n");
+   /**
+    * The {@link persistencePolicyWarnings} joined into one string, or "" if the
+    * package's persistence policy is valid.
+    */
+   public formatInvalidPersistencePolicy(): string {
+      return this.persistencePolicyWarnings().join("\n");
    }
 
    /**

package/src/service/package_manifest.spec.ts

@@ -1,7 +1,28 @@
 import { describe, expect, it } from "bun:test";
-import { parsePackageMaterialization } from "./package_manifest";
+import {
+   parsePackageMaterialization,
+   parsePackageScope,
+} from "./package_manifest";
 
 describe("service/package_manifest", () => {
+   describe("parsePackageScope", () => {
+      it("defaults to 'package' when absent", () => {
+         expect(parsePackageScope(undefined)).toBe("package");
+         expect(parsePackageScope(null)).toBe("package");
+      });
+
+      it("accepts the two valid modes verbatim", () => {
+         expect(parsePackageScope("version")).toBe("version");
+         expect(parsePackageScope("package")).toBe("package");
+      });
+
+      it("throws on any other value (no silent default)", () => {
+         expect(() => parsePackageScope("shared")).toThrow(/scope/i);
+         expect(() => parsePackageScope("")).toThrow(/scope/i);
+         expect(() => parsePackageScope(7)).toThrow(/scope/i);
+      });
+   });
+
    describe("parsePackageMaterialization", () => {
       it("extracts a string schedule", () => {
          expect(parsePackageMaterialization({ schedule: "0 6 * * *" })).toEqual(

package/src/service/package_manifest.ts

@@ -7,6 +7,35 @@
 const FRESHNESS_FALLBACKS = ["live", "stale_ok", "fail"] as const;
 export type FreshnessFallback = (typeof FRESHNESS_FALLBACKS)[number];
 
+/**
+ * Package-level Malloy Persistence scope mode, declared once at the manifest
+ * root. `package` (the default) = artifacts are reused across the package's
+ * versions when they satisfy freshness; `version` = each artifact is owned by
+ * one published version (the only mode a `materialization.schedule` is legal
+ * in). Applied uniformly to every persist source and index in the package.
+ */
+export const PACKAGE_SCOPES = ["version", "package"] as const;
+export type PackageScope = (typeof PACKAGE_SCOPES)[number];
+
+/**
+ * Read the manifest root's `scope`, defaulting to `"package"` when absent or
+ * null. Any other value is a manifest error: scope is load-bearing (it decides
+ * version-owned vs cross-version reuse), so a typo must fail loudly rather than
+ * silently pick a default. Throws on an invalid value.
+ */
+export function parsePackageScope(raw: unknown): PackageScope {
+   if (raw === undefined || raw === null) {
+      return "package";
+   }
+   if ((PACKAGE_SCOPES as readonly unknown[]).includes(raw)) {
+      return raw as PackageScope;
+   }
+   throw new Error(
+      `Invalid "scope" in the package manifest: ${JSON.stringify(raw)}. ` +
+         `Expected "version" or "package" (default "package").`,
+   );
+}
+
 /**
  * The manifest's `materialization.freshness` block, surfaced verbatim for the
  * control plane (which owns the scheduling and query-time gating logic).

package/src/service/persistence_policy.spec.ts

@@ -0,0 +1,234 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+
+import { Environment } from "./environment";
+import type { Package } from "./package";
+
+/**
+ * The publish gate for the package's Malloy Persistence policy (persistence.md
+ * §3.1, §9.2–§9.5). Scope is a single package-level mode (`Package.scope`) and a
+ * materialization cron is package-root-only + version-scope-only:
+ *
+ *  - per-source `#@ persist ... sharing=`/`schedule=` are retired (declaring
+ *    either on a source is a manifest error);
+ *  - `materialization.schedule` is legal only when `scope: version`;
+ *  - `materialization.schedule` and freshness (package or source) are mutually
+ *    exclusive.
+ *
+ * These tests run a real `Environment` + `Package.create` over temp dirs, so
+ * they also prove end-to-end that the pinned compiler still ACCEPTS the
+ * `#@ persist` annotation keys (`sharing`/`schedule`/`freshness.*`) at compile
+ * — the rejection is the publisher's manifest-level gate, not a compile error —
+ * and that `scope` is parsed from the manifest root and surfaced on the package.
+ */
+describe("persistence policy gate", () => {
+   let rootDir: string;
+   let envPath: string;
+
+   async function loadPackage(
+      model: string,
+      manifest: Record<string, unknown> = {},
+   ): Promise<Package> {
+      const dir = path.join(envPath, "pkg");
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(
+         path.join(dir, "publisher.json"),
+         JSON.stringify({ name: "pkg", description: "fixture", ...manifest }),
+      );
+      await fs.writeFile(path.join(dir, "model.malloy"), model);
+      const env = await Environment.create("testEnv", envPath, []);
+      await env.addPackage("pkg");
+      return env.getPackage("pkg", false);
+   }
+
+   function sourceByName(pkg: Package, name: string) {
+      const sources = pkg.getBuildPlan()?.sources ?? {};
+      const found = Object.values(sources).find((s) => s.name === name);
+      if (!found) throw new Error(`persist source '${name}' not in build plan`);
+      return found;
+   }
+
+   beforeEach(async () => {
+      rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "publisher-policy-"));
+      envPath = path.join(rootDir, "env");
+      await fs.mkdir(envPath, { recursive: true });
+   });
+
+   afterEach(async () => {
+      await fs.rm(rootDir, { recursive: true, force: true }).catch(() => {});
+   });
+
+   const PLAIN_MODEL = `##! experimental.persistence
+
+#@ persist name="a_table"
+source: a is duckdb.sql("SELECT 1 as x")
+
+#@ persist name="b_table" refresh=full
+source: b is duckdb.sql("SELECT 2 as x")
+`;
+
+   const SHARING_SOURCE_MODEL = `##! experimental.persistence
+
+#@ persist name="s_table" sharing=private
+source: s is duckdb.sql("SELECT 1 as x")
+`;
+
+   const SCHEDULE_SOURCE_MODEL = `##! experimental.persistence
+
+#@ persist name="s_table" schedule="0 */6 * * *"
+source: s is duckdb.sql("SELECT 1 as x")
+`;
+
+   const FRESHNESS_SOURCE_MODEL = `##! experimental.persistence
+
+#@ persist name="f_table" freshness.window="1h"
+source: f is duckdb.sql("SELECT 1 as x")
+`;
+
+   // ── scope parsing + surfacing ─────────────────────────────────────────
+
+   it(
+      "defaults scope to 'package' when the manifest omits it",
+      async () => {
+         const pkg = await loadPackage(PLAIN_MODEL);
+         expect(pkg.getPackageMetadata().scope).toBe("package");
+      },
+      { timeout: 30000 },
+   );
+
+   it(
+      "surfaces an explicit scope: version from the manifest root",
+      async () => {
+         const pkg = await loadPackage(PLAIN_MODEL, { scope: "version" });
+         expect(pkg.getPackageMetadata().scope).toBe("version");
+      },
+      { timeout: 30000 },
+   );
+
+   it(
+      "fails the load on an invalid scope value",
+      async () => {
+         await expect(
+            loadPackage(PLAIN_MODEL, { scope: "shared" }),
+         ).rejects.toThrow(/scope/i);
+      },
+      { timeout: 30000 },
+   );
+
+   // ── Rule 1: per-source sharing/schedule retired ───────────────────────
+
+   it(
+      "rejects a per-source sharing= annotation, pointing at root scope",
+      async () => {
+         const pkg = await loadPackage(SHARING_SOURCE_MODEL, {
+            scope: "version",
+         });
+         const joined = pkg.formatInvalidPersistencePolicy();
+         expect(joined).toContain('"s"');
+         expect(joined).toContain("sharing");
+         expect(joined).toContain('"scope"');
+      },
+      { timeout: 30000 },
+   );
+
+   it(
+      "rejects a per-source schedule= annotation, pointing at the root schedule",
+      async () => {
+         const pkg = await loadPackage(SCHEDULE_SOURCE_MODEL, {
+            scope: "version",
+         });
+         const joined = pkg.formatInvalidPersistencePolicy();
+         expect(joined).toContain('"s"');
+         expect(joined).toContain("schedule");
+         expect(joined).toContain("materialization.schedule");
+         // The retired field is not emitted on the wire plan.
+         const source = sourceByName(pkg, "s") as Record<string, unknown>;
+         expect(source.schedule).toBeUndefined();
+         expect(source.sharing).toBeUndefined();
+      },
+      { timeout: 30000 },
+   );
+
+   // ── Rule 2: schedule requires scope: version ──────────────────────────
+
+   it(
+      "rejects a package schedule when scope is package (the default)",
+      async () => {
+         const pkg = await loadPackage(PLAIN_MODEL, {
+            materialization: { schedule: "0 6 * * *" },
+         });
+         const joined = pkg.formatInvalidPersistencePolicy();
+         expect(joined).toContain("materialization.schedule");
+         expect(joined).toContain('"scope": "version"');
+      },
+      { timeout: 30000 },
+   );
+
+   it(
+      "accepts a package schedule when scope is version and no freshness is set",
+      async () => {
+         const pkg = await loadPackage(PLAIN_MODEL, {
+            scope: "version",
+            materialization: { schedule: "0 6 * * *" },
+         });
+         expect(pkg.persistencePolicyWarnings()).toEqual([]);
+      },
+      { timeout: 30000 },
+   );
+
+   // ── Rule 3: schedule XOR freshness ────────────────────────────────────
+
+   it(
+      "rejects a schedule declared alongside package-level freshness",
+      async () => {
+         const pkg = await loadPackage(PLAIN_MODEL, {
+            scope: "version",
+            materialization: {
+               schedule: "0 6 * * *",
+               freshness: { window: "24h" },
+            },
+         });
+         const joined = pkg.formatInvalidPersistencePolicy();
+         expect(joined).toContain("mutually exclusive");
+      },
+      { timeout: 30000 },
+   );
+
+   it(
+      "rejects a schedule declared alongside a source-level freshness",
+      async () => {
+         const pkg = await loadPackage(FRESHNESS_SOURCE_MODEL, {
+            scope: "version",
+            materialization: { schedule: "0 6 * * *" },
+         });
+         const joined = pkg.formatInvalidPersistencePolicy();
+         expect(joined).toContain("mutually exclusive");
+      },
+      { timeout: 30000 },
+   );
+
+   // ── inert when nothing is declared ────────────────────────────────────
+
+   it(
+      "is inert for a plain package with no schedule and no forbidden knobs",
+      async () => {
+         const pkg = await loadPackage(PLAIN_MODEL, { scope: "package" });
+         expect(pkg.persistencePolicyWarnings()).toEqual([]);
+      },
+      { timeout: 30000 },
+   );
+
+   it(
+      "accepts source-level freshness without a schedule in either scope",
+      async () => {
+         const pkg = await loadPackage(FRESHNESS_SOURCE_MODEL, {
+            scope: "package",
+         });
+         expect(pkg.persistencePolicyWarnings()).toEqual([]);
+         expect(sourceByName(pkg, "f").freshness).toEqual({ window: "1h" });
+      },
+      { timeout: 30000 },
+   );
+});

package/src/service/materialization_cron_gate.spec.ts

@@ -1,181 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import * as fs from "fs/promises";
-import * as os from "os";
-import * as path from "path";
-
-import { Environment } from "./environment";
-import type { Package } from "./package";
-
-/**
- * The publish gate for materialization crons (Phase A carve-out,
- * persistence.md §9.4). A cron is the power tier of artifact-anchored
- * scheduling and is valid only over `sharing="private"` artifacts:
- *
- *  - a package-level cron (`materialization.schedule`) is valid only when
- *    EVERY governed persist source resolves to explicit `sharing="private"`;
- *  - a per-source cron (`#@ persist ... schedule=`) is valid only when THAT
- *    source resolves to explicit `sharing="private"`;
- *  - a cron on a shared/unset artifact is rejected, pointing at
- *    `freshness.window` as the shared-tier replacement.
- *
- * These tests run a real `Environment` + `Package.create` over temp dirs, so
- * they also prove end-to-end that the pinned compiler ACCEPTS `sharing=` /
- * `refresh=` / `schedule=` / `freshness.*` keys in the `#@ persist` annotation
- * and that the values survive to the wire build plan verbatim (unset stays null
- * — never defaulted to "shared").
- */
-describe("materialization cron gate", () => {
-   let rootDir: string;
-   let envPath: string;
-
-   async function loadPackage(model: string, schedule?: string) {
-      const dir = path.join(envPath, "pkg");
-      await fs.mkdir(dir, { recursive: true });
-      await fs.writeFile(
-         path.join(dir, "publisher.json"),
-         JSON.stringify({
-            name: "pkg",
-            description: "fixture",
-            ...(schedule ? { materialization: { schedule } } : {}),
-         }),
-      );
-      await fs.writeFile(path.join(dir, "model.malloy"), model);
-      const env = await Environment.create("testEnv", envPath, []);
-      await env.addPackage("pkg");
-      return env.getPackage("pkg", false);
-   }
-
-   function sourceByName(pkg: Package, name: string) {
-      const sources = pkg.getBuildPlan()?.sources ?? {};
-      const found = Object.values(sources).find((s) => s.name === name);
-      if (!found) throw new Error(`persist source '${name}' not in build plan`);
-      return found;
-   }
-
-   beforeEach(async () => {
-      rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "publisher-cron-"));
-      envPath = path.join(rootDir, "env");
-      await fs.mkdir(envPath, { recursive: true });
-   });
-
-   afterEach(async () => {
-      await fs.rm(rootDir, { recursive: true, force: true }).catch(() => {});
-   });
-
-   const MIXED_MODEL = `##! experimental.persistence
-
-#@ persist name="priv_table" sharing=private refresh=incremental
-source: priv is duckdb.sql("SELECT 1 as x")
-
-#@ persist name="open_table" sharing=shared
-source: open is duckdb.sql("SELECT 2 as x")
-
-#@ persist name="unset_table"
-source: unspecified is duckdb.sql("SELECT 3 as x")
-`;
-
-   const ALL_PRIVATE_MODEL = `##! experimental.persistence
-
-#@ persist name="a_table" sharing=private
-source: a is duckdb.sql("SELECT 1 as x")
-
-#@ persist name="b_table" sharing=private refresh=full
-source: b is duckdb.sql("SELECT 2 as x")
-`;
-
-   // Per-source crons: valid on the private source, rejected on the shared and
-   // the unset (⇒ shared) sources.
-   const PER_SOURCE_CRON_MODEL = `##! experimental.persistence
-
-#@ persist name="p_table" sharing=private schedule="0 */6 * * *"
-source: p is duckdb.sql("SELECT 1 as x")
-
-#@ persist name="s_table" sharing=shared schedule="0 0 * * *"
-source: s is duckdb.sql("SELECT 2 as x")
-
-#@ persist name="u_table" schedule="0 0 * * *"
-source: u is duckdb.sql("SELECT 3 as x")
-`;
-
-   it(
-      "surfaces declared sharing/refresh verbatim on the build plan (null when unset)",
-      async () => {
-         const pkg = await loadPackage(MIXED_MODEL);
-
-         const priv = sourceByName(pkg, "priv");
-         expect(priv.sharing).toBe("private");
-         expect(priv.refresh).toBe("incremental");
-
-         const open = sourceByName(pkg, "open");
-         expect(open.sharing).toBe("shared");
-         expect(open.refresh).toBeNull();
-
-         // Unset must be reported as null — distinguishable from an explicit
-         // "shared" — because the control plane applies the platform default
-         // (unset => shared) itself.
-         const unspecified = sourceByName(pkg, "unspecified");
-         expect(unspecified.sharing).toBeNull();
-         expect(unspecified.refresh).toBeNull();
-      },
-      { timeout: 30000 },
-   );
-
-   it(
-      "rejects a package cron on a mixed package, pointing at freshness.window",
-      async () => {
-         // Phase A: a package cron governs every persist source, so it is valid
-         // only when all resolve to explicit private. MIXED has a shared and an
-         // unset source, so the package cron is rejected.
-         const pkg = await loadPackage(MIXED_MODEL, "0 6 * * *");
-
-         const warnings = pkg.scheduleWarnings();
-         expect(warnings).toHaveLength(1);
-         const joined = pkg.formatInvalidSchedule();
-         expect(joined).toContain("materialization.schedule");
-         expect(joined).toContain("materialization.freshness.window");
-      },
-      { timeout: 30000 },
-   );
-
-   it(
-      "accepts a package cron when every persist source is private",
-      async () => {
-         // Phase A carve-out: an all-private package legitimately carries a
-         // package-level cron (the power tier for its own private artifacts).
-         const pkg = await loadPackage(ALL_PRIVATE_MODEL, "0 6 * * *");
-         expect(pkg.scheduleWarnings()).toEqual([]);
-      },
-      { timeout: 30000 },
-   );
-
-   it(
-      "rejects a per-source cron unless that source resolves to private",
-      async () => {
-         // No package cron here — only per-source `schedule=` declarations. The
-         // private source's cron is accepted; the shared and unset sources' are
-         // rejected, each pointing at freshness.window.
-         const pkg = await loadPackage(PER_SOURCE_CRON_MODEL);
-
-         const warnings = pkg.scheduleWarnings();
-         expect(warnings).toHaveLength(2);
-         const joined = warnings.join("\n");
-         expect(joined).toContain('"s"');
-         expect(joined).toContain('"u"');
-         expect(joined).not.toContain('"p"');
-         expect(joined).toContain("freshness.window");
-
-         // The resolved per-source schedule is surfaced verbatim on the plan.
-         expect(sourceByName(pkg, "p").schedule).toBe("0 */6 * * *");
-      },
-      { timeout: 30000 },
-   );
-
-   it(
-      "is inert when no cron is declared, whatever the sources' sharing",
-      async () => {
-         const pkg = await loadPackage(MIXED_MODEL);
-         expect(pkg.scheduleWarnings()).toEqual([]);
-      },
-      { timeout: 30000 },
-   );
-});