@pd4castr/cli 1.2.0 → 1.4.0

package/dist/index.js

@@ -1,49 +1,6 @@
 #!/usr/bin/env node
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __using = (stack, value, async) => {
-  if (value != null) {
-    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
-    var dispose, inner;
-    if (async) dispose = value[__knownSymbol("asyncDispose")];
-    if (dispose === void 0) {
-      dispose = value[__knownSymbol("dispose")];
-      if (async) inner = dispose;
-    }
-    if (typeof dispose !== "function") __typeError("Object not disposable");
-    if (inner) dispose = function() {
-      try {
-        inner.call(this);
-      } catch (e) {
-        return Promise.reject(e);
-      }
-    };
-    stack.push([async, dispose, value]);
-  } else if (async) {
-    stack.push([async]);
-  }
-  return value;
-};
-var __callDispose = (stack, error, hasError) => {
-  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
-    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
-  };
-  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
-  var next = (it) => {
-    while (it = stack.pop()) {
-      try {
-        var result = it[1] && it[1].call(it[2]);
-        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
-      } catch (e) {
-        fail(e);
-      }
-    }
-    if (hasError) throw error;
-  };
-  return next();
-};
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/constants.ts
 var AUTH0_DOMAIN = "pdview.au.auth0.com";
@@ -77,13 +34,21 @@ import { ZodError } from "zod";
 import { z } from "zod";
 
 // src/utils/is-iana-timezone.ts
-var timezones = /* @__PURE__ */ new Set([...Intl.supportedValuesOf("timeZone"), "UTC"]);
+var timezones = /* @__PURE__ */ new Set([
+  ...Intl.supportedValuesOf("timeZone"),
+  "UTC"
+]);
 function isIanaTimeZone(value) {
   return typeof value === "string" && timezones.has(value);
 }
+__name(isIanaTimeZone, "isIanaTimeZone");
 
 // src/schemas/project-config-schema.ts
-var fileFormatSchema = z.enum(["csv", "json", "parquet"]);
+var fileFormatSchema = z.enum([
+  "csv",
+  "json",
+  "parquet"
+]);
 var aemoDataFetcherSchema = z.object({
   type: z.literal("AEMO_MMS"),
   checkInterval: z.number().int().min(60),
@@ -92,30 +57,63 @@ var aemoDataFetcherSchema = z.object({
     fetchQuery: z.string()
   })
 });
-var dataFetcherSchema = z.discriminatedUnion("type", [aemoDataFetcherSchema]);
+var dataFetcherSchema = z.discriminatedUnion("type", [
+  aemoDataFetcherSchema
+]);
 var modelInputSchema = z.object({
   key: z.string(),
   inputSource: z.string().optional().default(DEFAULT_INPUT_SOURCE_ID),
-  trigger: z.enum(["WAIT_FOR_LATEST_FILE", "USE_MOST_RECENT_FILE"]),
+  trigger: z.enum([
+    "WAIT_FOR_LATEST_FILE",
+    "USE_MOST_RECENT_FILE"
+  ]),
   uploadFileFormat: fileFormatSchema.optional().default("json"),
   targetFileFormat: fileFormatSchema.optional().default("json"),
   fetcher: dataFetcherSchema.optional().nullable()
 });
 var modelOutputSchema = z.object({
   name: z.string(),
-  type: z.enum(["float", "integer", "string", "date", "boolean", "unknown"]),
+  type: z.enum([
+    "float",
+    "integer",
+    "string",
+    "date",
+    "boolean",
+    "unknown"
+  ]),
   seriesKey: z.boolean(),
   colour: z.string().regex(/^#[0-9A-Fa-f]{6}$/).optional()
 });
+var sensitivitySchema = z.object({
+  name: z.string(),
+  query: z.string()
+});
+var inputAggregationSchema = z.object({
+  name: z.string(),
+  query: z.string(),
+  description: z.string().optional().default(""),
+  colours: z.array(z.string()).optional().default([])
+});
 var CONFIG_WARNING_KEY = "// WARNING: DO NOT MODIFY THESE SYSTEM MANAGED VALUES";
 var projectConfigSchema = z.object({
   name: z.string(),
-  forecastVariable: z.enum(["price"]),
-  timeHorizon: z.enum(["actual", "day_ahead", "week_ahead", "quarterly"]),
+  forecastVariable: z.enum([
+    "price"
+  ]),
+  timeHorizon: z.enum([
+    "actual",
+    "day_ahead",
+    "week_ahead",
+    "quarterly"
+  ]),
   displayTimezone: z.string().refine(isIanaTimeZone, "invalid IANA time zone").optional().default("Australia/Brisbane"),
   metadata: z.record(z.string(), z.any()).optional(),
+  public: z.boolean().optional().default(false),
+  runDatetimeQuery: z.string().optional().nullable().default(null),
   inputs: z.array(modelInputSchema),
+  inputAggregations: z.array(inputAggregationSchema).optional().default([]),
   outputs: z.array(modelOutputSchema),
+  sensitivities: z.array(sensitivitySchema).optional().default([]),
   [CONFIG_WARNING_KEY]: z.string().optional().default(""),
   $$id: z.string().nullable().optional().default(null),
   $$modelGroupID: z.string().nullable().optional().default(null),
@@ -133,6 +131,7 @@ async function isExistingPath(path15) {
     return false;
   }
 }
+__name(isExistingPath, "isExistingPath");
 
 // src/config/load-project-context.ts
 async function loadProjectContext(configPath) {
@@ -140,9 +139,7 @@ async function loadProjectContext(configPath) {
   const resolvedConfigPath = configPath ? path.resolve(configPath) : path.join(projectRoot, PROJECT_CONFIG_FILE);
   const configExists = await isExistingPath(resolvedConfigPath);
   if (!configExists) {
-    throw new Error(
-      `No config found at ${resolvedConfigPath} (docs: https://github.com/pipelabs/pd4castr-model-examples/blob/main/docs/005-config.md).`
-    );
+    throw new Error(`No config found at ${resolvedConfigPath} (docs: https://github.com/pipelabs/pd4castr-model-examples/blob/main/docs/005-config.md).`);
   }
   try {
     const configFileContents = await fs2.readFile(resolvedConfigPath, "utf8");
@@ -156,11 +153,10 @@ async function loadProjectContext(configPath) {
     if (error instanceof ZodError) {
       throw error;
     }
-    throw new Error(
-      "Failed to parse project config (docs: https://github.com/pipelabs/pd4castr-model-examples/blob/main/docs/005-config.md)."
-    );
+    throw new Error("Failed to parse project config (docs: https://github.com/pipelabs/pd4castr-model-examples/blob/main/docs/005-config.md).");
   }
 }
+__name(loadProjectContext, "loadProjectContext");
 
 // src/utils/create-link.ts
 var ESC = "\x1B";
@@ -171,11 +167,13 @@ function createLink(text, url) {
   const end = `${OSC}8${SEP}${SEP}${ESC}\\`;
   return `${start}${text}${end}`;
 }
+__name(createLink, "createLink");
 
 // src/utils/format-nest-error-message.ts
 function formatNestErrorMessage(error) {
   return `[${error.error?.toUpperCase() ?? "UNKNOWN"}] ${error.message}`;
 }
+__name(formatNestErrorMessage, "formatNestErrorMessage");
 
 // src/utils/get-auth.ts
 import invariant from "tiny-invariant";
@@ -208,18 +206,21 @@ async function loadGlobalConfig() {
     return getDefaultConfig();
   }
 }
+__name(loadGlobalConfig, "loadGlobalConfig");
 function getDefaultConfig() {
   return {
     accessToken: null,
     accessTokenExpiresAt: null
   };
 }
+__name(getDefaultConfig, "getDefaultConfig");
 
 // src/utils/is-authed.ts
 function isAuthed(config) {
   const isTokenExpired = config.accessTokenExpiresAt && config.accessTokenExpiresAt <= Date.now();
   return Boolean(config.accessToken) && !isTokenExpired;
 }
+__name(isAuthed, "isAuthed");
 
 // src/utils/get-auth.ts
 async function getAuth() {
@@ -234,6 +235,7 @@ async function getAuth() {
     expiresAt: config.accessTokenExpiresAt
   };
 }
+__name(getAuth, "getAuth");
 
 // src/utils/log-zod-issues.ts
 function logZodIssues(error) {
@@ -241,6 +243,7 @@ function logZodIssues(error) {
     console.log(`  \u2718 ${issue.path.join(".")} - ${issue.message}`);
   }
 }
+__name(logZodIssues, "logZodIssues");
 
 // src/commands/fetch/utils/fetch-aemo-data.ts
 import fs4 from "fs/promises";
@@ -255,9 +258,7 @@ var envSchema = z3.object({
   // wsl sets this environment variable on all distros that i've checked
   isWSL: z3.boolean().default(() => Boolean(process.env.WSL_DISTRO_NAME)),
   apiURL: z3.string().default(() => process.env.PD4CASTR_API_URL ?? DEFAULT_API_URL),
-  wslNetworkInterface: z3.string().default(
-    () => process.env.PD4CASTR_WSL_NETWORK_INTERFACE ?? WSL_NETWORK_INTERFACE_DEFAULT
-  ),
+  wslNetworkInterface: z3.string().default(() => process.env.PD4CASTR_WSL_NETWORK_INTERFACE ?? WSL_NETWORK_INTERFACE_DEFAULT),
   auth0ClientId: z3.string().default(() => process.env.PD4CASTR_AUTH0_CLIENT_ID ?? AUTH0_CLIENT_ID),
   auth0Audience: z3.string().default(() => process.env.PD4CASTR_AUTH0_AUDIENCE ?? AUTH0_AUDIENCE)
 });
@@ -266,6 +267,7 @@ var envSchema = z3.object({
 function getEnv() {
   return envSchema.parse(process.env);
 }
+__name(getEnv, "getEnv");
 
 // src/api/api.ts
 var api = ky.create({
@@ -274,22 +276,29 @@ var api = ky.create({
 
 // src/api/query-data-fetcher.ts
 async function queryDataFetcher(querySQL, authCtx) {
-  const headers = { Authorization: `Bearer ${authCtx.accessToken}` };
-  const payload = { query: querySQL, type: "AEMO_MMS" };
-  const result = await api.post("data-fetcher/query", { json: payload, headers }).json();
+  const headers = {
+    Authorization: `Bearer ${authCtx.accessToken}`
+  };
+  const payload = {
+    query: querySQL,
+    type: "AEMO_MMS"
+  };
+  const result = await api.post("data-fetcher/query", {
+    json: payload,
+    headers
+  }).json();
   return result;
 }
+__name(queryDataFetcher, "queryDataFetcher");
 
 // src/commands/fetch/utils/fetch-aemo-data.ts
 async function fetchAEMOData(dataFetcher, authCtx, ctx) {
-  const queryPath = path3.resolve(
-    ctx.projectRoot,
-    dataFetcher.config.fetchQuery
-  );
+  const queryPath = path3.resolve(ctx.projectRoot, dataFetcher.config.fetchQuery);
   const querySQL = await fs4.readFile(queryPath, "utf8");
   const result = await queryDataFetcher(querySQL, authCtx);
   return result;
 }
+__name(fetchAEMOData, "fetchAEMOData");
 
 // src/commands/fetch/utils/get-fetcher.ts
 var DATA_FETCHER_FNS = {
@@ -302,6 +311,7 @@ function getFetcher(type) {
   }
   return fetcher;
 }
+__name(getFetcher, "getFetcher");
 
 // src/commands/fetch/utils/write-test-data.ts
 import fs5 from "fs/promises";
@@ -311,18 +321,24 @@ import path4 from "path";
 function getInputFilename(modelInput) {
   return `${modelInput.key}.${modelInput.targetFileFormat}`;
 }
+__name(getInputFilename, "getInputFilename");
 
 // src/commands/fetch/utils/write-test-data.ts
 async function writeTestData(inputData, modelInput, inputDataDir, ctx) {
   const inputDir = path4.resolve(ctx.projectRoot, inputDataDir);
-  await fs5.mkdir(inputDir, { recursive: true });
+  await fs5.mkdir(inputDir, {
+    recursive: true
+  });
   const inputFilename = getInputFilename(modelInput);
   const inputPath = path4.resolve(inputDir, inputFilename);
   await fs5.writeFile(inputPath, JSON.stringify(inputData, void 0, 2));
 }
+__name(writeTestData, "writeTestData");
 
 // src/commands/fetch/handle-action.ts
-var FETCHABLE_DATA_FETCHER_TYPES = /* @__PURE__ */ new Set(["AEMO_MMS"]);
+var FETCHABLE_DATA_FETCHER_TYPES = /* @__PURE__ */ new Set([
+  "AEMO_MMS"
+]);
 async function handleAction(options) {
   const spinner = ora("Starting data fetch...").start();
   try {
@@ -339,9 +355,7 @@ async function handleAction(options) {
         continue;
       }
       if (!FETCHABLE_DATA_FETCHER_TYPES.has(input2.fetcher.type)) {
-        spinner.warn(
-          `\`${input2.key}\` (${input2.fetcher.type}) - unsupported, skipping`
-        );
+        spinner.warn(`\`${input2.key}\` (${input2.fetcher.type}) - unsupported, skipping`);
         continue;
       }
       spinner.start(`\`${input2.key}\` (${input2.fetcher.type}) - fetching...`);
@@ -373,15 +387,13 @@ ${link} to view fetched data
     process.exit(1);
   }
 }
+__name(handleAction, "handleAction");
 
 // src/commands/fetch/index.ts
 function registerFetchCommand(program2) {
-  program2.command("fetch").description("Fetches test data from configured data fetchers.").option(
-    "-i, --input-dir <path>",
-    "The input test data directory",
-    TEST_INPUT_DATA_DIR
-  ).option("-c, --config <path>", "Path to config file", PROJECT_CONFIG_FILE).action(handleAction);
+  program2.command("fetch").description("Fetches test data from configured data fetchers.").option("-i, --input-dir <path>", "The input test data directory", TEST_INPUT_DATA_DIR).option("-c, --config <path>", "Path to config file", PROJECT_CONFIG_FILE).action(handleAction);
 }
+__name(registerFetchCommand, "registerFetchCommand");
 
 // src/commands/init/handle-action.ts
 import path6 from "path";
@@ -408,6 +420,7 @@ var templates = {
 function getTemplatePath(template) {
   return `https://github.com/${template.repo}/${template.path}`;
 }
+__name(getTemplatePath, "getTemplatePath");
 
 // src/commands/init/utils/validate-name.ts
 async function validateName(value) {
@@ -417,6 +430,7 @@ async function validateName(value) {
   }
   return true;
 }
+__name(validateName, "validateName");
 
 // src/commands/init/handle-action.ts
 async function handleAction2() {
@@ -446,6 +460,7 @@ async function handleAction2() {
     process.exit(1);
   }
 }
+__name(handleAction2, "handleAction");
 async function fetchTemplate(template, projectName) {
   const templatePath = getTemplatePath(templates[template]);
   const fetcher = tiged(templatePath, {
@@ -455,11 +470,13 @@ async function fetchTemplate(template, projectName) {
   const destination = path6.join(process.cwd(), projectName);
   await fetcher.clone(destination);
 }
+__name(fetchTemplate, "fetchTemplate");
 
 // src/commands/init/index.ts
 function registerInitCommand(program2) {
   program2.command("init").description("Initialize a new model using a template.").action(handleAction2);
 }
+__name(registerInitCommand, "registerInitCommand");
 
 // src/commands/login/handle-action.ts
 import { ExecaError as ExecaError3 } from "execa";
@@ -477,16 +494,22 @@ async function updateGlobalConfig(updateFn) {
   const configPath = path7.join(os2.homedir(), GLOBAL_CONFIG_FILE);
   await fs6.writeFile(configPath, JSON.stringify(updatedConfig, void 0, 2));
 }
+__name(updateGlobalConfig, "updateGlobalConfig");
 
 // src/commands/login/utils/complete-auth-flow.ts
 import { HTTPError as HTTPError2 } from "ky";
 
 // src/commands/login/auth0-api.ts
 import ky2 from "ky";
-var auth0API = ky2.create({ prefixUrl: `https://${AUTH0_DOMAIN}` });
+var auth0API = ky2.create({
+  prefixUrl: `https://${AUTH0_DOMAIN}`
+});
 
 // src/commands/login/utils/complete-auth-flow.ts
-var FAILED_AUTH_ERRORS = /* @__PURE__ */ new Set(["expired_token", "access_denied"]);
+var FAILED_AUTH_ERRORS = /* @__PURE__ */ new Set([
+  "expired_token",
+  "access_denied"
+]);
 async function completeAuthFlow(authCtx) {
   const env = getEnv();
   const payload = {
@@ -496,7 +519,9 @@ async function completeAuthFlow(authCtx) {
   };
   async function fetchAuthResponse() {
     try {
-      const response = await auth0API.post("oauth/token", { json: payload }).json();
+      const response = await auth0API.post("oauth/token", {
+        json: payload
+      }).json();
       const authPayload = {
         accessToken: response.access_token,
         expiresAt: Date.now() + response.expires_in * 1e3
@@ -509,18 +534,16 @@ async function completeAuthFlow(authCtx) {
       const errorResponse = await error.response.json();
       const isFailedAuthError = FAILED_AUTH_ERRORS.has(errorResponse.error);
       if (isFailedAuthError) {
-        throw new Error(
-          `Login failed, please try again (${errorResponse.error_description}).`
-        );
+        throw new Error(`Login failed, please try again (${errorResponse.error_description}).`);
       }
       const delay = authCtx.checkInterval * 1e3;
-      return new Promise(
-        (resolve) => setTimeout(() => resolve(fetchAuthResponse()), delay)
-      );
+      return new Promise((resolve) => setTimeout(() => resolve(fetchAuthResponse()), delay));
     }
   }
+  __name(fetchAuthResponse, "fetchAuthResponse");
   return fetchAuthResponse();
 }
+__name(completeAuthFlow, "completeAuthFlow");
 
 // src/commands/login/utils/start-auth-flow.ts
 async function startAuthFlow() {
@@ -530,7 +553,9 @@ async function startAuthFlow() {
     audience: env.auth0Audience,
     scope: "openid email"
   };
-  const codeResponse = await auth0API.post("oauth/device/code", { json: payload }).json();
+  const codeResponse = await auth0API.post("oauth/device/code", {
+    json: payload
+  }).json();
   const authContext = {
     deviceCode: codeResponse.device_code,
     verificationURL: codeResponse.verification_uri_complete,
@@ -539,6 +564,7 @@ async function startAuthFlow() {
   };
   return authContext;
 }
+__name(startAuthFlow, "startAuthFlow");
 
 // src/commands/login/handle-action.ts
 async function handleAction3() {
@@ -550,10 +576,8 @@ async function handleAction3() {
       return;
     }
     const authCtx = await startAuthFlow();
-    spinner.info(
-      `Please open the login link in your browser:
-	${authCtx.verificationURL}`
-    );
+    spinner.info(`Please open the login link in your browser:
+	${authCtx.verificationURL}`);
     spinner.info(`Your login code is:
 	${authCtx.userCode}
 `);
@@ -579,11 +603,13 @@ async function handleAction3() {
     process.exit(1);
   }
 }
+__name(handleAction3, "handleAction");
 
 // src/commands/login/index.ts
 function registerLoginCommand(program2) {
   program2.command("login").description("Logs in to the pd4castr API.").action(handleAction3);
 }
+__name(registerLoginCommand, "registerLoginCommand");
 
 // src/commands/logout/handle-action.ts
 import { ExecaError as ExecaError4 } from "execa";
@@ -617,11 +643,13 @@ async function handleAction4() {
     process.exit(1);
   }
 }
+__name(handleAction4, "handleAction");
 
 // src/commands/logout/index.ts
 function registerLogoutCommand(program2) {
   program2.command("logout").description("Logs out of the pd4castr API.").action(handleAction4);
 }
+__name(registerLogoutCommand, "registerLogoutCommand");
 
 // src/commands/publish/handle-action.ts
 import { ExecaError as ExecaError5 } from "execa";
@@ -641,6 +669,7 @@ async function startWebServer(app, port) {
     });
   });
 }
+__name(startWebServer, "startWebServer");
 
 // src/commands/publish/handle-create-model-flow.ts
 import * as inquirer2 from "@inquirer/prompts";
@@ -648,25 +677,42 @@ import chalk3 from "chalk";
 
 // src/api/create-model.ts
 async function createModel(config, authCtx) {
-  const headers = { Authorization: `Bearer ${authCtx.accessToken}` };
-  const result = await api.post("model", { headers, json: config }).json();
+  const headers = {
+    Authorization: `Bearer ${authCtx.accessToken}`
+  };
+  const result = await api.post("model", {
+    headers,
+    json: config
+  }).json();
   return result;
 }
+__name(createModel, "createModel");
 
 // src/api/get-registry-push-credentials.ts
 async function getRegistryPushCredentials(modelID, authCtx) {
-  const headers = { Authorization: `Bearer ${authCtx.accessToken}` };
+  const headers = {
+    Authorization: `Bearer ${authCtx.accessToken}`
+  };
   const searchParams = new URLSearchParams(`modelId=${modelID}`);
-  const result = await api.get("registry/push-credentials", { headers, searchParams }).json();
+  const result = await api.get("registry/push-credentials", {
+    headers,
+    searchParams
+  }).json();
   return result;
 }
+__name(getRegistryPushCredentials, "getRegistryPushCredentials");
 
 // src/api/trigger-model-run.ts
 async function triggerModelRun(modelId, authCtx) {
-  const headers = { Authorization: `Bearer ${authCtx.accessToken}` };
-  const result = await api.post(`model/${modelId}/trigger`, { headers }).json();
+  const headers = {
+    Authorization: `Bearer ${authCtx.accessToken}`
+  };
+  const result = await api.post(`model/${modelId}/trigger`, {
+    headers
+  }).json();
   return result;
 }
+__name(triggerModelRun, "triggerModelRun");
 
 // src/config/update-project-config.ts
 import fs7 from "fs/promises";
@@ -676,73 +722,93 @@ async function updateProjectConfig(updateFn, configPath) {
   const projectConfig = await loadProjectContext(configPath);
   const updatedConfig = produce2(projectConfig.config, updateFn);
   const resolvedConfigPath = configPath ? path8.resolve(configPath) : path8.join(projectConfig.projectRoot, PROJECT_CONFIG_FILE);
-  await fs7.writeFile(
-    resolvedConfigPath,
-    JSON.stringify(updatedConfig, void 0, 2)
-  );
+  await fs7.writeFile(resolvedConfigPath, JSON.stringify(updatedConfig, void 0, 2));
 }
+__name(updateProjectConfig, "updateProjectConfig");
 
 // src/docker/build-docker-image.ts
 import { execa } from "execa";
 async function buildDockerImage(dockerImage, ctx) {
   try {
-    await execa(
-      "docker",
-      ["build", "--platform=linux/amd64", "-t", dockerImage, "."],
-      {
-        cwd: ctx.projectRoot,
-        stdio: "pipe"
-      }
-    );
+    await execa("docker", [
+      "build",
+      "--platform=linux/amd64",
+      "-t",
+      dockerImage,
+      "."
+    ], {
+      cwd: ctx.projectRoot,
+      stdio: "pipe"
+    });
   } catch (error) {
-    throw new Error("Failed to build docker image", { cause: error });
+    throw new Error("Failed to build docker image", {
+      cause: error
+    });
   }
 }
+__name(buildDockerImage, "buildDockerImage");
 
 // src/docker/login-to-docker-registry.ts
 import { execa as execa2 } from "execa";
 async function loginToDockerRegistry(authConfig) {
   try {
-    await execa2(
-      "docker",
-      [
-        "login",
-        authConfig.registry,
-        "--username",
-        authConfig.username,
-        "--password-stdin"
-      ],
-      { input: authConfig.password }
-    );
+    await execa2("docker", [
+      "login",
+      authConfig.registry,
+      "--username",
+      authConfig.username,
+      "--password-stdin"
+    ], {
+      input: authConfig.password
+    });
   } catch (error) {
-    throw new Error("Failed to login to docker registry", { cause: error });
+    throw new Error("Failed to login to docker registry", {
+      cause: error
+    });
   }
 }
+__name(loginToDockerRegistry, "loginToDockerRegistry");
 
 // src/docker/push-docker-image.ts
 import { execa as execa3 } from "execa";
 async function pushDockerImage(dockerImage, pushRef) {
   try {
-    await execa3("docker", ["tag", dockerImage, pushRef]);
-    await execa3("docker", ["push", pushRef]);
+    await execa3("docker", [
+      "tag",
+      dockerImage,
+      pushRef
+    ]);
+    await execa3("docker", [
+      "push",
+      pushRef
+    ]);
   } catch (error) {
-    throw new Error("Failed to push docker image", { cause: error });
+    throw new Error("Failed to push docker image", {
+      cause: error
+    });
   }
 }
+__name(pushDockerImage, "pushDockerImage");
 
 // src/utils/get-docker-image.ts
 import slugify from "slugify";
 function getDockerImage(ctx) {
-  const sluggedName = slugify(ctx.config.name, { lower: true });
+  const sluggedName = slugify(ctx.config.name, {
+    lower: true
+  });
   const dockerImage = `pd4castr/${sluggedName}-local:${Date.now()}`;
   return dockerImage;
 }
+__name(getDockerImage, "getDockerImage");
 
 // src/utils/get-model-config-from-project-config.ts
 import fs8 from "fs/promises";
 import path9 from "path";
 async function getModelConfigFromProjectConfig(ctx) {
   const inputs = await getInputsWithInlinedSQL(ctx);
+  const sensitivities = await getSensitivitiesWithInlinedSQL(ctx);
+  const inputAggregations = await getInputAggregationsWithInlinedSQL(ctx);
+  const runDatetimeQuery = await getrunDatetimeQuerySQL(ctx);
   const { $$id, $$modelGroupID, $$revision, $$dockerImage, ...config } = ctx.config;
   return {
     ...config,
@@ -750,10 +816,16 @@ async function getModelConfigFromProjectConfig(ctx) {
     modelGroupId: $$modelGroupID,
     revision: $$revision ?? 0,
     dockerImage: $$dockerImage,
-    inputs
+    inputs,
+    sensitivities,
+    inputAggregations,
+    runDatetimeQuery
   };
 }
-var FETCHERS_WITH_SQL = /* @__PURE__ */ new Set(["AEMO_MMS"]);
+__name(getModelConfigFromProjectConfig, "getModelConfigFromProjectConfig");
+var FETCHERS_WITH_SQL = /* @__PURE__ */ new Set([
+  "AEMO_MMS"
+]);
 async function getInputsWithInlinedSQL(ctx) {
   const inputsWithSQL = [];
   for (const input2 of ctx.config.inputs) {
@@ -761,14 +833,8 @@ async function getInputsWithInlinedSQL(ctx) {
       inputsWithSQL.push(input2);
       continue;
     }
-    const fetchQueryPath = path9.resolve(
-      ctx.projectRoot,
-      input2.fetcher.config.fetchQuery
-    );
-    const checkQueryPath = path9.resolve(
-      ctx.projectRoot,
-      input2.fetcher.config.checkQuery
-    );
+    const fetchQueryPath = path9.resolve(ctx.projectRoot, input2.fetcher.config.fetchQuery);
+    const checkQueryPath = path9.resolve(ctx.projectRoot, input2.fetcher.config.checkQuery);
     const [fetchQuerySQL, checkQuerySQL] = await Promise.all([
       fs8.readFile(fetchQueryPath, "utf8"),
       fs8.readFile(checkQueryPath, "utf8")
@@ -788,11 +854,61 @@ async function getInputsWithInlinedSQL(ctx) {
   }
   return inputsWithSQL;
 }
+__name(getInputsWithInlinedSQL, "getInputsWithInlinedSQL");
+async function getSensitivitiesWithInlinedSQL(ctx) {
+  const sensitivitiesWithSQL = [];
+  const sensitivities = ctx.config.sensitivities ?? [];
+  for (const sensitivity of sensitivities) {
+    const queryPath = path9.resolve(ctx.projectRoot, sensitivity.query);
+    try {
+      const sql = await fs8.readFile(queryPath, "utf8");
+      sensitivitiesWithSQL.push({
+        ...sensitivity,
+        query: sql
+      });
+    } catch {
+      throw new Error(`Sensitivity query file not found (${sensitivity.query})`);
+    }
+  }
+  return sensitivitiesWithSQL;
+}
+__name(getSensitivitiesWithInlinedSQL, "getSensitivitiesWithInlinedSQL");
+async function getInputAggregationsWithInlinedSQL(ctx) {
+  const inputAggregationsWithSQL = [];
+  for (const inputAggregation of ctx.config.inputAggregations) {
+    const queryPath = path9.resolve(ctx.projectRoot, inputAggregation.query);
+    try {
+      const sql = await fs8.readFile(queryPath, "utf8");
+      inputAggregationsWithSQL.push({
+        ...inputAggregation,
+        query: sql
+      });
+    } catch {
+      throw new Error(`Input aggregation query file not found (${inputAggregation.query})`);
+    }
+  }
+  return inputAggregationsWithSQL;
+}
+__name(getInputAggregationsWithInlinedSQL, "getInputAggregationsWithInlinedSQL");
+async function getrunDatetimeQuerySQL(ctx) {
+  if (!ctx.config.runDatetimeQuery) {
+    return null;
+  }
+  const queryPath = path9.resolve(ctx.projectRoot, ctx.config.runDatetimeQuery);
+  try {
+    const sql = await fs8.readFile(queryPath, "utf8");
+    return sql;
+  } catch {
+    throw new Error(`Run datetime query file not found (${ctx.config.runDatetimeQuery})`);
+  }
+}
+__name(getrunDatetimeQuerySQL, "getrunDatetimeQuerySQL");
 
 // src/utils/log-empty-line.ts
 function logEmptyLine() {
   console.log("");
 }
+__name(logEmptyLine, "logEmptyLine");
 
 // src/commands/publish/constants.ts
 import chalk from "chalk";
@@ -810,21 +926,30 @@ function getModelSummaryLines(ctx) {
     `	${chalk2.bold("Revision:")} ${ctx.config.$$revision}`,
     `	${chalk2.bold("Forecast variable:")} ${ctx.config.forecastVariable}`,
     `	${chalk2.bold("Time horizon:")} ${ctx.config.timeHorizon}`,
+    `	${chalk2.bold("Public:")} ${ctx.config.public}`,
     `	${chalk2.bold("Inputs:")}`,
-    ...ctx.config.inputs.map(
-      (input2) => `	\u2022 ${input2.key} - ${getInputType(input2)}`
-    ),
+    ...ctx.config.inputs.map((input2) => `	\u2022 ${input2.key} - ${getInputType(input2)}`),
     `	${chalk2.bold("Outputs:")}`,
     ...ctx.config.outputs.map((output) => `	\u2022 ${output.name} - ${output.type}`),
+    ...ctx.config.inputAggregations.length > 0 ? [
+      `	${chalk2.bold("Input aggregations:")}`,
+      ...ctx.config.inputAggregations.map((agg) => `	\u2022 ${agg.name}`)
+    ] : [],
+    ...ctx.config.sensitivities.length > 0 ? [
+      `	${chalk2.bold("Sensitivities:")}`,
+      ...ctx.config.sensitivities.map((s) => `	\u2022 ${s.name}`)
+    ] : [],
     ""
   ];
 }
+__name(getModelSummaryLines, "getModelSummaryLines");
 function getInputType(input2) {
   if (input2.fetcher) {
     return input2.fetcher.type;
   }
   return "static";
 }
+__name(getInputType, "getInputType");
 
 // src/docker/run-model-container.ts
 import os3 from "os";
@@ -837,17 +962,19 @@ function getInputEnv(modelInput, webserverURL) {
   const inputFileURL = `${webserverURL}/input/${filename}`;
   return `INPUT_${variableName}_URL=${inputFileURL}`;
 }
+__name(getInputEnv, "getInputEnv");
 
 // src/docker/run-model-container.ts
 async function runModelContainer(dockerImage, webserverPort, ctx) {
   const env = getEnv();
   const webserverHostname = env.isWSL ? DOCKER_HOSTNAME_WSL : DOCKER_HOSTNAME_DEFAULT;
   const webserverURL = `http://${webserverHostname}:${webserverPort}`;
-  const inputEnvs = ctx.config.inputs.map(
-    (input2) => getInputEnv(input2, webserverURL)
-  );
+  const inputEnvs = ctx.config.inputs.map((input2) => getInputEnv(input2, webserverURL));
   const outputEnv = `OUTPUT_URL=${webserverURL}/output`;
-  const envs = [...inputEnvs, outputEnv];
+  const envs = [
+    ...inputEnvs,
+    outputEnv
+  ];
   try {
     const extraRunArgs = [];
     if (env.isWSL) {
@@ -858,7 +985,10 @@ async function runModelContainer(dockerImage, webserverPort, ctx) {
       "run",
       "--rm",
       ...extraRunArgs,
-      ...envs.flatMap((env2) => ["--env", env2]),
+      ...envs.flatMap((env2) => [
+        "--env",
+        env2
+      ]),
       dockerImage
     ];
     await execa4("docker", args, {
@@ -866,20 +996,22 @@ async function runModelContainer(dockerImage, webserverPort, ctx) {
       stdio: "pipe"
     });
   } catch (error) {
-    throw new Error("Failed to run model container", { cause: error });
+    throw new Error("Failed to run model container", {
+      cause: error
+    });
   }
 }
+__name(runModelContainer, "runModelContainer");
 function getWSLMachineIP() {
   const env = getEnv();
   const interfaces = os3.networkInterfaces();
   const interfaceInfo = interfaces[env.wslNetworkInterface]?.[0];
   if (!interfaceInfo) {
-    throw new Error(
-      `WSL machine IP not found for interface \`${env.wslNetworkInterface}\``
-    );
+    throw new Error(`WSL machine IP not found for interface \`${env.wslNetworkInterface}\``);
   }
   return interfaceInfo.address;
 }
+__name(getWSLMachineIP, "getWSLMachineIP");
 
 // src/model-io-checks/setup-model-io-checks.ts
 import path12 from "path";
@@ -887,6 +1019,9 @@ import express from "express";
 
 // src/model-io-checks/model-io-checks.ts
 var ModelIOChecks = class {
+  static {
+    __name(this, "ModelIOChecks");
+  }
   inputsToDownload;
   outputUploaded;
   constructor(data) {
@@ -923,17 +1058,16 @@ import path10 from "path";
 function createInputHandler(inputFilesPath, modelIOChecks, ctx) {
   return (req, res) => {
     if (!modelIOChecks.isValidInput(req.params.filename)) {
-      return res.status(404).json({ error: "File not found" });
+      return res.status(404).json({
+        error: "File not found"
+      });
     }
     modelIOChecks.trackInputHandled(req.params.filename);
-    const filePath = path10.join(
-      ctx.projectRoot,
-      inputFilesPath,
-      req.params.filename
-    );
+    const filePath = path10.join(ctx.projectRoot, inputFilesPath, req.params.filename);
     return res.sendFile(filePath);
   };
 }
+__name(createInputHandler, "createInputHandler");
 
 // src/model-io-checks/utils/create-output-handler.ts
 import fs9 from "fs/promises";
@@ -942,17 +1076,24 @@ function createOutputHandler(modelIOChecks, ctx) {
   return async (req, res) => {
     modelIOChecks.trackOutputHandled();
     const outputPath = path11.join(ctx.projectRoot, TEST_OUTPUT_DATA_DIR);
-    await fs9.mkdir(outputPath, { recursive: true });
+    await fs9.mkdir(outputPath, {
+      recursive: true
+    });
     const outputFilePath = path11.join(outputPath, TEST_OUTPUT_FILENAME);
     const outputData = JSON.stringify(req.body, null, 2);
     await fs9.writeFile(outputFilePath, outputData, "utf8");
-    return res.status(200).json({ success: true });
+    return res.status(200).json({
+      success: true
+    });
   };
 }
+__name(createOutputHandler, "createOutputHandler");
 
 // src/model-io-checks/setup-model-io-checks.ts
 function setupModelIOChecks(app, inputDir, inputFiles, ctx) {
-  const modelIOChecks = new ModelIOChecks({ inputFiles });
+  const modelIOChecks = new ModelIOChecks({
+    inputFiles
+  });
   const handleInput = createInputHandler(inputDir, modelIOChecks, ctx);
   const handleOutput = createOutputHandler(modelIOChecks, ctx);
   const inputPath = path12.join(ctx.projectRoot, inputDir);
@@ -962,6 +1103,7 @@ function setupModelIOChecks(app, inputDir, inputFiles, ctx) {
   app.put("/output", handleOutput);
   return modelIOChecks;
 }
+__name(setupModelIOChecks, "setupModelIOChecks");
 
 // src/utils/check-input-files.ts
 import path13 from "path";
@@ -970,37 +1112,31 @@ async function checkInputFiles(inputFiles, inputDataPath, ctx) {
     const filePath = path13.join(ctx.projectRoot, inputDataPath, inputFile);
     const exists = await isExistingPath(filePath);
     if (!exists) {
-      throw new Error(
-        `Input data not found (${inputFile}) - did you need to run \`pd4castr fetch\`?`
-      );
+      throw new Error(`Input data not found (${inputFile}) - did you need to run \`pd4castr fetch\`?`);
     }
   }
 }
+__name(checkInputFiles, "checkInputFiles");
 
 // src/utils/get-input-files.ts
 function getInputFiles(config) {
   const inputFiles = config.inputs.map((input2) => getInputFilename(input2));
   return inputFiles;
 }
+__name(getInputFiles, "getInputFiles");
 
 // src/commands/publish/utils/run-model-io-tests.ts
 async function runModelIOTests(dockerImage, options, app, ctx) {
   const inputFiles = getInputFiles(ctx.config);
   await checkInputFiles(inputFiles, options.inputDir, ctx);
   await buildDockerImage(dockerImage, ctx);
-  const modelIOChecks = setupModelIOChecks(
-    app,
-    options.inputDir,
-    inputFiles,
-    ctx
-  );
+  const modelIOChecks = setupModelIOChecks(app, options.inputDir, inputFiles, ctx);
   await runModelContainer(dockerImage, options.port, ctx);
   if (!modelIOChecks.isInputsHandled() || !modelIOChecks.isOutputHandled()) {
-    throw new Error(
-      "Model I/O test failed. Please run `pd4castr test` to debug the issue."
-    );
+    throw new Error("Model I/O test failed. Please run `pd4castr test` to debug the issue.");
   }
 }
+__name(runModelIOTests, "runModelIOTests");
 
 // src/commands/publish/handle-create-model-flow.ts
 async function handleCreateModelFlow(options, app, spinner, ctx, authCtx) {
@@ -1032,9 +1168,7 @@ async function handleCreateModelFlow(options, app, spinner, ctx, authCtx) {
     config.displayTimezone = model.displayTimezone;
   }, options.config);
   spinner.succeed("Model data published successfully");
-  spinner.start(
-    "Pushing model image to registry - this may take a few minutes..."
-  );
+  spinner.start("Pushing model image to registry - this may take a few minutes...");
   const pushCredentials = await getRegistryPushCredentials(model.id, authCtx);
   await loginToDockerRegistry(pushCredentials);
   await buildDockerImage(dockerImage, ctx);
@@ -1061,6 +1195,7 @@ async function handleCreateModelFlow(options, app, spinner, ctx, authCtx) {
     console.log(MODEL_RUN_TRIGGER_MESSAGE);
   }
 }
+__name(handleCreateModelFlow, "handleCreateModelFlow");
 
 // src/commands/publish/handle-update-existing-model-flow.ts
 import * as inquirer5 from "@inquirer/prompts";
@@ -1075,26 +1210,28 @@ import invariant2 from "tiny-invariant";
 
 // src/api/get-model.ts
 async function getModel(id, authCtx) {
-  const headers = { Authorization: `Bearer ${authCtx.accessToken}` };
-  const result = await api.get(`model/${id}`, { headers }).json();
+  const headers = {
+    Authorization: `Bearer ${authCtx.accessToken}`
+  };
+  const result = await api.get(`model/${id}`, {
+    headers
+  }).json();
   return result;
 }
+__name(getModel, "getModel");
 
 // src/commands/publish/utils/validate-local-model-state.ts
 async function validateLocalModelState(ctx, authCtx) {
   invariant2(ctx.config.$$id, "model ID is required to fetch published model");
   const currentModel = await getModel(ctx.config.$$id, authCtx);
   if (currentModel.revision !== ctx.config.$$revision) {
-    throw new Error(
-      `OUT OF SYNC: Local revision (${ctx.config.$$revision}) does not match the current published revision (${currentModel.revision})`
-    );
+    throw new Error(`OUT OF SYNC: Local revision (${ctx.config.$$revision}) does not match the current published revision (${currentModel.revision})`);
   }
   if (currentModel.modelGroupId !== ctx.config.$$modelGroupID) {
-    throw new Error(
-      `OUT OF SYNC: Local model group ID (${ctx.config.$$modelGroupID}) does not match the current published model group ID (${currentModel.modelGroupId})`
-    );
+    throw new Error(`OUT OF SYNC: Local model group ID (${ctx.config.$$modelGroupID}) does not match the current published model group ID (${currentModel.modelGroupId})`);
   }
 }
+__name(validateLocalModelState, "validateLocalModelState");
 
 // src/commands/publish/handle-model-revision-create-flow.ts
 var WARNING_LABEL = chalk4.yellowBright.bold("WARNING!");
@@ -1130,9 +1267,7 @@ async function handleModelRevisionCreateFlow(options, app, spinner, ctx, authCtx
     config.$$dockerImage = model.dockerImage;
   }, options.config);
   spinner.succeed("Model revision data published successfully");
-  spinner.start(
-    "Pushing new model revision image to registry - this may take a few minutes..."
-  );
+  spinner.start("Pushing new model revision image to registry - this may take a few minutes...");
   const pushCredentials = await getRegistryPushCredentials(model.id, authCtx);
   await loginToDockerRegistry(pushCredentials);
   await buildDockerImage(dockerImage, ctx);
@@ -1153,14 +1288,13 @@ async function handleModelRevisionCreateFlow(options, app, spinner, ctx, authCtx
     symbol: "\u{1F680} ",
     prefixText: "\n",
     suffixText: "\n",
-    text: chalk4.bold(
-      `New model revision (r${model.revision}) published successfully`
-    )
+    text: chalk4.bold(`New model revision (r${model.revision}) published successfully`)
   });
   if (!modelRunTriggered && !options.skipTrigger) {
     console.log(MODEL_RUN_TRIGGER_MESSAGE);
   }
 }
+__name(handleModelRevisionCreateFlow, "handleModelRevisionCreateFlow");
 
 // src/commands/publish/handle-model-revision-update-flow.ts
 import * as inquirer4 from "@inquirer/prompts";
@@ -1168,10 +1302,16 @@ import chalk5 from "chalk";
 
 // src/api/update-model.ts
 async function updateModel(config, authCtx) {
-  const headers = { Authorization: `Bearer ${authCtx.accessToken}` };
-  const result = await api.patch(`model/${config.id}`, { headers, json: config }).json();
+  const headers = {
+    Authorization: `Bearer ${authCtx.accessToken}`
+  };
+  const result = await api.patch(`model/${config.id}`, {
+    headers,
+    json: config
+  }).json();
   return result;
 }
+__name(updateModel, "updateModel");
 
 // src/commands/publish/handle-model-revision-update-flow.ts
 var WARNING_LABEL2 = chalk5.yellowBright.bold("WARNING!");
@@ -1208,9 +1348,7 @@ async function handleModelRevisionUpdateFlow(options, app, spinner, ctx, authCtx
     config.displayTimezone = model.displayTimezone;
   }, options.config);
   spinner.succeed("Model revision data updated successfully");
-  spinner.start(
-    "Pushing updated model image to registry - this may take a few minutes..."
-  );
+  spinner.start("Pushing updated model image to registry - this may take a few minutes...");
   const pushCredentials = await getRegistryPushCredentials(model.id, authCtx);
   await loginToDockerRegistry(pushCredentials);
   await buildDockerImage(dockerImage, ctx);
@@ -1237,6 +1375,7 @@ async function handleModelRevisionUpdateFlow(options, app, spinner, ctx, authCtx
     console.log(MODEL_RUN_TRIGGER_MESSAGE);
   }
 }
+__name(handleModelRevisionUpdateFlow, "handleModelRevisionUpdateFlow");
 
 // src/commands/publish/handle-update-existing-model-flow.ts
 async function handleUpdateExistingModelFlow(options, app, spinner, ctx, authCtx) {
@@ -1248,34 +1387,113 @@ async function handleUpdateExistingModelFlow(options, app, spinner, ctx, authCtx
     message: "Do you want to update the existing revision or create a new one?",
     choices: [
       {
-        value: "new" /* NewRevision */,
+        value: "new",
         name: `New Revision (r${revision} \u2192 r${revision + 1})`
       },
       {
-        value: "update" /* UpdateExisting */,
+        value: "update",
         name: `Update Existing Revision (r${revision})`
       }
     ]
   });
   logEmptyLine();
-  if (action === "new" /* NewRevision */) {
+  if (action === "new") {
     await handleModelRevisionCreateFlow(options, app, spinner, ctx, authCtx);
-  } else if (action === "update" /* UpdateExisting */) {
+  } else if (action === "update") {
     await handleModelRevisionUpdateFlow(options, app, spinner, ctx, authCtx);
   } else {
     throw new Error("Invalid CLI state");
   }
 }
+__name(handleUpdateExistingModelFlow, "handleUpdateExistingModelFlow");
 
 // src/commands/publish/handle-action.ts
+function _ts_add_disposable_resource(env, value, async) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value[Symbol.asyncDispose];
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value[Symbol.dispose];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    if (inner) dispose = /* @__PURE__ */ __name(function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }, "dispose");
+    env.stack.push({
+      value,
+      dispose,
+      async
+    });
+  } else if (async) {
+    env.stack.push({
+      async: true
+    });
+  }
+  return value;
+}
+__name(_ts_add_disposable_resource, "_ts_add_disposable_resource");
+function _ts_dispose_resources(env) {
+  var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  return (_ts_dispose_resources = /* @__PURE__ */ __name(function _ts_dispose_resources3(env2) {
+    function fail(e) {
+      env2.error = env2.hasError ? new _SuppressedError(e, env2.error, "An error was suppressed during disposal.") : e;
+      env2.hasError = true;
+    }
+    __name(fail, "fail");
+    var r, s = 0;
+    function next() {
+      while (r = env2.stack.pop()) {
+        try {
+          if (!r.async && s === 1) return s = 0, env2.stack.push(r), Promise.resolve().then(next);
+          if (r.dispose) {
+            var result = r.dispose.call(r.value);
+            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+              fail(e);
+              return next();
+            });
+          } else s |= 1;
+        } catch (e) {
+          fail(e);
+        }
+      }
+      if (s === 1) return env2.hasError ? Promise.reject(env2.error) : Promise.resolve();
+      if (env2.hasError) throw env2.error;
+    }
+    __name(next, "next");
+    return next();
+  }, "_ts_dispose_resources"))(env);
+}
+__name(_ts_dispose_resources, "_ts_dispose_resources");
 async function handleAction5(options) {
-  var _stack = [];
+  const env = {
+    stack: [],
+    error: void 0,
+    hasError: false
+  };
   try {
     const spinner = ora5("Starting model publish...").start();
     const app = express2();
-    app.use(express2.json({ limit: "100mb" }));
-    app.use(express2.urlencoded({ limit: "100mb", extended: true }));
-    const webServer = __using(_stack, await startWebServer(app, options.port));
+    app.use(express2.json({
+      limit: "100mb"
+    }));
+    app.use(express2.urlencoded({
+      limit: "100mb",
+      extended: true
+    }));
+    const webServer = _ts_add_disposable_resource(env, await startWebServer(app, options.port), false);
     try {
       const ctx = await loadProjectContext(options.config);
       const authCtx = await getAuth();
@@ -1297,25 +1515,20 @@ async function handleAction5(options) {
       }
       process.exit(1);
     }
-  } catch (_) {
-    var _error = _, _hasError = true;
+  } catch (e) {
+    env.error = e;
+    env.hasError = true;
   } finally {
-    __callDispose(_stack, _error, _hasError);
+    _ts_dispose_resources(env);
   }
 }
+__name(handleAction5, "handleAction");
 
 // src/commands/publish/index.ts
 function registerPublishCommand(program2) {
-  program2.command("publish").description("Publishes a pd4castr model.").option(
-    "-i, --input-dir <path>",
-    "The input test data directory",
-    TEST_INPUT_DATA_DIR
-  ).option(
-    "-p, --port <port>",
-    "The port to run the IO testing webserver on",
-    TEST_WEBSERVER_PORT.toString()
-  ).option("--sc, --skip-checks", "Skip the model I/O checks", false).option("--st, --skip-trigger", "Skip the model trigger", false).option("-c, --config <path>", "Path to config file", PROJECT_CONFIG_FILE).action(handleAction5);
+  program2.command("publish").description("Publishes a pd4castr model.").option("-i, --input-dir <path>", "The input test data directory", TEST_INPUT_DATA_DIR).option("-p, --port <port>", "The port to run the IO testing webserver on", TEST_WEBSERVER_PORT.toString()).option("--sc, --skip-checks", "Skip the model I/O checks", false).option("--st, --skip-trigger", "Skip the model trigger", false).option("-c, --config <path>", "Path to config file", PROJECT_CONFIG_FILE).action(handleAction5);
 }
+__name(registerPublishCommand, "registerPublishCommand");
 
 // src/commands/test/handle-action.ts
 import path14 from "path";
@@ -1323,14 +1536,92 @@ import { ExecaError as ExecaError6 } from "execa";
 import express3 from "express";
 import ora6 from "ora";
 import { ZodError as ZodError6 } from "zod";
+function _ts_add_disposable_resource2(env, value, async) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value[Symbol.asyncDispose];
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value[Symbol.dispose];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    if (inner) dispose = /* @__PURE__ */ __name(function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }, "dispose");
+    env.stack.push({
+      value,
+      dispose,
+      async
+    });
+  } else if (async) {
+    env.stack.push({
+      async: true
+    });
+  }
+  return value;
+}
+__name(_ts_add_disposable_resource2, "_ts_add_disposable_resource");
+function _ts_dispose_resources2(env) {
+  var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  return (_ts_dispose_resources2 = /* @__PURE__ */ __name(function _ts_dispose_resources3(env2) {
+    function fail(e) {
+      env2.error = env2.hasError ? new _SuppressedError(e, env2.error, "An error was suppressed during disposal.") : e;
+      env2.hasError = true;
+    }
+    __name(fail, "fail");
+    var r, s = 0;
+    function next() {
+      while (r = env2.stack.pop()) {
+        try {
+          if (!r.async && s === 1) return s = 0, env2.stack.push(r), Promise.resolve().then(next);
+          if (r.dispose) {
+            var result = r.dispose.call(r.value);
+            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+              fail(e);
+              return next();
+            });
+          } else s |= 1;
+        } catch (e) {
+          fail(e);
+        }
+      }
+      if (s === 1) return env2.hasError ? Promise.reject(env2.error) : Promise.resolve();
+      if (env2.hasError) throw env2.error;
+    }
+    __name(next, "next");
+    return next();
+  }, "_ts_dispose_resources"))(env);
+}
+__name(_ts_dispose_resources2, "_ts_dispose_resources");
 async function handleAction6(options) {
-  var _stack = [];
+  const env = {
+    stack: [],
+    error: void 0,
+    hasError: false
+  };
   try {
     const spinner = ora6("Starting model tests...").info();
     const app = express3();
-    app.use(express3.json({ limit: "100mb" }));
-    app.use(express3.urlencoded({ limit: "100mb", extended: true }));
-    const webServer = __using(_stack, await startWebServer(app, options.port));
+    app.use(express3.json({
+      limit: "100mb"
+    }));
+    app.use(express3.urlencoded({
+      limit: "100mb",
+      extended: true
+    }));
+    const webServer = _ts_add_disposable_resource2(env, await startWebServer(app, options.port), false);
     try {
       const ctx = await loadProjectContext(options.config);
       const inputFiles = getInputFiles(ctx.config);
@@ -1341,12 +1632,7 @@ async function handleAction6(options) {
       const dockerImage = getDockerImage(ctx);
       await buildDockerImage(dockerImage, ctx);
       spinner.succeed(`Built docker image (${dockerImage})`);
-      const modelIOChecks = setupModelIOChecks(
-        app,
-        options.inputDir,
-        inputFiles,
-        ctx
-      );
+      const modelIOChecks = setupModelIOChecks(app, options.inputDir, inputFiles, ctx);
       spinner.start("Running model container");
       await runModelContainer(dockerImage, options.port, ctx);
       spinner.succeed("Model run complete");
@@ -1362,11 +1648,7 @@ async function handleAction6(options) {
         throw new Error("Model I/O test failed");
       }
       if (modelIOChecks.isOutputHandled()) {
-        const outputPath = path14.join(
-          ctx.projectRoot,
-          TEST_OUTPUT_DATA_DIR,
-          TEST_OUTPUT_FILENAME
-        );
+        const outputPath = path14.join(ctx.projectRoot, TEST_OUTPUT_DATA_DIR, TEST_OUTPUT_FILENAME);
         const clickHereLink = createLink("Click here", `file://${outputPath}`);
         const fileLink = createLink(TEST_OUTPUT_FILENAME, `file://${outputPath}`);
         console.log(`
@@ -1387,27 +1669,20 @@ ${clickHereLink} to view output (${fileLink})
       }
       process.exit(1);
     }
-  } catch (_) {
-    var _error = _, _hasError = true;
+  } catch (e) {
+    env.error = e;
+    env.hasError = true;
   } finally {
-    __callDispose(_stack, _error, _hasError);
+    _ts_dispose_resources2(env);
   }
 }
+__name(handleAction6, "handleAction");
 
 // src/commands/test/index.ts
 function registerTestCommand(program2) {
-  program2.command("test").description(
-    "Test a model by verifying input and output is handled correctly."
-  ).option(
-    "-i, --input-dir <path>",
-    "The input test data directory",
-    TEST_INPUT_DATA_DIR
-  ).option(
-    "-p, --port <port>",
-    "The port to run the IO testing webserver on",
-    TEST_WEBSERVER_PORT.toString()
-  ).option("-c, --config <path>", "Path to config file", PROJECT_CONFIG_FILE).action(handleAction6);
+  program2.command("test").description("Test a model by verifying input and output is handled correctly.").option("-i, --input-dir <path>", "The input test data directory", TEST_INPUT_DATA_DIR).option("-p, --port <port>", "The port to run the IO testing webserver on", TEST_WEBSERVER_PORT.toString()).option("-c, --config <path>", "Path to config file", PROJECT_CONFIG_FILE).action(handleAction6);
 }
+__name(registerTestCommand, "registerTestCommand");
 
 // src/program.ts
 import { Command } from "commander";
@@ -1415,8 +1690,9 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@pd4castr/cli",
-  version: "1.2.0",
+  version: "1.4.0",
   description: "CLI tool for creating, testing, and publishing pd4castr models",
+  license: "UNLICENSED",
   main: "dist/index.js",
   type: "module",
   bin: {
@@ -1425,77 +1701,58 @@ var package_default = {
   files: [
     "dist/**/*"
   ],
+  engines: {
+    node: ">=20.0.0"
+  },
   scripts: {
     build: "tsup",
     dev: "tsup --watch",
-    cli: "node dist/index.js",
-    test: "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    lint: "eslint .",
-    "lint:fix": "eslint . --fix",
+    pd4castr: "node dist/index.js",
+    release: "semantic-release -e semantic-release-monorepo",
     format: "prettier --write .",
-    "format:check": "prettier --check .",
+    lint: "eslint .",
     typecheck: "tsc --noEmit",
     prepublishOnly: "yarn build"
   },
-  keywords: [
-    "cli",
-    "pd4castr"
-  ],
-  license: "UNLICENSED",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/pipelabs/pd4castr-cli.git"
-  },
-  bugs: {
-    url: "https://github.com/pipelabs/pd4castr-cli/issues"
+  dependencies: {
+    "@inquirer/prompts": "7.7.1",
+    auth0: "4.28.0",
+    chalk: "5.6.0",
+    commander: "14.0.0",
+    execa: "9.6.0",
+    express: "4.21.2",
+    immer: "10.1.1",
+    ky: "1.8.2",
+    ora: "8.2.0",
+    slugify: "1.6.6",
+    tiged: "2.12.7",
+    "tiny-invariant": "1.3.3",
+    zod: "4.0.14"
   },
-  homepage: "https://github.com/pipelabs/pd4castr-cli#readme",
   devDependencies: {
     "@faker-js/faker": "10.0.0",
     "@mswjs/data": "0.16.2",
     "@types/express": "4.17.21",
     "@types/node": "24.1.0",
     "@types/supertest": "6.0.3",
-    "@typescript-eslint/eslint-plugin": "8.38.0",
-    "@typescript-eslint/parser": "8.38.0",
-    eslint: "9.32.0",
-    "eslint-config-prettier": "10.1.8",
-    "eslint-plugin-simple-import-sort": "12.1.1",
-    "eslint-plugin-unicorn": "60.0.0",
-    "eslint-plugin-vitest": "0.5.4",
     "hook-std": "3.0.0",
     "jest-extended": "6.0.0",
-    memfs: "4.23.0",
-    msw: "2.10.4",
-    prettier: "3.6.2",
+    memfs: "4.49.0",
+    msw: "2.10.5",
     "strip-ansi": "7.1.0",
     supertest: "7.1.4",
     tsup: "8.5.0",
     "type-fest": "4.41.0",
     typescript: "5.8.3",
-    "typescript-eslint": "8.38.0",
     vitest: "3.2.4"
   },
-  dependencies: {
-    "@inquirer/prompts": "7.7.1",
-    auth0: "4.27.0",
-    chalk: "5.6.0",
-    commander: "14.0.0",
-    execa: "9.6.0",
-    express: "4.21.2",
-    immer: "10.1.1",
-    ky: "1.8.2",
-    ora: "8.2.0",
-    slugify: "1.6.6",
-    tiged: "2.12.7",
-    "tiny-invariant": "1.3.3",
-    zod: "4.0.14"
+  publishConfig: {
+    access: "public"
   },
-  engines: {
-    node: ">=20.0.0"
-  }
+  keywords: [
+    "cli",
+    "pd4castr"
+  ]
 };
 
 // src/program.ts