@malloy-publisher/server 0.0.228 → 0.0.229

package/tests/integration/materialization/schedule_edit.integration.spec.ts

@@ -0,0 +1,126 @@
+/// <reference types="bun-types" />
+
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import path from "path";
+import { fileURLToPath } from "url";
+import { RestE2EEnv, startRestE2E } from "../../harness/rest_e2e";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PROJECT_NAME = "sched-edit-project";
+const PACKAGE_NAME = "persist-schedule-test";
+const API = `/api/v0/environments/${PROJECT_NAME}/packages/${PACKAGE_NAME}`;
+
+// Exercises the editable-schedule PATCH path: materialization.schedule and
+// scope are writable via updatePackage, validated with the same rules a publish
+// enforces (schedule requires scope: version, valid 5-field cron), and
+// persisted to publisher.json.
+describe("Editable materialization schedule (PATCH)", () => {
+   let env: (RestE2EEnv & { stop(): Promise<void> }) | null = null;
+   let baseUrl: string;
+
+   beforeAll(async () => {
+      env = await startRestE2E();
+      baseUrl = env.baseUrl;
+
+      const fixtureDir = path.resolve(
+         __dirname,
+         "../../fixtures/persist-schedule-test",
+      );
+      const createRes = await fetch(`${baseUrl}/api/v0/environments`, {
+         method: "POST",
+         headers: { "Content-Type": "application/json" },
+         body: JSON.stringify({
+            name: PROJECT_NAME,
+            packages: [{ name: PACKAGE_NAME, location: fixtureDir }],
+            connections: [],
+         }),
+      });
+      if (!createRes.ok) {
+         throw new Error(
+            `Failed to create test project (${createRes.status}): ${await createRes.text()}`,
+         );
+      }
+
+      const deadline = Date.now() + 30_000;
+      while (Date.now() < deadline) {
+         const res = await fetch(`${baseUrl}${API}`);
+         if (res.ok) break;
+         await new Promise((r) => setTimeout(r, 500));
+      }
+   });
+
+   afterAll(async () => {
+      if (baseUrl) {
+         try {
+            await fetch(`${baseUrl}/api/v0/environments/${PROJECT_NAME}`, {
+               method: "DELETE",
+            });
+         } catch {
+            // best-effort
+         }
+      }
+      await env?.stop();
+      env = null;
+   });
+
+   async function getPackage(): Promise<Record<string, unknown>> {
+      const res = await fetch(`${baseUrl}${API}`);
+      expect(res.status).toBe(200);
+      return (await res.json()) as Record<string, unknown>;
+   }
+
+   function scheduleOf(
+      pkg: Record<string, unknown>,
+   ): string | null | undefined {
+      return (pkg.materialization as { schedule?: string | null } | null)
+         ?.schedule;
+   }
+
+   async function patch(body: Record<string, unknown>): Promise<Response> {
+      return fetch(`${baseUrl}${API}`, {
+         method: "PATCH",
+         headers: { "Content-Type": "application/json" },
+         body: JSON.stringify({ name: PACKAGE_NAME, ...body }),
+      });
+   }
+
+   it("starts from the fixture's version-scoped schedule", async () => {
+      const pkg = await getPackage();
+      expect(pkg.scope).toBe("version");
+      expect(scheduleOf(pkg)).toBe("0 6 * * *");
+   });
+
+   it("edits and persists a new schedule", async () => {
+      const res = await patch({
+         materialization: { schedule: "*/30 * * * *" },
+      });
+      expect(res.ok).toBe(true);
+      expect(scheduleOf(await getPackage())).toBe("*/30 * * * *");
+   });
+
+   it("rejects an invalid cron (400) and leaves the schedule unchanged", async () => {
+      const res = await patch({ materialization: { schedule: "not a cron" } });
+      expect(res.status).toBe(400);
+      expect(scheduleOf(await getPackage())).toBe("*/30 * * * *");
+   });
+
+   it("rejects a schedule without version scope (400)", async () => {
+      const res = await patch({
+         scope: "package",
+         materialization: { schedule: "0 6 * * *" },
+      });
+      expect(res.status).toBe(400);
+      // Prior good state preserved (scope + schedule both unchanged).
+      const pkg = await getPackage();
+      expect(pkg.scope).toBe("version");
+      expect(scheduleOf(pkg)).toBe("*/30 * * * *");
+   });
+
+   it("clears the schedule with schedule: null", async () => {
+      const res = await patch({ materialization: { schedule: null } });
+      expect(res.ok).toBe(true);
+      expect(scheduleOf(await getPackage())).toBeNull();
+   });
+});

package/tests/integration/materialization/scheduler.integration.spec.ts

@@ -0,0 +1,200 @@
+/// <reference types="bun-types" />
+
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import fsp from "fs/promises";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+import { MaterializationScheduler } from "../../../src/service/materialization_scheduler";
+import { MaterializationService } from "../../../src/service/materialization_service";
+import { environmentStore } from "../../../src/server";
+import { RestE2EEnv, startRestE2E } from "../../harness/rest_e2e";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PROJECT_NAME = "sched-project";
+const PACKAGE_NAME = "persist-schedule-test";
+const API = `/api/v0/environments/${PROJECT_NAME}/packages/${PACKAGE_NAME}`;
+
+const TERMINAL = ["MANIFEST_FILE_READY", "FAILED", "CANCELLED"];
+
+// Deterministic clock for the scheduler: we call tick(nowMs) explicitly, so the
+// fixture's daily cron ("0 6 * * *") fires without waiting on a real minute.
+const T0 = Date.parse("2026-01-01T00:00:00Z");
+const THREE_DAYS_MS = 3 * 24 * 60 * 60 * 1000;
+
+describe("MaterializationScheduler (E2E, real build)", () => {
+   let env: (RestE2EEnv & { stop(): Promise<void> }) | null = null;
+   let baseUrl: string;
+   let scheduler: MaterializationScheduler;
+
+   beforeAll(async () => {
+      env = await startRestE2E();
+      baseUrl = env.baseUrl;
+
+      const fixtureDir = path.resolve(
+         __dirname,
+         "../../fixtures/persist-schedule-test",
+      );
+      const createRes = await fetch(`${baseUrl}/api/v0/environments`, {
+         method: "POST",
+         headers: { "Content-Type": "application/json" },
+         body: JSON.stringify({
+            name: PROJECT_NAME,
+            packages: [{ name: PACKAGE_NAME, location: fixtureDir }],
+            connections: [],
+         }),
+      });
+      if (!createRes.ok) {
+         throw new Error(
+            `Failed to create test project (${createRes.status}): ${await createRes.text()}`,
+         );
+      }
+
+      // Wait for the package to load (so it's in the environmentStore the
+      // scheduler sweeps).
+      const deadline = Date.now() + 30_000;
+      while (Date.now() < deadline) {
+         const res = await fetch(`${baseUrl}${API}`);
+         if (res.ok) break;
+         await new Promise((r) => setTimeout(r, 500));
+      }
+
+      // Drive the real scheduler against the server's real environmentStore and
+      // a real MaterializationService (shares the same repository). We call
+      // tick() by hand with a controlled clock rather than relying on the timer.
+      scheduler = new MaterializationScheduler(
+         environmentStore,
+         new MaterializationService(environmentStore),
+         { tickIntervalMs: 60_000, maxFiresPerTick: 10 },
+      );
+   });
+
+   afterAll(async () => {
+      if (baseUrl) {
+         try {
+            await fetch(`${baseUrl}/api/v0/environments/${PROJECT_NAME}`, {
+               method: "DELETE",
+            });
+         } catch {
+            // best-effort
+         }
+      }
+      await env?.stop();
+      env = null;
+   });
+
+   async function listMaterializations(): Promise<
+      Array<Record<string, unknown>>
+   > {
+      const res = await fetch(`${baseUrl}${API}/materializations`);
+      expect(res.status).toBe(200);
+      return (await res.json()) as Array<Record<string, unknown>>;
+   }
+
+   function triggerOf(m: Record<string, unknown>): string | undefined {
+      return (m.metadata as { trigger?: string } | null)?.trigger;
+   }
+
+   async function pollTerminal(id: string): Promise<Record<string, unknown>> {
+      const deadline = Date.now() + 60_000;
+      while (Date.now() < deadline) {
+         const res = await fetch(`${baseUrl}${API}/materializations/${id}`);
+         expect(res.status).toBe(200);
+         const m = (await res.json()) as Record<string, unknown>;
+         if (TERMINAL.includes(m.status as string)) return m;
+         await new Promise((r) => setTimeout(r, 250));
+      }
+      throw new Error(`materialization ${id} did not reach a terminal state`);
+   }
+
+   it(
+      "fires a due scheduled package as a SCHEDULER build that completes",
+      async () => {
+         // Arm on the first tick (nextFire is strictly future, so no fire yet).
+         await scheduler.tick(T0);
+         expect(
+            (await listMaterializations()).filter(
+               (m) => triggerOf(m) === "SCHEDULER",
+            ).length,
+         ).toBe(0);
+
+         // Advance well past the daily cron: the sweep fires one SCHEDULER run.
+         await scheduler.tick(T0 + THREE_DAYS_MS);
+
+         const scheduled = (await listMaterializations()).filter(
+            (m) => triggerOf(m) === "SCHEDULER",
+         );
+         expect(scheduled.length).toBe(1);
+
+         // The real build settles at MANIFEST_FILE_READY, producing the table.
+         const built = await pollTerminal(scheduled[0].id as string);
+         expect(built.status).toBe("MANIFEST_FILE_READY");
+         const entries = (
+            built.manifest as { entries: Record<string, unknown> }
+         ).entries;
+         expect(Object.keys(entries).length).toBe(1);
+         // The SCHEDULER trigger must survive the build commit (not just exist
+         // while the run is in-flight) — otherwise a completed scheduled run is
+         // indistinguishable from a manual one.
+         expect(triggerOf(built)).toBe("SCHEDULER");
+
+         // Cleanup: drop the table + record so the negative case starts clean.
+         const del = await fetch(
+            `${baseUrl}${API}/materializations/${scheduled[0].id}?dropTables=true`,
+            { method: "DELETE" },
+         );
+         expect(del.status).toBe(204);
+      },
+      { timeout: 120_000 },
+   );
+
+   it(
+      "never fires a control-plane-driven package (manifestLocation set)",
+      async () => {
+         // Make the package orchestrated: point it at a (bind-clean) manifest.
+         const manifestFile = path.join(
+            os.tmpdir(),
+            `sched-empty-manifest-${T0}.json`,
+         );
+         await fsp.writeFile(
+            manifestFile,
+            JSON.stringify({
+               builtAt: new Date(T0).toISOString(),
+               strict: false,
+               entries: {},
+            }),
+            "utf8",
+         );
+         const patch = await fetch(`${baseUrl}${API}`, {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+               name: PACKAGE_NAME,
+               manifestLocation: manifestFile,
+            }),
+         });
+         expect(patch.ok).toBe(true);
+
+         const before = (await listMaterializations()).length;
+
+         // Even armed + well past the cron, an orchestrated package is skipped
+         // (Guard 2) — the control plane owns its refresh.
+         await scheduler.tick(T0);
+         await scheduler.tick(T0 + THREE_DAYS_MS);
+
+         expect((await listMaterializations()).length).toBe(before);
+
+         await fetch(`${baseUrl}${API}`, {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+               name: PACKAGE_NAME,
+               manifestLocation: null,
+            }),
+         });
+      },
+      { timeout: 60_000 },
+   );
+});

package/tests/integration/materialization/scheduler_recovery.integration.spec.ts

@@ -0,0 +1,172 @@
+/// <reference types="bun-types" />
+
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import path from "path";
+import { fileURLToPath } from "url";
+import { CronEvaluator } from "../../../src/service/cron_evaluator";
+import { MaterializationScheduler } from "../../../src/service/materialization_scheduler";
+import { MaterializationService } from "../../../src/service/materialization_service";
+import { environmentStore } from "../../../src/server";
+import { RestE2EEnv, startRestE2E } from "../../harness/rest_e2e";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PROJECT_NAME = "sched-recovery-project";
+const PACKAGE_NAME = "persist-schedule-test";
+const CRON = "0 6 * * *"; // the fixture's daily schedule
+const API = `/api/v0/environments/${PROJECT_NAME}/packages/${PACKAGE_NAME}`;
+const CONFIG = { tickIntervalMs: 60_000, maxFiresPerTick: 10 };
+const TERMINAL = ["MANIFEST_FILE_READY", "FAILED", "CANCELLED"];
+
+// The restart-recovery anchor is only unit-tested against a stubbed
+// getLatestScheduledFireAt. This drives the real sequence end to end: a real
+// SCHEDULER fire lands a row in the store, then a *second* scheduler instance
+// (a simulated process restart — empty in-memory arming state) re-anchors from
+// that row via the real repo query. We assert exactly one catch-up when an
+// occurrence came due during "downtime", and no double-fire when it didn't.
+describe("MaterializationScheduler restart recovery (E2E, real store)", () => {
+   let env: (RestE2EEnv & { stop(): Promise<void> }) | null = null;
+   let baseUrl: string;
+   let service: MaterializationService;
+   // A fixed anchor for the *first* scheduler's arming clock; the real fire's
+   // created_at (wall clock) is what recovery actually re-anchors from, and we
+   // read it back from the store rather than assuming it.
+   const T0 = Date.parse("2026-01-01T00:00:00Z");
+   const THREE_DAYS_MS = 3 * 24 * 60 * 60 * 1000;
+
+   beforeAll(async () => {
+      env = await startRestE2E();
+      baseUrl = env.baseUrl;
+      service = new MaterializationService(environmentStore);
+
+      const fixtureDir = path.resolve(
+         __dirname,
+         "../../fixtures/persist-schedule-test",
+      );
+      const createRes = await fetch(`${baseUrl}/api/v0/environments`, {
+         method: "POST",
+         headers: { "Content-Type": "application/json" },
+         body: JSON.stringify({
+            name: PROJECT_NAME,
+            packages: [{ name: PACKAGE_NAME, location: fixtureDir }],
+            connections: [],
+         }),
+      });
+      if (!createRes.ok) {
+         throw new Error(
+            `Failed to create test project (${createRes.status}): ${await createRes.text()}`,
+         );
+      }
+
+      // Wait for the package to load into the store the scheduler sweeps.
+      const deadline = Date.now() + 30_000;
+      while (Date.now() < deadline) {
+         const res = await fetch(`${baseUrl}${API}`);
+         if (res.ok) break;
+         await new Promise((r) => setTimeout(r, 500));
+      }
+   });
+
+   afterAll(async () => {
+      if (baseUrl) {
+         try {
+            await fetch(`${baseUrl}/api/v0/environments/${PROJECT_NAME}`, {
+               method: "DELETE",
+            });
+         } catch {
+            // best-effort
+         }
+      }
+      await env?.stop();
+      env = null;
+   });
+
+   function newScheduler(): MaterializationScheduler {
+      // A fresh instance == a process restart: no in-memory arming state, so the
+      // first arm re-anchors from the store.
+      return new MaterializationScheduler(environmentStore, service, CONFIG);
+   }
+
+   async function scheduledCount(): Promise<number> {
+      const res = await fetch(`${baseUrl}${API}/materializations`);
+      expect(res.status).toBe(200);
+      const rows = (await res.json()) as Array<Record<string, unknown>>;
+      return rows.filter(
+         (m) =>
+            (m.metadata as { trigger?: string } | null)?.trigger ===
+            "SCHEDULER",
+      ).length;
+   }
+
+   async function pollAllTerminal(): Promise<void> {
+      const deadline = Date.now() + 90_000;
+      while (Date.now() < deadline) {
+         const res = await fetch(`${baseUrl}${API}/materializations`);
+         const rows = (await res.json()) as Array<Record<string, unknown>>;
+         if (rows.every((m) => TERMINAL.includes(m.status as string))) return;
+         await new Promise((r) => setTimeout(r, 250));
+      }
+      throw new Error("materializations did not all reach a terminal state");
+   }
+
+   it(
+      "recovers exactly one missed occurrence across a restart, then jumps forward",
+      async () => {
+         const cron = new CronEvaluator();
+
+         // ── Scheduler #1: produce a real baseline SCHEDULER fire. ──
+         const s1 = newScheduler();
+         await s1.tick(T0); // arm (nextFire strictly future -> no fire)
+         expect(await scheduledCount()).toBe(0);
+         await s1.tick(T0 + THREE_DAYS_MS); // an occurrence is due -> one fire
+         expect(await scheduledCount()).toBe(1);
+         await pollAllTerminal();
+
+         // The instant recovery re-anchors from is the newest SCHEDULER row's
+         // created_at (wall clock), read through the same path the scheduler uses.
+         const lastFire = await service.getLatestScheduledFireAt(
+            PROJECT_NAME,
+            PACKAGE_NAME,
+         );
+         expect(lastFire).not.toBeNull();
+         const missedOccurrence = cron.nextAfter(CRON, lastFire!).getTime();
+
+         // ── Scheduler #2: simulated restart with an occurrence missed during
+         // downtime (now is just past the first occurrence after the last fire). ──
+         const s2 = newScheduler();
+         await s2.tick(missedOccurrence + 60_000); // due on first arm -> catch up
+         expect(await scheduledCount()).toBe(2); // exactly one catch-up
+         await pollAllTerminal();
+         // Advanced forward: the same instance does not fire again next tick.
+         await s2.tick(missedOccurrence + 120_000);
+         expect(await scheduledCount()).toBe(2);
+      },
+      { timeout: 200_000 },
+   );
+
+   it(
+      "does not double-fire on a restart when no occurrence was missed",
+      async () => {
+         const cron = new CronEvaluator();
+         const before = await scheduledCount();
+
+         // Latest SCHEDULER fire is the catch-up above (created_at ~ now). The
+         // next occurrence after it is the next 06:00 UTC, hours away.
+         const lastFire = await service.getLatestScheduledFireAt(
+            PROJECT_NAME,
+            PACKAGE_NAME,
+         );
+         expect(lastFire).not.toBeNull();
+         const nextOccurrence = cron.nextAfter(CRON, lastFire!).getTime();
+
+         // ── Scheduler #3: simulated restart shortly after the last fire, before
+         // the next occurrence is due -> arms into the future, no catch-up. ──
+         const s3 = newScheduler();
+         await s3.tick(lastFire!.getTime() + 1_000);
+         expect(await scheduledCount()).toBe(before);
+         expect(lastFire!.getTime() + 1_000).toBeLessThan(nextOccurrence);
+      },
+      { timeout: 120_000 },
+   );
+});

package/tests/integration/materialization/scheduler_wiring.integration.spec.ts

@@ -0,0 +1,143 @@
+/// <reference types="bun-types" />
+
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import path from "path";
+import { fileURLToPath } from "url";
+import type { MaterializationScheduler } from "../../../src/service/materialization_scheduler";
+import { MaterializationService } from "../../../src/service/materialization_service";
+import {
+   environmentStore,
+   startMaterializationSchedulerFromEnv,
+} from "../../../src/server";
+import { RestE2EEnv, startRestE2E } from "../../harness/rest_e2e";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PROJECT_NAME = "sched-wiring-project";
+const PACKAGE_NAME = "persist-schedule-test";
+const API = `/api/v0/environments/${PROJECT_NAME}/packages/${PACKAGE_NAME}`;
+
+const ENABLE = "PUBLISHER_LOCAL_MATERIALIZATION_SCHEDULER";
+const INTERVAL = "PUBLISHER_MATERIALIZATION_SCHEDULER_INTERVAL_MS";
+
+// The other scheduler tests hand-construct MaterializationScheduler and call
+// tick() by hand, bypassing the env-var → getMaterializationSchedulerConfig →
+// construct → start()/unref() → real-timer path an operator actually runs. This
+// exercises that wiring: set the flag + a short interval, start the scheduler
+// through the same seam server.ts uses at boot, and observe a build fire through
+// the real timer (not a hand-driven tick).
+describe("MaterializationScheduler wiring (E2E, real env-var timer)", () => {
+   let env: (RestE2EEnv & { stop(): Promise<void> }) | null = null;
+   let baseUrl: string;
+   let scheduler: MaterializationScheduler | null = null;
+   const prev: Record<string, string | undefined> = {};
+
+   beforeAll(async () => {
+      env = await startRestE2E();
+      baseUrl = env.baseUrl;
+
+      const fixtureDir = path.resolve(
+         __dirname,
+         "../../fixtures/persist-schedule-test",
+      );
+      const createRes = await fetch(`${baseUrl}/api/v0/environments`, {
+         method: "POST",
+         headers: { "Content-Type": "application/json" },
+         body: JSON.stringify({
+            name: PROJECT_NAME,
+            packages: [{ name: PACKAGE_NAME, location: fixtureDir }],
+            connections: [],
+         }),
+      });
+      if (!createRes.ok) {
+         throw new Error(
+            `Failed to create test project (${createRes.status}): ${await createRes.text()}`,
+         );
+      }
+
+      // Wait for the package to load, then switch it to an every-minute cron so
+      // the real timer fires within the test window (the fixture ships a daily
+      // cron, which a wall-clock test can't wait on).
+      const deadline = Date.now() + 30_000;
+      while (Date.now() < deadline) {
+         const res = await fetch(`${baseUrl}${API}`);
+         if (res.ok) break;
+         await new Promise((r) => setTimeout(r, 500));
+      }
+      const patch = await fetch(`${baseUrl}${API}`, {
+         method: "PATCH",
+         headers: { "Content-Type": "application/json" },
+         body: JSON.stringify({
+            name: PACKAGE_NAME,
+            materialization: { schedule: "* * * * *" },
+         }),
+      });
+      expect(patch.ok).toBe(true);
+   });
+
+   afterAll(async () => {
+      scheduler?.stop();
+      // Restore env so the shared test process isn't left with the flag set.
+      for (const key of [ENABLE, INTERVAL]) {
+         if (prev[key] === undefined) delete process.env[key];
+         else process.env[key] = prev[key];
+      }
+      if (baseUrl) {
+         try {
+            await fetch(`${baseUrl}/api/v0/environments/${PROJECT_NAME}`, {
+               method: "DELETE",
+            });
+         } catch {
+            // best-effort
+         }
+      }
+      await env?.stop();
+      env = null;
+   });
+
+   it(
+      "boots the scheduler from env config and fires a build through the real timer",
+      async () => {
+         // Enable via the real env-var path and use the minimum 1s sweep so the
+         // every-minute cron is picked up promptly once its boundary passes.
+         prev[ENABLE] = process.env[ENABLE];
+         prev[INTERVAL] = process.env[INTERVAL];
+         process.env[ENABLE] = "true";
+         process.env[INTERVAL] = "1000";
+
+         scheduler = startMaterializationSchedulerFromEnv(
+            environmentStore,
+            new MaterializationService(environmentStore),
+         );
+         // The config path must have constructed + started a scheduler (a null
+         // here would mean the enable flag wasn't honored).
+         expect(scheduler).not.toBeNull();
+
+         // Wait for the real timer to fire a SCHEDULER build and for it to build.
+         const deadline = Date.now() + 150_000;
+         let built: Record<string, unknown> | null = null;
+         while (Date.now() < deadline && !built) {
+            const res = await fetch(`${baseUrl}${API}/materializations`);
+            const rows = (await res.json()) as Array<Record<string, unknown>>;
+            built =
+               rows.find(
+                  (m) =>
+                     (m.metadata as { trigger?: string } | null)?.trigger ===
+                        "SCHEDULER" && m.status === "MANIFEST_FILE_READY",
+               ) ?? null;
+            if (!built) await new Promise((r) => setTimeout(r, 1_000));
+         }
+
+         expect(built).not.toBeNull();
+         const entries = (
+            built!.manifest as { entries: Record<string, unknown> }
+         ).entries;
+         expect(Object.keys(entries).length).toBe(1);
+
+         // Stop the timer before the test ends so it can't fire into other files.
+         scheduler!.stop();
+      },
+      { timeout: 180_000 },
+   );
+});

package/dist/app/assets/EnvironmentPage-EW2lbGvb.js

@@ -1 +0,0 @@
-import{W as r,G as t,j as e,$ as i,a5 as o}from"./index-EqslXZ44.js";function m(){const s=r(),{environmentName:n}=t();if(n){const a=i({environmentName:n});return e.jsx(o,{onSelectPackage:s,resourceUri:a})}else return e.jsx("div",{children:e.jsx("h2",{children:"Missing environment name"})})}export{m as default};