@kitsi/action 0.0.14 → 0.0.16

package/dist/index.js

@@ -101119,7 +101119,7 @@ var require_picomatch2 = __commonJS((exports, module2) => {
 });
 
 // src/index.ts
-var core6 = __toESM(require_core(), 1);
+var core7 = __toESM(require_core(), 1);
 
 // src/capabilities/annotations.ts
 var core = __toESM(require_core(), 1);
@@ -101566,9 +101566,9 @@ class GroupManager {
 import { resolve as resolvePath2 } from "node:path";
 import { pathToFileURL } from "node:url";
 
-// ../cli/dist/version.js
+// ../core/dist/version.js
 var VERSION = "0.0.1";
-// ../cli/dist/dsl/plan.js
+// ../core/dist/dsl/plan.js
 var clonePlan = (plan, patch) => new PlanBuilder((() => {
   const next = {
     name: patch.name ?? plan.config.name,
@@ -101662,7 +101662,7 @@ var plan = (name) => new PlanBuilder({
   concurrency: {},
   tasks: []
 });
-// ../cli/dist/dsl/task.js
+// ../core/dist/dsl/task.js
 var cloneTask = (task, patch) => new TaskBuilder({
   ...task.config,
   ...patch,
@@ -101729,7 +101729,7 @@ var task = (name) => new TaskBuilder({
   inputs: [],
   cacheEnv: []
 });
-// ../cli/dist/dsl/step.js
+// ../core/dist/dsl/step.js
 class StepBuilder {
   name;
   run;
@@ -101746,7 +101746,7 @@ class StepBuilder {
   }
 }
 var step = (name, run) => new StepBuilder(name, run);
-// ../cli/dist/dsl/kit.js
+// ../core/dist/dsl/kit.js
 var cloneKit = (kit, patch) => new KitBuilder({
   ...kit.config,
   ...patch,
@@ -101780,7 +101780,7 @@ class KitBuilder {
   }
 }
 var kit = (name) => new KitBuilder({ name, env: {}, setupSteps: [] });
-// ../cli/dist/dsl/image.js
+// ../core/dist/dsl/image.js
 class ImageBuilder {
   config;
   constructor(config) {
@@ -101794,7 +101794,7 @@ class ImageBuilder {
   }
 }
 var image = (ref) => new ImageBuilder({ ref, env: {} });
-// ../cli/dist/dsl/service.js
+// ../core/dist/dsl/service.js
 class ServiceBuilder {
   config;
   constructor(config) {
@@ -101814,101 +101814,26 @@ class ServiceBuilder {
   }
 }
 var service = (imageRef) => new ServiceBuilder({ image: imageRef, env: {}, ports: [] });
-// ../cli/dist/dsl/registry.js
+// ../core/dist/dsl/registry.js
 var registry = (...plansList) => ({
   plans: plansList
 });
-// ../cli/dist/ops/shell.js
-var toTemplatePart = (value) => {
-  if (typeof value === "string" || typeof value === "number") {
-    return { type: "interpolated", value: String(value) };
-  }
-  if (value.kind === "secret") {
-    return { type: "secret", name: value.name };
-  }
-  if (value.kind === "param") {
-    return { type: "param", ref: value };
-  }
-  return { type: "value", ref: value };
-};
-
-class CommandBuilder {
-  op;
-  constructor(op) {
-    this.op = op;
-  }
-  stdout() {
-    return { ...this.op, capture: "stdout" };
-  }
-  code() {
-    return { ...this.op, capture: "code" };
-  }
-  ok() {
-    return { ...this.op, capture: "ok" };
-  }
-  must() {
-    return { ...this.op, capture: "must" };
-  }
-  cached(options) {
-    return new CommandBuilder({ ...this.op, cache: { enabled: true, ...options } });
-  }
-  uncached() {
-    return new CommandBuilder({ ...this.op, cache: { enabled: false } });
-  }
-}
-var sh = (strings, ...values) => {
-  const template = [];
-  for (let i = 0;i < strings.length; i += 1) {
-    const text = strings[i] ?? "";
-    if (text.length > 0) {
-      template.push({ type: "text", value: text });
-    }
-    const value = values[i];
-    if (i < values.length && value !== undefined) {
-      template.push(toTemplatePart(value));
-    }
-  }
-  return new CommandBuilder({
-    kind: "command",
-    capture: "result",
-    template
-  });
+// ../core/dist/ops/operation.js
+var isOperation = (value) => {
+  if (!value || typeof value !== "object")
+    return false;
+  const op = value;
+  return typeof op.kind === "string" && typeof op.toOp === "function" && typeof op.analysisPlaceholder === "function" && typeof op.extractDependencies === "function" && typeof op.extractSecrets === "function" && typeof op.extractRefs === "function" && typeof op.cacheNormalize === "function" && typeof op.cachePlaceholder === "function";
 };
 
-// ../cli/dist/dsl/analysis.js
+// ../core/dist/dsl/analysis.js
 var stepIterator = (step2, task2) => {
   return step2.run({ task: task2, workspace: "" });
 };
-var toOp = (value) => {
-  if (value instanceof CommandBuilder)
-    return value.op;
-  if (value && typeof value === "object" && "op" in value) {
-    const maybeOp = value.op;
-    if (maybeOp && typeof maybeOp === "object" && "kind" in maybeOp) {
-      return maybeOp;
-    }
-  }
-  return value;
-};
-var placeholderForOp = (value) => {
-  const op = toOp(value);
-  switch (op.kind) {
-    case "command":
-      return "";
-    case "http":
-      return { status: 200, ok: true, headers: {}, body: "" };
-    case "use":
-      return op.ref.parse("");
-    case "emit":
-      return op.value;
-    case "pack":
-    case "unpack":
-      return;
-    case "env":
-      return typeof op.value === "string" || typeof op.value === "number" ? op.value : "";
-    default:
-      return;
-  }
+var toOperation = (value) => {
+  if (isOperation(value))
+    return value;
+  throw new Error("Step yielded a non-operation value");
 };
 var collectEnvSecrets = (task2, secrets) => {
   for (const value of Object.values(task2.config.env)) {
@@ -101917,49 +101842,17 @@ var collectEnvSecrets = (task2, secrets) => {
     }
   }
 };
-var collectTemplateSecrets = (template, secrets) => {
-  for (const part of template) {
-    if (part.type === "secret" && part.name) {
-      secrets.add(part.name);
-    }
-  }
-};
-var collectHttpSecrets = (op, secrets) => {
-  collectTemplateSecrets(op.url, secrets);
-  for (const header of op.headers) {
-    collectTemplateSecrets(header.value, secrets);
-  }
-  if (op.body) {
-    collectTemplateSecrets(op.body, secrets);
-  }
-};
-var collectEnvOpSecrets = (op, secrets) => {
-  if (op.value.kind === "secret") {
-    secrets.add(op.value.name);
-  }
-};
-var collectOpSecrets = (op, secrets) => {
-  if (op.kind === "command") {
-    collectTemplateSecrets(op.template, secrets);
-    return;
-  }
-  if (op.kind === "http") {
-    collectHttpSecrets(op, secrets);
-    return;
-  }
-  if (op.kind === "env") {
-    collectEnvOpSecrets(op, secrets);
-  }
-};
 var collectStepSecrets = (task2, secrets) => {
   const steps = [...task2.config.setupSteps, ...task2.config.steps];
   for (const step2 of steps) {
     const iterator = stepIterator(step2, task2);
     let cursor = iterator.next();
     while (!cursor.done) {
-      const op = toOp(cursor.value);
-      collectOpSecrets(op, secrets);
-      cursor = iterator.next(placeholderForOp(op));
+      const operation = toOperation(cursor.value);
+      for (const name of operation.extractSecrets()) {
+        secrets.add(name);
+      }
+      cursor = iterator.next(operation.analysisPlaceholder());
     }
   }
 };
@@ -101971,14 +101864,14 @@ var collectSecrets = (tasks) => {
   }
   return secrets;
 };
-// ../cli/dist/dsl/utils.js
+// ../core/dist/dsl/utils.js
 import { resolve as resolvePath } from "node:path";
 var resolveWorkspace = (workspace) => {
   if (!workspace)
     return process.cwd();
   return workspace.startsWith(".") ? resolvePath(process.cwd(), workspace) : workspace;
 };
-// ../cli/dist/ops/errors.js
+// ../core/dist/ops/errors.js
 class OpErrorBuilder {
   type;
   message;
@@ -102019,10 +101912,10 @@ var OpErrors = {
   service: (message) => new OpErrorBuilder("service", message),
   timeout: (message) => new OpErrorBuilder("timeout", message)
 };
-// ../cli/dist/ops/http.js
+// ../core/dist/ops/template.js
 var isTemplateStringsArray = (value) => Array.isArray(value) && Object.prototype.hasOwnProperty.call(value, "raw");
 var isTemplatePartArray = (value) => Array.isArray(value) && (value.length === 0 || typeof value[0] === "object" && value[0] !== null && ("type" in value[0]));
-var toTemplatePart2 = (value) => {
+var toTemplatePart = (value) => {
   if (typeof value === "string" || typeof value === "number") {
     return { type: "interpolated", value: String(value) };
   }
@@ -102043,7 +101936,7 @@ var buildTemplateParts = (strings, values) => {
     }
     const value = values[i];
     if (i < values.length && value !== undefined) {
-      template.push(toTemplatePart2(value));
+      template.push(toTemplatePart(value));
     }
   }
   return template;
@@ -102056,10 +101949,123 @@ var templateFromInput = (input, values) => {
     return input;
   }
   if (Array.isArray(input)) {
-    return input.map((part) => toTemplatePart2(part));
+    return input.map((part) => toTemplatePart(part));
+  }
+  return [toTemplatePart(input)];
+};
+var collectTemplateMetadata = (template, addSecret, addParam) => {
+  for (const part of template) {
+    if (part.type === "secret")
+      addSecret(part.name);
+    if (part.type === "param")
+      addParam(part.ref.name);
   }
-  return [toTemplatePart2(input)];
 };
+var collectTemplateSecrets = (template) => {
+  const names = new Set;
+  for (const part of template) {
+    if (part.type === "secret")
+      names.add(part.name);
+  }
+  return Array.from(names);
+};
+var normalizeTemplatePart = (part) => {
+  if (part.type === "text" || part.type === "interpolated") {
+    return { type: part.type, value: part.value };
+  }
+  if (part.type === "secret") {
+    return { type: part.type, name: part.name };
+  }
+  return { type: part.type, name: part.ref.name };
+};
+var commandSignature = (template) => {
+  const raw = template.map((part) => {
+    if (part.type === "text")
+      return part.value;
+    if (part.type === "interpolated")
+      return String(part.value);
+    if (part.type === "secret")
+      return `<secret:${part.name}>`;
+    if (part.type === "param")
+      return `<param:${part.ref.name}>`;
+    return `<value:${part.ref.name}>`;
+  }).join("");
+  return raw.replace(/\s+/g, " ").trim();
+};
+
+// ../core/dist/ops/shell.js
+class CommandBuilder {
+  op;
+  constructor(op) {
+    this.op = op;
+  }
+  get kind() {
+    return this.op.kind;
+  }
+  toOp() {
+    return this.op;
+  }
+  analysisPlaceholder() {
+    return "";
+  }
+  extractDependencies(_taskName) {
+    return [];
+  }
+  extractSecrets() {
+    const names = new Set;
+    collectTemplateMetadata(this.op.template, (name) => names.add(name), () => {});
+    return Array.from(names);
+  }
+  extractRefs() {
+    return [];
+  }
+  cacheNormalize(context) {
+    context.addCommandSignature(commandSignature(this.op.template));
+    collectTemplateMetadata(this.op.template, context.addSecret, context.addParam);
+    return {
+      kind: this.op.kind,
+      capture: this.op.capture,
+      cache: this.op.cache ?? null,
+      template: this.op.template.map(normalizeTemplatePart)
+    };
+  }
+  cachePlaceholder(context) {
+    if (!context.isPrimary)
+      return;
+    if (this.op.capture === "ok")
+      return true;
+    if (this.op.capture === "code")
+      return 0;
+    return "";
+  }
+  stdout() {
+    return new CommandBuilder({ ...this.op, capture: "stdout" });
+  }
+  code() {
+    return new CommandBuilder({ ...this.op, capture: "code" });
+  }
+  ok() {
+    return new CommandBuilder({ ...this.op, capture: "ok" });
+  }
+  must() {
+    return new CommandBuilder({ ...this.op, capture: "must" });
+  }
+  cached(options) {
+    return new CommandBuilder({ ...this.op, cache: { enabled: true, ...options } });
+  }
+  uncached() {
+    return new CommandBuilder({ ...this.op, cache: { enabled: false } });
+  }
+}
+var sh = (strings, ...values) => {
+  const template = buildTemplateParts(strings, values);
+  return new CommandBuilder({
+    kind: "command",
+    capture: "result",
+    template
+  });
+};
+// ../core/dist/ops/http.js
 var hasHeader = (headers, name) => headers.some((header) => header.name.toLowerCase() === name.toLowerCase());
 
 class HttpBuilder {
@@ -102067,6 +102073,60 @@ class HttpBuilder {
   constructor(op) {
     this.op = op;
   }
+  get kind() {
+    return this.op.kind;
+  }
+  toOp() {
+    return this.op;
+  }
+  analysisPlaceholder() {
+    return { status: 200, ok: true, headers: {}, body: "" };
+  }
+  extractDependencies(_taskName) {
+    return [];
+  }
+  extractSecrets() {
+    const names = new Set;
+    for (const name of collectTemplateSecrets(this.op.url))
+      names.add(name);
+    for (const header of this.op.headers) {
+      for (const name of collectTemplateSecrets(header.value))
+        names.add(name);
+    }
+    if (this.op.body) {
+      for (const name of collectTemplateSecrets(this.op.body))
+        names.add(name);
+    }
+    return Array.from(names);
+  }
+  extractRefs() {
+    return [];
+  }
+  cacheNormalize(context) {
+    collectTemplateMetadata(this.op.url, context.addSecret, context.addParam);
+    for (const header of this.op.headers) {
+      collectTemplateMetadata(header.value, context.addSecret, context.addParam);
+    }
+    if (this.op.body) {
+      collectTemplateMetadata(this.op.body, context.addSecret, context.addParam);
+    }
+    return {
+      kind: this.op.kind,
+      method: this.op.method,
+      url: this.op.url.map(normalizeTemplatePart),
+      headers: this.op.headers.map((header) => ({
+        name: header.name,
+        value: header.value.map(normalizeTemplatePart)
+      })),
+      body: this.op.body ? this.op.body.map(normalizeTemplatePart) : null,
+      bodyPath: this.op.bodyPath ?? null
+    };
+  }
+  cachePlaceholder(context) {
+    if (!context.isPrimary)
+      return;
+    return { status: 200, ok: true, headers: {}, body: "" };
+  }
   header(name, value, ...values) {
     const next = { name, value: templateFromInput(value, values) };
     return new HttpBuilder({ ...this.op, headers: [...this.op.headers, next] });
@@ -102113,15 +102173,76 @@ var http = {
   head: (url, ...values) => buildRequest("HEAD", url, values),
   options: (url, ...values) => buildRequest("OPTIONS", url, values)
 };
-// ../cli/dist/ops/env.js
-var env = (name, value) => ({
-  kind: "env",
-  name,
-  value
-});
-// ../cli/dist/ops/secret.js
+// ../core/dist/ops/types.js
+var isSecretRef = (value) => value.kind === "secret";
+var isParamRef = (value) => value.kind === "param";
+var isValueRef = (value) => value.kind === "value";
+
+// ../core/dist/ops/env.js
+class EnvOperation {
+  name;
+  value;
+  constructor(name, value) {
+    this.name = name;
+    this.value = value;
+  }
+  get kind() {
+    return "env";
+  }
+  toOp() {
+    return { kind: "env", name: this.name, value: this.value };
+  }
+  analysisPlaceholder() {
+    if (typeof this.value === "string" || typeof this.value === "number") {
+      return this.value;
+    }
+    return "";
+  }
+  extractDependencies(_taskName) {
+    return [];
+  }
+  extractSecrets() {
+    const value = this.value;
+    if (typeof value === "object" && value !== null && isSecretRef(value)) {
+      return [value.name];
+    }
+    return [];
+  }
+  extractRefs() {
+    return [];
+  }
+  cacheNormalize(context) {
+    const value = this.value;
+    if (typeof value !== "string" && typeof value !== "number") {
+      if (isSecretRef(value))
+        context.addSecret(value.name);
+      if (isParamRef(value))
+        context.addParam(value.name);
+    }
+    const normalized = (() => {
+      if (typeof value === "string" || typeof value === "number")
+        return value;
+      if (isSecretRef(value))
+        return { kind: "secret", name: value.name };
+      if (isParamRef(value))
+        return { kind: "param", name: value.name };
+      if (isValueRef(value))
+        return { kind: "value", name: value.name };
+      return String(value);
+    })();
+    return { kind: this.kind, name: this.name, value: normalized };
+  }
+  cachePlaceholder(context) {
+    if (typeof this.value === "string" || typeof this.value === "number") {
+      return this.value;
+    }
+    return context.isPrimary ? "" : undefined;
+  }
+}
+var env = (name, value) => new EnvOperation(name, value);
+// ../core/dist/ops/secret.js
 var secret = (name) => ({ kind: "secret", name });
-// ../cli/dist/ops/ref.js
+// ../core/dist/ops/ref.js
 var coerce = {
   string: (value) => String(value),
   number: (value) => Number(value),
@@ -102143,7 +102264,111 @@ var createRefFactory = (kind) => {
 };
 var param = createRefFactory("param");
 var out = createRefFactory("value");
-// ../cli/dist/ops/cache.js
+// ../core/dist/ops/operation-base.js
+class OperationBase {
+  analysisPlaceholder() {
+    return;
+  }
+  extractDependencies(_taskName) {
+    return [];
+  }
+  extractSecrets() {
+    return [];
+  }
+  extractRefs() {
+    return [];
+  }
+  cachePlaceholder(context) {
+    return context.value;
+  }
+}
+
+// ../core/dist/ops/cache.js
+class CacheOperation extends OperationBase {
+  name;
+  paths;
+  key;
+  constructor(name, paths, key) {
+    super();
+    this.name = name;
+    this.paths = paths;
+    if (key)
+      this.key = key;
+  }
+  get kind() {
+    return "cache";
+  }
+  toOp() {
+    return {
+      kind: "cache",
+      name: this.name,
+      paths: this.paths,
+      ...this.key ? { key: this.key } : {}
+    };
+  }
+  cacheNormalize(_context) {
+    return {
+      kind: this.kind,
+      name: this.name,
+      paths: this.paths,
+      key: this.key ?? null
+    };
+  }
+}
+
+class CacheOrOperation extends OperationBase {
+  name;
+  paths;
+  key;
+  compute;
+  constructor(name, paths, compute, key) {
+    super();
+    this.name = name;
+    this.paths = paths;
+    this.compute = compute;
+    if (key)
+      this.key = key;
+  }
+  get kind() {
+    return "cache-or";
+  }
+  toOp() {
+    return {
+      kind: "cache-or",
+      name: this.name,
+      paths: this.paths,
+      ...this.key ? { key: this.key } : {},
+      compute: this.compute
+    };
+  }
+  cacheNormalize(context) {
+    const computeOps = context.analyzeNested(this.compute, context.resultValue);
+    return {
+      kind: this.kind,
+      name: this.name,
+      paths: this.paths,
+      key: this.key ?? null,
+      compute: computeOps
+    };
+  }
+}
+
+class CacheMountOperation extends OperationBase {
+  cache;
+  constructor(cache2) {
+    super();
+    this.cache = cache2;
+  }
+  get kind() {
+    return "cache-mount";
+  }
+  toOp() {
+    return { kind: "cache-mount", cache: this.cache };
+  }
+  cacheNormalize(_context) {
+    return { kind: this.kind };
+  }
+}
 var createCacheRef = (name, mountPath, key) => {
   const ref = {
     kind: "cache",
@@ -102157,26 +102382,57 @@ var createCacheRef = (name, mountPath, key) => {
     ref.key = key;
   return ref;
 };
-var cacheOr = (name, options) => ({
-  kind: "cache-or",
-  name,
-  paths: options.paths,
-  ...options.key !== undefined ? { key: options.key } : {},
-  compute: options.compute
-});
-var cacheFn = (name, options) => ({
-  kind: "cache",
-  name,
-  paths: options.paths,
-  ...options.key !== undefined ? { key: options.key } : {}
-});
+var cacheOr = (name, options) => new CacheOrOperation(name, options.paths, options.compute, options.key);
+var cacheFn = (name, options) => new CacheOperation(name, options.paths, options.key);
 cacheFn.dir = (name) => createCacheRef(name);
-cacheFn.mount = (ref) => ({
-  kind: "cache-mount",
-  cache: ref
-});
+cacheFn.mount = (ref) => new CacheMountOperation(ref);
 var cache2 = cacheFn;
-// ../cli/dist/ops/artifact.js
+// ../core/dist/ops/artifact.js
+class ArtifactUploadOperation extends OperationBase {
+  name;
+  patterns;
+  when;
+  constructor(name, patterns, when) {
+    super();
+    this.name = name;
+    this.patterns = patterns;
+    this.when = when;
+  }
+  get kind() {
+    return "artifact-upload";
+  }
+  toOp() {
+    return { kind: "artifact-upload", name: this.name, patterns: this.patterns, when: this.when };
+  }
+  cacheNormalize(_context) {
+    return {
+      kind: this.kind,
+      name: this.name,
+      patterns: this.patterns,
+      when: this.when
+    };
+  }
+}
+
+class ArtifactDownloadOperation extends OperationBase {
+  name;
+  destination;
+  constructor(name, destination) {
+    super();
+    this.name = name;
+    this.destination = destination;
+  }
+  get kind() {
+    return "artifact-download";
+  }
+  toOp() {
+    return { kind: "artifact-download", name: this.name, destination: this.destination };
+  }
+  cacheNormalize(_context) {
+    return { kind: this.kind, name: this.name, destination: this.destination };
+  }
+}
+
 class ArtifactUploadBuilder {
   name;
   patterns;
@@ -102190,10 +102446,10 @@ class ArtifactUploadBuilder {
     return new ArtifactUploadBuilder(this.name, patterns, this.when);
   }
   whenSuccess() {
-    return { kind: "artifact-upload", name: this.name, patterns: this.patterns, when: "success" };
+    return new ArtifactUploadOperation(this.name, this.patterns, "success");
   }
   whenAlways() {
-    return { kind: "artifact-upload", name: this.name, patterns: this.patterns, when: "always" };
+    return new ArtifactUploadOperation(this.name, this.patterns, "always");
   }
 }
 
@@ -102203,14 +102459,14 @@ class ArtifactDownloadBuilder {
     this.name = name;
   }
   to(destination) {
-    return { kind: "artifact-download", name: this.name, destination };
+    return new ArtifactDownloadOperation(this.name, destination);
   }
 }
 var artifact2 = {
   upload: (name) => new ArtifactUploadBuilder(name),
   download: (name) => new ArtifactDownloadBuilder(name)
 };
-// ../cli/dist/ops/bundle.js
+// ../core/dist/ops/bundle.js
 var cloneBundle = (ref, patterns) => ({
   ...ref,
   patterns,
@@ -102225,79 +102481,243 @@ var createBundleRef = (name) => {
   };
   return ref;
 };
-var pack = (ref) => ({
-  kind: "pack",
-  ref
-});
-var unpack = (from, ref) => ({
-  kind: "unpack",
-  from,
-  ref
-});
 
-// ../cli/dist/ops/output.js
+class PackOperation extends OperationBase {
+  ref;
+  constructor(ref) {
+    super();
+    this.ref = ref;
+  }
+  get kind() {
+    return "pack";
+  }
+  toOp() {
+    return { kind: "pack", ref: this.ref };
+  }
+  cacheNormalize(_context) {
+    return { kind: this.kind, name: this.ref.name, patterns: this.ref.patterns };
+  }
+  cachePlaceholder(_context) {
+    return;
+  }
+}
+
+class UnpackOperation extends OperationBase {
+  from;
+  ref;
+  constructor(from, ref) {
+    super();
+    this.from = from;
+    this.ref = ref;
+  }
+  get kind() {
+    return "unpack";
+  }
+  toOp() {
+    return { kind: "unpack", from: this.from, ref: this.ref };
+  }
+  extractDependencies(taskName) {
+    return [{ from: this.from.config.name, to: taskName, type: "unpack" }];
+  }
+  extractRefs() {
+    return [{ type: "bundle", ref: this.ref }];
+  }
+  cacheNormalize(context) {
+    context.addDependency(this.from.config.name);
+    return {
+      kind: this.kind,
+      from: this.from.config.name,
+      name: this.ref.name,
+      patterns: this.ref.patterns
+    };
+  }
+  cachePlaceholder(_context) {
+    return;
+  }
+}
+var pack = (ref) => new PackOperation(ref);
+var unpack = (from, ref) => new UnpackOperation(from, ref);
+
+// ../core/dist/ops/output.js
 var out2 = {
   ...out,
   bundle: (name) => createBundleRef(name)
 };
-var emit = (ref, value) => ({
-  kind: "emit",
-  ref,
-  value
-});
-var use = (from, ref) => ({
-  kind: "use",
-  from,
-  ref
-});
-// ../cli/dist/ops/summary.js
+var emit = (ref, value) => new EmitOperation(ref, value);
+var use = (from, ref) => new UseOperation(from, ref);
+
+class EmitOperation {
+  ref;
+  value;
+  constructor(ref, value) {
+    this.ref = ref;
+    this.value = value;
+  }
+  get kind() {
+    return "emit";
+  }
+  toOp() {
+    return { kind: "emit", ref: this.ref, value: this.value };
+  }
+  analysisPlaceholder() {
+    return this.value;
+  }
+  extractDependencies(_taskName) {
+    return [];
+  }
+  extractSecrets() {
+    return [];
+  }
+  extractRefs() {
+    return [];
+  }
+  cacheNormalize(_context) {
+    return { kind: this.kind, ref: this.ref.name, value: this.value };
+  }
+  cachePlaceholder(_context) {
+    return this.value;
+  }
+}
+
+class UseOperation {
+  from;
+  ref;
+  constructor(from, ref) {
+    this.from = from;
+    this.ref = ref;
+  }
+  get kind() {
+    return "use";
+  }
+  toOp() {
+    return { kind: "use", from: this.from, ref: this.ref };
+  }
+  analysisPlaceholder() {
+    return this.ref.parse("");
+  }
+  extractDependencies(taskName) {
+    return [{ from: this.from.config.name, to: taskName, type: "use" }];
+  }
+  extractSecrets() {
+    return [];
+  }
+  extractRefs() {
+    return [{ type: "value", ref: this.ref }];
+  }
+  cacheNormalize(context) {
+    context.addDependency(this.from.config.name);
+    return { kind: this.kind, from: this.from.config.name, ref: this.ref.name };
+  }
+  cachePlaceholder(context) {
+    return context.isPrimary ? this.ref.parse("") : undefined;
+  }
+}
+// ../core/dist/ops/summary.js
+class SummaryOperation extends OperationBase {
+  format;
+  content;
+  constructor(format, content) {
+    super();
+    this.format = format;
+    this.content = content;
+  }
+  get kind() {
+    return "summary";
+  }
+  toOp() {
+    return { kind: "summary", format: this.format, content: this.content };
+  }
+  cacheNormalize(_context) {
+    return { kind: this.kind, format: this.format, content: this.content };
+  }
+}
 var summary2 = {
-  md: (content) => ({
-    kind: "summary",
-    format: "md",
-    content
-  })
+  md: (content) => new SummaryOperation("md", content)
 };
-// ../cli/dist/ops/annotate.js
-var createAnnotation = (level) => (message, location) => ({
-  kind: "annotate",
-  level,
-  message,
-  ...location ? { location } : {}
-});
+// ../core/dist/ops/annotate.js
+class AnnotateOperation extends OperationBase {
+  level;
+  message;
+  location;
+  constructor(level, message, location) {
+    super();
+    this.level = level;
+    this.message = message;
+    if (location)
+      this.location = location;
+  }
+  get kind() {
+    return "annotate";
+  }
+  toOp() {
+    return {
+      kind: "annotate",
+      level: this.level,
+      message: this.message,
+      ...this.location ? { location: this.location } : {}
+    };
+  }
+  cacheNormalize(_context) {
+    return { kind: this.kind, level: this.level, message: this.message };
+  }
+}
+var createAnnotation = (level) => (message, location) => new AnnotateOperation(level, message, location);
 var annotate = {
   error: createAnnotation("error"),
   warning: createAnnotation("warning"),
   info: createAnnotation("info")
 };
-// ../cli/dist/ops/report.js
+// ../core/dist/ops/report.js
+class ReportOperation extends OperationBase {
+  reportType;
+  path;
+  constructor(reportType, path) {
+    super();
+    this.reportType = reportType;
+    this.path = path;
+  }
+  get kind() {
+    return "report";
+  }
+  toOp() {
+    return { kind: "report", reportType: this.reportType, path: this.path };
+  }
+  cacheNormalize(_context) {
+    return { kind: this.kind, reportType: this.reportType, path: this.path };
+  }
+}
 var report = {
-  junit: (path) => ({
-    kind: "report",
-    reportType: "junit",
-    path
-  }),
-  coverage: (path) => ({
-    kind: "report",
-    reportType: "coverage",
-    path
-  })
+  junit: (path) => new ReportOperation("junit", path),
+  coverage: (path) => new ReportOperation("coverage", path)
 };
-// ../cli/dist/ops/bind.js
-var bind = (serviceInstance, alias) => {
-  const op = { kind: "bind-service", service: serviceInstance };
-  if (alias)
-    op.alias = alias;
-  return op;
-};
-// ../cli/dist/ops/types.js
-var isSecretRef = (value) => value.kind === "secret";
-var isParamRef = (value) => value.kind === "param";
-var isValueRef = (value) => value.kind === "value";
-// ../cli/dist/engine/cache/coordinator.js
+// ../core/dist/ops/bind.js
+class BindServiceOperation extends OperationBase {
+  service;
+  alias;
+  constructor(service2, alias) {
+    super();
+    this.service = service2;
+    if (alias)
+      this.alias = alias;
+  }
+  get kind() {
+    return "bind-service";
+  }
+  toOp() {
+    const op = { kind: "bind-service", service: this.service };
+    if (this.alias)
+      op.alias = this.alias;
+    return op;
+  }
+  cacheNormalize(_context) {
+    return { kind: this.kind, service: this.service, alias: this.alias ?? null };
+  }
+}
+var bind = (serviceInstance, alias) => new BindServiceOperation(serviceInstance, alias);
+// ../core/dist/engine/cache/coordinator.js
 import { join as join4 } from "node:path";
 
-// ../cli/dist/engine/executor/file-system.js
+// ../core/dist/engine/executor/file-system.js
 var import_picomatch = __toESM(require_picomatch2(), 1);
 import { mkdir, readFile as readFile3, readdir, stat, writeFile } from "node:fs/promises";
 import { dirname, join, relative } from "node:path";
@@ -102345,7 +102765,7 @@ var writeFiles = async (basePath, files) => {
   }));
 };
 
-// ../cli/dist/engine/cache/serialize.js
+// ../core/dist/engine/cache/serialize.js
 var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var stableStringify = (value) => {
   if (value === null || value === undefined)
@@ -102365,7 +102785,7 @@ var stableStringify = (value) => {
   return JSON.stringify(String(value));
 };
 
-// ../cli/dist/engine/cache/analyze.js
+// ../core/dist/engine/cache/analyze.js
 var createPlaceholderTracker = () => {
   let touched = false;
   const placeholder = new Proxy(() => {
@@ -102390,219 +102810,40 @@ var createPlaceholderTracker = () => {
     used: () => touched
   };
 };
-var toOp2 = (value) => {
-  if (value instanceof Object && "op" in value) {
-    const maybeOp = value.op;
-    if (maybeOp && typeof maybeOp === "object" && "kind" in maybeOp) {
-      return maybeOp;
-    }
+var toOperation2 = (value) => {
+  if (!isOperation(value)) {
+    throw new Error("Step yielded a non-operation value");
   }
   return value;
 };
-var normalizeTemplatePart = (part) => {
-  if (part.type === "text" || part.type === "interpolated") {
-    return { type: part.type, value: part.value };
+var createCacheContext = (ctx, analysis, tracker, resultValue) => ({
+  addCommandSignature: (signature) => {
+    analysis.commandSignatures.push(signature);
+  },
+  addDependency: (name) => {
+    analysis.dependencies.add(name);
+  },
+  addSecret: (name) => {
+    analysis.secrets.add(name);
+  },
+  addParam: (name) => {
+    analysis.params.add(name);
+  },
+  analyzeNested: (compute, nestedResultValue) => analyzeGenerator(compute(ctx), ctx, analysis, tracker, nestedResultValue),
+  resultValue,
+  placeholder: {
+    value: tracker.value,
+    isPrimary: tracker.value !== undefined
   }
-  if (part.type === "secret") {
-    return { type: part.type, name: part.name };
-  }
-  return { type: part.type, name: part.ref.name };
-};
-var commandSignature = (template) => {
-  const raw = template.map((part) => {
-    if (part.type === "text")
-      return part.value;
-    if (part.type === "interpolated")
-      return String(part.value);
-    if (part.type === "secret")
-      return `<secret:${part.name}>`;
-    if (part.type === "param")
-      return `<param:${part.ref.name}>`;
-    return `<value:${part.ref.name}>`;
-  }).join("");
-  return raw.replace(/\s+/g, " ").trim();
-};
-var collectFromTemplate = (template, secrets, params) => {
-  for (const part of template) {
-    if (part.type === "secret")
-      secrets.add(part.name);
-    if (part.type === "param")
-      params.add(part.ref.name);
-  }
-};
-var collectEnvValue = (value, secrets, params) => {
-  if (typeof value === "string" || typeof value === "number")
-    return;
-  if (isSecretRef(value))
-    secrets.add(value.name);
-  if (isParamRef(value))
-    params.add(value.name);
-};
-var normalizeEnvValue = (value) => {
-  if (typeof value === "string" || typeof value === "number")
-    return value;
-  if (isSecretRef(value))
-    return { kind: "secret", name: value.name };
-  if (isParamRef(value))
-    return { kind: "param", name: value.name };
-  if (isValueRef(value))
-    return { kind: "value", name: value.name };
-  return String(value);
-};
-var normalizeOp = (op, ctx, analysis, tracker, resultValue) => {
-  switch (op.kind) {
-    case "command": {
-      const commandOp = op;
-      analysis.commandSignatures.push(commandSignature(commandOp.template));
-      collectFromTemplate(commandOp.template, analysis.secrets, analysis.params);
-      return {
-        kind: op.kind,
-        capture: commandOp.capture,
-        cache: commandOp.cache ?? null,
-        template: commandOp.template.map(normalizeTemplatePart)
-      };
-    }
-    case "http": {
-      const httpOp = op;
-      collectFromTemplate(httpOp.url, analysis.secrets, analysis.params);
-      for (const header of httpOp.headers) {
-        collectFromTemplate(header.value, analysis.secrets, analysis.params);
-      }
-      if (httpOp.body) {
-        collectFromTemplate(httpOp.body, analysis.secrets, analysis.params);
-      }
-      return {
-        kind: op.kind,
-        method: httpOp.method,
-        url: httpOp.url.map(normalizeTemplatePart),
-        headers: httpOp.headers.map((header) => ({
-          name: header.name,
-          value: header.value.map(normalizeTemplatePart)
-        })),
-        body: httpOp.body ? httpOp.body.map(normalizeTemplatePart) : null,
-        bodyPath: httpOp.bodyPath ?? null
-      };
-    }
-    case "emit": {
-      const emitOp = op;
-      return { kind: op.kind, ref: emitOp.ref.name, value: emitOp.value };
-    }
-    case "use": {
-      const useOp = op;
-      analysis.dependencies.add(useOp.from.config.name);
-      return { kind: op.kind, from: useOp.from.config.name, ref: useOp.ref.name };
-    }
-    case "pack": {
-      const packOp = op;
-      return { kind: op.kind, name: packOp.ref.name, patterns: packOp.ref.patterns };
-    }
-    case "unpack": {
-      const unpackOp = op;
-      analysis.dependencies.add(unpackOp.from.config.name);
-      return {
-        kind: op.kind,
-        from: unpackOp.from.config.name,
-        name: unpackOp.ref.name,
-        patterns: unpackOp.ref.patterns
-      };
-    }
-    case "env": {
-      const envOp = op;
-      collectEnvValue(envOp.value, analysis.secrets, analysis.params);
-      return { kind: op.kind, name: envOp.name, value: normalizeEnvValue(envOp.value) };
-    }
-    case "summary": {
-      const summaryOp = op;
-      return { kind: op.kind, format: summaryOp.format, content: summaryOp.content };
-    }
-    case "artifact-upload": {
-      const uploadOp = op;
-      return {
-        kind: op.kind,
-        name: uploadOp.name,
-        patterns: uploadOp.patterns,
-        when: uploadOp.when
-      };
-    }
-    case "artifact-download": {
-      const downloadOp = op;
-      return { kind: op.kind, name: downloadOp.name, destination: downloadOp.destination };
-    }
-    case "annotate": {
-      const annotateOp = op;
-      return { kind: op.kind, level: annotateOp.level, message: annotateOp.message };
-    }
-    case "report": {
-      const reportOp = op;
-      return { kind: op.kind, reportType: reportOp.reportType, path: reportOp.path };
-    }
-    case "bind-service": {
-      const bindOp = op;
-      return { kind: op.kind, service: bindOp.service, alias: bindOp.alias ?? null };
-    }
-    case "cache": {
-      const cacheOp = op;
-      return { kind: op.kind, name: cacheOp.name, paths: cacheOp.paths, key: cacheOp.key ?? null };
-    }
-    case "cache-or": {
-      const cacheOrOp = op;
-      const computeOps = analyzeGenerator(cacheOrOp.compute(ctx), ctx, analysis, tracker, resultValue);
-      return {
-        kind: op.kind,
-        name: cacheOrOp.name,
-        paths: cacheOrOp.paths,
-        key: cacheOrOp.key ?? null,
-        compute: computeOps
-      };
-    }
-    default:
-      return { kind: op.kind };
-  }
-};
-var placeholderForCommand = (op, isPrimary) => {
-  if (!isPrimary)
-    return;
-  if (op.capture === "ok")
-    return true;
-  if (op.capture === "code")
-    return 0;
-  return "";
-};
-var placeholderForHttp = (isPrimary) => isPrimary ? { status: 200, ok: true, headers: {}, body: "" } : undefined;
-var placeholderForUse = (op, isPrimary) => isPrimary ? op.ref.parse("") : undefined;
-var placeholderForEnv = (op, isPrimary) => {
-  if (typeof op.value === "string" || typeof op.value === "number") {
-    return op.value;
-  }
-  return isPrimary ? "" : undefined;
-};
-var placeholderForOp2 = (op, tracker) => {
-  const isPrimary = tracker.value !== undefined;
-  switch (op.kind) {
-    case "command":
-      return placeholderForCommand(op, isPrimary);
-    case "http":
-      return placeholderForHttp(isPrimary);
-    case "use":
-      return placeholderForUse(op, isPrimary);
-    case "emit":
-      return op.value;
-    case "env":
-      return placeholderForEnv(op, isPrimary);
-    case "pack":
-    case "unpack":
-      return;
-    default:
-      return tracker.value;
-  }
-};
+});
 var analyzeGenerator = (iterator, ctx, analysis, tracker, resultValue) => {
   const ops = [];
   let cursor = iterator.next();
   while (!cursor.done) {
-    const op = toOp2(cursor.value);
-    ops.push(normalizeOp(op, ctx, analysis, tracker, resultValue));
-    const placeholder = placeholderForOp2(op, tracker);
+    const operation = toOperation2(cursor.value);
+    const cacheContext = createCacheContext(ctx, analysis, tracker, resultValue);
+    ops.push(operation.cacheNormalize(cacheContext));
+    const placeholder = operation.cachePlaceholder(cacheContext.placeholder);
     cursor = iterator.next(placeholder);
   }
   return ops;
@@ -102646,7 +102887,7 @@ var analyzeTaskSteps = (task2, workspace) => {
   return primary.analysis;
 };
 
-// ../cli/dist/engine/cache/hasher.js
+// ../core/dist/engine/cache/hasher.js
 import { createHash as createHash2 } from "node:crypto";
 import { readFile as readFile4 } from "node:fs/promises";
 import { join as join2, relative as relative2 } from "node:path";
@@ -102695,7 +102936,7 @@ var hashNamedValues = (values) => {
   return toHex(overall);
 };
 
-// ../cli/dist/engine/cache/inference.js
+// ../core/dist/engine/cache/inference.js
 var trimCommand = (command) => command.replace(/\s+/g, " ").trim();
 var inferInputsFromCommand = (command) => {
   const normalized = trimCommand(command.toLowerCase());
@@ -102739,7 +102980,7 @@ var inferOutputsFromCommand = (command) => {
   return [];
 };
 
-// ../cli/dist/engine/cache/store.js
+// ../core/dist/engine/cache/store.js
 import { existsSync } from "node:fs";
 import { mkdir as mkdir2, readFile as readFile5, readdir as readdir2, rm, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
 import { join as join3 } from "node:path";
@@ -102945,7 +103186,7 @@ class CacheStore {
   }
 }
 
-// ../cli/dist/engine/cache/coordinator.js
+// ../core/dist/engine/cache/coordinator.js
 class CacheCoordinator {
   workspace;
   settings;
@@ -103506,16 +103747,10 @@ class CacheCoordinator {
     }
   }
   toOp(value) {
-    if (value instanceof CommandBuilder) {
-      return value.op;
+    if (!isOperation(value)) {
+      throw new Error("Step yielded a non-operation value");
     }
-    if (value && typeof value === "object" && "op" in value) {
-      const maybeOp = value.op;
-      if (maybeOp && typeof maybeOp === "object" && "kind" in maybeOp) {
-        return maybeOp;
-      }
-    }
-    return value;
+    return value.toOp();
   }
   async computeCacheOpDecision(op, context, task2) {
     if (op.paths.length === 0) {
@@ -103690,7 +103925,7 @@ class CacheCoordinator {
   }
 }
 
-// ../cli/dist/engine/handlers/annotate-handler.js
+// ../core/dist/engine/handlers/annotate-handler.js
 class AnnotateHandler {
   kind = "annotate";
   async execute(op, context, _state) {
@@ -103699,7 +103934,7 @@ class AnnotateHandler {
   }
 }
 
-// ../cli/dist/engine/handlers/artifact-download-handler.js
+// ../core/dist/engine/handlers/artifact-download-handler.js
 import { existsSync as existsSync2 } from "node:fs";
 import { mkdir as mkdir3, readFile as readFile6 } from "node:fs/promises";
 import { join as join5, relative as relative3 } from "node:path";
@@ -103735,7 +103970,7 @@ class ArtifactDownloadHandler {
   }
 }
 
-// ../cli/dist/engine/handlers/artifact-upload-handler.js
+// ../core/dist/engine/handlers/artifact-upload-handler.js
 import { join as join6 } from "node:path";
 class ArtifactUploadHandler {
   kind = "artifact-upload";
@@ -103760,7 +103995,7 @@ class ArtifactUploadHandler {
   }
 }
 
-// ../cli/dist/engine/handlers/bind-service-handler.js
+// ../core/dist/engine/handlers/bind-service-handler.js
 class BindServiceHandler {
   kind = "bind-service";
   async execute(op, context, _state) {
@@ -103769,7 +104004,7 @@ class BindServiceHandler {
   }
 }
 
-// ../cli/dist/engine/handlers/cache-mount-handler.js
+// ../core/dist/engine/handlers/cache-mount-handler.js
 import { existsSync as existsSync3 } from "node:fs";
 import { mkdir as mkdir4 } from "node:fs/promises";
 import { join as join7 } from "node:path";
@@ -103787,7 +104022,7 @@ class CacheMountHandler {
   }
 }
 
-// ../cli/dist/engine/handlers/command-handler.js
+// ../core/dist/engine/handlers/command-handler.js
 class CommandHandler {
   runner;
   kind = "command";
@@ -103799,7 +104034,7 @@ class CommandHandler {
   }
 }
 
-// ../cli/dist/engine/handlers/emit-handler.js
+// ../core/dist/engine/handlers/emit-handler.js
 class EmitHandler {
   kind = "emit";
   async execute(op, _context, state) {
@@ -103808,7 +104043,7 @@ class EmitHandler {
   }
 }
 
-// ../cli/dist/engine/handlers/env-handler.js
+// ../core/dist/engine/handlers/env-handler.js
 class EnvHandler {
   kind = "env";
   async execute(op, context, _state) {
@@ -103818,7 +104053,7 @@ class EnvHandler {
   }
 }
 
-// ../cli/dist/engine/handlers/http-handler.js
+// ../core/dist/engine/handlers/http-handler.js
 import { readFile as readFile7 } from "node:fs/promises";
 import { isAbsolute, resolve } from "node:path";
 class HttpHandler {
@@ -103885,7 +104120,7 @@ class HttpHandler {
   }
 }
 
-// ../cli/dist/engine/handlers/pack-handler.js
+// ../core/dist/engine/handlers/pack-handler.js
 class PackHandler {
   kind = "pack";
   async execute(op, context, state) {
@@ -103898,7 +104133,7 @@ class PackHandler {
   }
 }
 
-// ../cli/dist/engine/handlers/registry.js
+// ../core/dist/engine/handlers/registry.js
 class OpHandlerRegistry {
   handlers = new Map;
   register(handler) {
@@ -103913,7 +104148,7 @@ class OpHandlerRegistry {
   }
 }
 
-// ../cli/dist/engine/handlers/report-handler.js
+// ../core/dist/engine/handlers/report-handler.js
 class ReportHandler {
   kind = "report";
   async execute(op, context, _state) {
@@ -103927,7 +104162,7 @@ class ReportHandler {
   }
 }
 
-// ../cli/dist/engine/handlers/summary-handler.js
+// ../core/dist/engine/handlers/summary-handler.js
 class SummaryHandler {
   kind = "summary";
   async execute(op, _context, state) {
@@ -103936,7 +104171,7 @@ class SummaryHandler {
   }
 }
 
-// ../cli/dist/engine/handlers/unpack-handler.js
+// ../core/dist/engine/handlers/unpack-handler.js
 class UnpackHandler {
   executeTask;
   states;
@@ -103959,7 +104194,7 @@ class UnpackHandler {
   }
 }
 
-// ../cli/dist/engine/handlers/use-handler.js
+// ../core/dist/engine/handlers/use-handler.js
 class UseHandler {
   executeTask;
   states;
@@ -103981,7 +104216,7 @@ class UseHandler {
   }
 }
 
-// ../cli/dist/engine/executor/command-runner.js
+// ../core/dist/engine/executor/command-runner.js
 import { spawn } from "node:child_process";
 class CommandRunner {
   workspace;
@@ -104115,7 +104350,7 @@ class CommandRunner {
   }
 }
 
-// ../cli/dist/engine/executor/value-resolver.js
+// ../core/dist/engine/executor/value-resolver.js
 class ValueResolver {
   states;
   params;
@@ -104178,7 +104413,7 @@ class ValueResolver {
   }
 }
 
-// ../cli/dist/engine/executor/plan-runner.js
+// ../core/dist/engine/executor/plan-runner.js
 var mergeEnv = (...sources) => {
   const merged = {};
   for (const source of sources) {
@@ -104440,16 +104675,10 @@ class PlanRunner {
     return String(error2);
   }
   toOp(value) {
-    if (value instanceof CommandBuilder) {
-      return value.op;
+    if (!isOperation(value)) {
+      throw new Error("Step yielded a non-operation value");
     }
-    if (value && typeof value === "object" && "op" in value) {
-      const maybeOp = value.op;
-      if (maybeOp && typeof maybeOp === "object" && "kind" in maybeOp) {
-        return maybeOp;
-      }
-    }
-    return value;
+    return value.toOp();
   }
   async executeOp(op, task2, step2, env2, state) {
     if (op.kind === "artifact-upload") {
@@ -104582,7 +104811,7 @@ class PlanRunner {
   }
 }
 
-// ../cli/dist/engine/executor/executor.js
+// ../core/dist/engine/executor/executor.js
 var defaultLogger = {
   info: (message) => console.log(message),
   error: (message) => console.error(message),
@@ -104800,15 +105029,15 @@ Available plans: ${available}`);
 async function run() {
   const startTime = Date.now();
   try {
-    const plan2 = core6.getInput("plan", { required: true });
-    const file = core6.getInput("file") || ".kitsi/pipeline.ts";
-    const task2 = core6.getInput("task") || undefined;
-    const timeout = core6.getInput("timeout") || "30m";
-    const failFast = core6.getBooleanInput("fail-fast");
-    const workdirInput = core6.getInput("working-directory");
+    const plan2 = core7.getInput("plan", { required: true });
+    const file = core7.getInput("file") || ".kitsi/pipeline.ts";
+    const task2 = core7.getInput("task") || undefined;
+    const timeout = core7.getInput("timeout") || "30m";
+    const failFast = core7.getBooleanInput("fail-fast");
+    const workdirInput = core7.getInput("working-directory");
     const defaultWorkdir = process.env.GITHUB_WORKSPACE || ".";
     const workdir = !workdirInput || workdirInput === "." ? defaultWorkdir : workdirInput;
-    core6.info(`Running Kitsi plan: ${plan2}`);
+    core7.info(`Running Kitsi plan: ${plan2}`);
     const capabilities = new GitHubCapabilities;
     const groups = new GroupManager;
     const result = await runPipeline({
@@ -104827,16 +105056,16 @@ async function run() {
     });
     const duration = (Date.now() - startTime) / 1000;
     const status = Object.values(result.tasks).some((t) => t.status === "failed") ? "failed" : "success";
-    core6.setOutput("status", status);
-    core6.setOutput("duration", duration.toFixed(1));
-    core6.setOutput("tasks", JSON.stringify(result.tasks));
+    core7.setOutput("status", status);
+    core7.setOutput("duration", duration.toFixed(1));
+    core7.setOutput("tasks", JSON.stringify(result.tasks));
     await capabilities.summary.writePlanSummary(plan2, result, duration);
     if (status === "failed") {
       for (const [name, taskResult] of Object.entries(result.tasks)) {
         if (taskResult.status !== "failed")
           continue;
         if (taskResult.error) {
-          core6.error(`Task "${name}" failed: ${taskResult.error.message}`);
+          core7.error(`Task "${name}" failed: ${taskResult.error.message}`);
           const cause = taskResult.error.cause;
           if (cause) {
             const formatted = typeof cause === "string" ? cause : cause instanceof Error ? cause.message : (() => {
@@ -104849,23 +105078,23 @@ async function run() {
             for (const line of formatted.split(`
 `)) {
               if (line.trim().length > 0) {
-                core6.error(line);
+                core7.error(line);
               }
             }
           }
         } else {
-          core6.error(`Task "${name}" failed`);
+          core7.error(`Task "${name}" failed`);
         }
       }
     }
     if (status === "success") {
-      core6.info(`Plan "${plan2}" completed successfully in ${duration.toFixed(1)}s`);
+      core7.info(`Plan "${plan2}" completed successfully in ${duration.toFixed(1)}s`);
     } else {
-      core6.setFailed(`Plan "${plan2}" failed`);
+      core7.setFailed(`Plan "${plan2}" failed`);
     }
   } catch (error3) {
     const message = error3 instanceof Error ? error3.message : String(error3);
-    core6.setFailed(message);
+    core7.setFailed(message);
   }
 }
 run();