@kitsi/action 0.0.14 → 0.0.15

package/dist/index.js

@@ -101818,97 +101818,22 @@ var service = (imageRef) => new ServiceBuilder({ image: imageRef, env: {}, ports
 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
-  });
+// ../cli/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
 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());
     }
   }
 };
@@ -102019,6 +101912,132 @@ var OpErrors = {
   service: (message) => new OpErrorBuilder("service", message),
   timeout: (message) => new OpErrorBuilder("timeout", message)
 };
+// ../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 };
+};
+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);
+  }
+};
+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();
+};
+
+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 = [];
+  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
+  });
+};
 // ../cli/dist/ops/http.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]));
@@ -102061,12 +102080,91 @@ var templateFromInput = (input, values) => {
   return [toTemplatePart2(input)];
 };
 var hasHeader = (headers, name) => headers.some((header) => header.name.toLowerCase() === name.toLowerCase());
+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 collectTemplateMetadata2 = (template, addSecret, addParam) => {
+  for (const part of template) {
+    if (part.type === "secret")
+      addSecret(part.name);
+    if (part.type === "param")
+      addParam(part.ref.name);
+  }
+};
+var normalizeTemplatePart2 = (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 };
+};
 
 class HttpBuilder {
   op;
   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) {
+    collectTemplateMetadata2(this.op.url, context.addSecret, context.addParam);
+    for (const header of this.op.headers) {
+      collectTemplateMetadata2(header.value, context.addSecret, context.addParam);
+    }
+    if (this.op.body) {
+      collectTemplateMetadata2(this.op.body, context.addSecret, context.addParam);
+    }
+    return {
+      kind: this.op.kind,
+      method: this.op.method,
+      url: this.op.url.map(normalizeTemplatePart2),
+      headers: this.op.headers.map((header) => ({
+        name: header.name,
+        value: header.value.map(normalizeTemplatePart2)
+      })),
+      body: this.op.body ? this.op.body.map(normalizeTemplatePart2) : 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,12 +102211,73 @@ var http = {
   head: (url, ...values) => buildRequest("HEAD", url, values),
   options: (url, ...values) => buildRequest("OPTIONS", url, values)
 };
+// ../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/ops/env.js
-var env = (name, value) => ({
-  kind: "env",
-  name,
-  value
-});
+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);
 // ../cli/dist/ops/secret.js
 var secret = (name) => ({ kind: "secret", name });
 // ../cli/dist/ops/ref.js
@@ -102144,6 +102303,133 @@ var createRefFactory = (kind) => {
 var param = createRefFactory("param");
 var out = createRefFactory("value");
 // ../cli/dist/ops/cache.js
+class CacheOperation {
+  name;
+  paths;
+  key;
+  constructor(name, paths, key) {
+    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 } : {}
+    };
+  }
+  analysisPlaceholder() {
+    return;
+  }
+  extractDependencies(_taskName) {
+    return [];
+  }
+  extractSecrets() {
+    return [];
+  }
+  extractRefs() {
+    return [];
+  }
+  cacheNormalize(_context) {
+    return {
+      kind: this.kind,
+      name: this.name,
+      paths: this.paths,
+      key: this.key ?? null
+    };
+  }
+  cachePlaceholder(context) {
+    return context.value;
+  }
+}
+
+class CacheOrOperation {
+  name;
+  paths;
+  key;
+  compute;
+  constructor(name, paths, compute, key) {
+    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
+    };
+  }
+  analysisPlaceholder() {
+    return;
+  }
+  extractDependencies(_taskName) {
+    return [];
+  }
+  extractSecrets() {
+    return [];
+  }
+  extractRefs() {
+    return [];
+  }
+  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
+    };
+  }
+  cachePlaceholder(context) {
+    return context.value;
+  }
+}
+
+class CacheMountOperation {
+  cache;
+  constructor(cache2) {
+    this.cache = cache2;
+  }
+  get kind() {
+    return "cache-mount";
+  }
+  toOp() {
+    return { kind: "cache-mount", cache: this.cache };
+  }
+  analysisPlaceholder() {
+    return;
+  }
+  extractDependencies(_taskName) {
+    return [];
+  }
+  extractSecrets() {
+    return [];
+  }
+  extractRefs() {
+    return [];
+  }
+  cacheNormalize(_context) {
+    return { kind: this.kind };
+  }
+  cachePlaceholder(context) {
+    return context.value;
+  }
+}
 var createCacheRef = (name, mountPath, key) => {
   const ref = {
     kind: "cache",
@@ -102157,26 +102443,85 @@ 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
+class ArtifactUploadOperation {
+  name;
+  patterns;
+  when;
+  constructor(name, patterns, when) {
+    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 };
+  }
+  analysisPlaceholder() {
+    return;
+  }
+  extractDependencies(_taskName) {
+    return [];
+  }
+  extractSecrets() {
+    return [];
+  }
+  extractRefs() {
+    return [];
+  }
+  cacheNormalize(_context) {
+    return {
+      kind: this.kind,
+      name: this.name,
+      patterns: this.patterns,
+      when: this.when
+    };
+  }
+  cachePlaceholder(context) {
+    return context.value;
+  }
+}
+
+class ArtifactDownloadOperation {
+  name;
+  destination;
+  constructor(name, destination) {
+    this.name = name;
+    this.destination = destination;
+  }
+  get kind() {
+    return "artifact-download";
+  }
+  toOp() {
+    return { kind: "artifact-download", name: this.name, destination: this.destination };
+  }
+  analysisPlaceholder() {
+    return;
+  }
+  extractDependencies(_taskName) {
+    return [];
+  }
+  extractSecrets() {
+    return [];
+  }
+  extractRefs() {
+    return [];
+  }
+  cacheNormalize(_context) {
+    return { kind: this.kind, name: this.name, destination: this.destination };
+  }
+  cachePlaceholder(context) {
+    return context.value;
+  }
+}
+
 class ArtifactUploadBuilder {
   name;
   patterns;
@@ -102190,10 +102535,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,7 +102548,7 @@ class ArtifactDownloadBuilder {
     this.name = name;
   }
   to(destination) {
-    return { kind: "artifact-download", name: this.name, destination };
+    return new ArtifactDownloadOperation(this.name, destination);
   }
 }
 var artifact2 = {
@@ -102225,75 +102570,311 @@ var createBundleRef = (name) => {
   };
   return ref;
 };
-var pack = (ref) => ({
-  kind: "pack",
-  ref
-});
-var unpack = (from, ref) => ({
-  kind: "unpack",
-  from,
-  ref
-});
+
+class PackOperation {
+  ref;
+  constructor(ref) {
+    this.ref = ref;
+  }
+  get kind() {
+    return "pack";
+  }
+  toOp() {
+    return { kind: "pack", ref: this.ref };
+  }
+  analysisPlaceholder() {
+    return;
+  }
+  extractDependencies(_taskName) {
+    return [];
+  }
+  extractSecrets() {
+    return [];
+  }
+  extractRefs() {
+    return [];
+  }
+  cacheNormalize(_context) {
+    return { kind: this.kind, name: this.ref.name, patterns: this.ref.patterns };
+  }
+  cachePlaceholder(_context) {
+    return;
+  }
+}
+
+class UnpackOperation {
+  from;
+  ref;
+  constructor(from, ref) {
+    this.from = from;
+    this.ref = ref;
+  }
+  get kind() {
+    return "unpack";
+  }
+  toOp() {
+    return { kind: "unpack", from: this.from, ref: this.ref };
+  }
+  analysisPlaceholder() {
+    return;
+  }
+  extractDependencies(taskName) {
+    return [{ from: this.from.config.name, to: taskName, type: "unpack" }];
+  }
+  extractSecrets() {
+    return [];
+  }
+  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);
 
 // ../cli/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
-});
+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;
+  }
+}
 // ../cli/dist/ops/summary.js
+class SummaryOperation {
+  format;
+  content;
+  constructor(format, content) {
+    this.format = format;
+    this.content = content;
+  }
+  get kind() {
+    return "summary";
+  }
+  toOp() {
+    return { kind: "summary", format: this.format, content: this.content };
+  }
+  analysisPlaceholder() {
+    return;
+  }
+  extractDependencies(_taskName) {
+    return [];
+  }
+  extractSecrets() {
+    return [];
+  }
+  extractRefs() {
+    return [];
+  }
+  cacheNormalize(_context) {
+    return { kind: this.kind, format: this.format, content: this.content };
+  }
+  cachePlaceholder(context) {
+    return context.value;
+  }
+}
 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 } : {}
-});
+class AnnotateOperation {
+  level;
+  message;
+  location;
+  constructor(level, message, location) {
+    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 } : {}
+    };
+  }
+  analysisPlaceholder() {
+    return;
+  }
+  extractDependencies(_taskName) {
+    return [];
+  }
+  extractSecrets() {
+    return [];
+  }
+  extractRefs() {
+    return [];
+  }
+  cacheNormalize(_context) {
+    return { kind: this.kind, level: this.level, message: this.message };
+  }
+  cachePlaceholder(context) {
+    return context.value;
+  }
+}
+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
+class ReportOperation {
+  reportType;
+  path;
+  constructor(reportType, path) {
+    this.reportType = reportType;
+    this.path = path;
+  }
+  get kind() {
+    return "report";
+  }
+  toOp() {
+    return { kind: "report", reportType: this.reportType, path: this.path };
+  }
+  analysisPlaceholder() {
+    return;
+  }
+  extractDependencies(_taskName) {
+    return [];
+  }
+  extractSecrets() {
+    return [];
+  }
+  extractRefs() {
+    return [];
+  }
+  cacheNormalize(_context) {
+    return { kind: this.kind, reportType: this.reportType, path: this.path };
+  }
+  cachePlaceholder(context) {
+    return context.value;
+  }
+}
 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";
+class BindServiceOperation {
+  service;
+  alias;
+  constructor(service2, alias) {
+    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;
+  }
+  analysisPlaceholder() {
+    return;
+  }
+  extractDependencies(_taskName) {
+    return [];
+  }
+  extractSecrets() {
+    return [];
+  }
+  extractRefs() {
+    return [];
+  }
+  cacheNormalize(_context) {
+    return { kind: this.kind, service: this.service, alias: this.alias ?? null };
+  }
+  cachePlaceholder(context) {
+    return context.value;
+  }
+}
+var bind = (serviceInstance, alias) => new BindServiceOperation(serviceInstance, alias);
 // ../cli/dist/engine/cache/coordinator.js
 import { join as join4 } from "node:path";
 
@@ -102390,219 +102971,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 };
-  }
-  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 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
   }
-};
+});
 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;
@@ -103506,16 +103908,10 @@ class CacheCoordinator {
     }
   }
   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;
-      }
+    if (!isOperation(value)) {
+      throw new Error("Step yielded a non-operation value");
     }
-    return value;
+    return value.toOp();
   }
   async computeCacheOpDecision(op, context, task2) {
     if (op.paths.length === 0) {
@@ -104440,16 +104836,10 @@ class PlanRunner {
     return String(error2);
   }
   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;
-      }
+    if (!isOperation(value)) {
+      throw new Error("Step yielded a non-operation value");
     }
-    return value;
+    return value.toOp();
   }
   async executeOp(op, task2, step2, env2, state) {
     if (op.kind === "artifact-upload") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitsi/action",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "GitHub Action for running Kitsi pipelines",
   "type": "module",
   "main": "./dist/index.js",