@kitsi/action 0.0.35 → 0.1.0

package/dist/index.js

@@ -125458,9 +125458,9 @@ class GroupManager {
 import { resolve as resolvePath2 } from "node:path";
 import { pathToFileURL } from "node:url";
 
-// ../core/dist/version.js
+// ../core/src/version.ts
 var VERSION = "0.0.1";
-// ../core/dist/dsl/plan.js
+// ../core/src/dsl/plan.ts
 var clonePlan = (plan, patch) => {
   const next = {
     name: patch.name ?? plan.config.name,
@@ -125562,7 +125562,7 @@ var plan = (name) => new PlanBuilder({
   concurrency: {},
   tasks: []
 });
-// ../core/dist/dsl/task.js
+// ../core/src/dsl/task.ts
 var cloneTask = (task, patch) => new TaskBuilder({
   ...task.config,
   ...patch,
@@ -125633,7 +125633,7 @@ var task = (name) => new TaskBuilder({
   inputs: [],
   cacheEnv: []
 });
-// ../core/dist/dsl/step.js
+// ../core/src/dsl/step.ts
 class StepBuilder {
   name;
   run;
@@ -125650,7 +125650,7 @@ class StepBuilder {
   }
 }
 var step = (name, run) => new StepBuilder(name, run);
-// ../core/dist/dsl/kit.js
+// ../core/src/dsl/kit.ts
 var cloneKit = (kit, patch) => new KitBuilder({
   ...kit.config,
   ...patch,
@@ -125684,7 +125684,7 @@ class KitBuilder {
   }
 }
 var kit = (name) => new KitBuilder({ name, env: {}, setupSteps: [] });
-// ../core/dist/dsl/image.js
+// ../core/src/dsl/image.ts
 class ImageBuilder {
   config;
   constructor(config) {
@@ -125698,7 +125698,7 @@ class ImageBuilder {
   }
 }
 var image = (ref) => new ImageBuilder({ ref, env: {} });
-// ../core/dist/dsl/service.js
+// ../core/src/dsl/service.ts
 class ServiceBuilder {
   config;
   constructor(config) {
@@ -125718,11 +125718,11 @@ class ServiceBuilder {
   }
 }
 var service = (imageRef) => new ServiceBuilder({ image: imageRef, env: {}, ports: [] });
-// ../core/dist/dsl/registry.js
+// ../core/src/dsl/registry.ts
 var registry = (...plansList) => ({
   plans: plansList
 });
-// ../core/dist/errors/index.js
+// ../core/src/errors/index.ts
 class CliError extends Error {
   format() {
     return this.message;
@@ -125732,7 +125732,7 @@ class NotFoundError extends CliError {
   code = "NOT_FOUND";
   exitCode = 2;
 }
-// ../core/dist/ops/operation.js
+// ../core/src/ops/operation.ts
 var isOperation = (value) => {
   if (!value || typeof value !== "object")
     return false;
@@ -125740,12 +125740,12 @@ var isOperation = (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";
 };
 
-// ../core/dist/ops/types.js
+// ../core/src/ops/types.ts
 var isSecretRef = (value) => value.kind === "secret";
 var isParamRef = (value) => value.kind === "param";
 var isValueRef = (value) => value.kind === "value";
 
-// ../core/dist/dsl/glob.js
+// ../core/src/dsl/glob.ts
 var import_picomatch = __toESM(require_picomatch2(), 1);
 var GLOB_CHARS = /[*?[\]{}!]/;
 function isGlobPattern(pattern) {
@@ -125763,7 +125763,7 @@ function expandPattern(pattern, taskNames) {
   return matches;
 }
 
-// ../core/dist/dsl/analysis.js
+// ../core/src/dsl/analysis.ts
 function toOperation(value) {
   if (isOperation(value)) {
     return value;
@@ -125810,421 +125810,244 @@ function collectSecrets(tasks) {
   }
   return secrets;
 }
-// ../core/dist/dsl/utils.js
+// ../core/src/dsl/utils.ts
 import { resolve as resolvePath } from "node:path";
 var resolveWorkspace = (workspace) => {
   if (!workspace)
     return process.cwd();
   return workspace.startsWith(".") ? resolvePath(process.cwd(), workspace) : workspace;
 };
-// ../core/dist/ops/errors.js
-class OpErrorBuilder {
-  type;
-  message;
-  context = {};
-  constructor(type, message) {
-    this.type = type;
-    this.message = message;
-  }
-  inTask(task2) {
-    this.context.task = task2;
-    return this;
-  }
-  inStep(step2) {
-    this.context.step = step2;
-    return this;
-  }
-  causedBy(cause) {
-    this.context.cause = cause;
-    return this;
-  }
-  build() {
-    return { type: this.type, message: this.message, ...this.context };
-  }
-}
-var OpErrors = {
-  bundle: (message) => new OpErrorBuilder("bundle", message),
-  artifact: (message) => new OpErrorBuilder("artifact", message),
-  command: (message) => new OpErrorBuilder("command", message),
-  http: (message) => new OpErrorBuilder("http", message),
-  secret: (message) => new OpErrorBuilder("secret", message),
-  param: (message) => new OpErrorBuilder("param", message),
-  value: (message) => new OpErrorBuilder("value", message),
-  validation: (message) => new OpErrorBuilder("validation", message),
-  env: (message) => new OpErrorBuilder("env", message),
-  cache: (message) => new OpErrorBuilder("cache", message),
-  report: (message) => new OpErrorBuilder("report", message),
-  annotation: (message) => new OpErrorBuilder("annotation", message),
-  service: (message) => new OpErrorBuilder("service", message),
-  timeout: (message) => new OpErrorBuilder("timeout", message)
-};
-// ../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 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 buildTemplateParts = (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 template;
-};
-var templateFromInput = (input, values) => {
-  if (isTemplateStringsArray(input)) {
-    return buildTemplateParts(input, values);
-  }
-  if (isTemplatePartArray(input)) {
-    return input;
-  }
-  if (Array.isArray(input)) {
-    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);
-  }
-};
-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;
-  }
+// ../core/src/ops/operation-base.ts
+class OperationBase {
   analysisPlaceholder() {
-    return "";
+    return;
   }
   extractDependencies(_taskName) {
     return [];
   }
   extractSecrets() {
-    const names = new Set;
-    collectTemplateMetadata(this.op.template, (name) => names.add(name), () => {});
-    return Array.from(names);
+    return [];
   }
   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" });
+    return context.value;
   }
-  ok() {
-    return new CommandBuilder({ ...this.op, capture: "ok" });
+}
+
+// ../core/src/ops/annotate.ts
+class AnnotateOperation extends OperationBase {
+  level;
+  message;
+  location;
+  constructor(level, message, location) {
+    super();
+    this.level = level;
+    this.message = message;
+    if (location)
+      this.location = location;
   }
-  must() {
-    return new CommandBuilder({ ...this.op, capture: "must" });
+  get kind() {
+    return "annotate";
   }
-  cached(options) {
-    return new CommandBuilder({ ...this.op, cache: { enabled: true, ...options } });
+  toOp() {
+    return {
+      kind: "annotate",
+      level: this.level,
+      message: this.message,
+      ...this.location ? { location: this.location } : {}
+    };
   }
-  uncached() {
-    return new CommandBuilder({ ...this.op, cache: { enabled: false } });
+  cacheNormalize(_context) {
+    return { kind: this.kind, level: this.level, message: this.message };
   }
 }
-var sh = (strings, ...values) => {
-  const template = buildTemplateParts(strings, values);
-  return new CommandBuilder({
-    kind: "command",
-    capture: "result",
-    template
-  });
+var createAnnotation = (level) => (message, location) => new AnnotateOperation(level, message, location);
+var annotate = {
+  error: createAnnotation("error"),
+  warning: createAnnotation("warning"),
+  info: createAnnotation("info")
 };
-// ../core/dist/ops/http.js
-var hasHeader = (headers, name) => headers.some((header) => header.name.toLowerCase() === name.toLowerCase());
 
-class HttpBuilder {
-  op;
-  constructor(op) {
-    this.op = op;
+// ../core/src/ops/artifact.ts
+class ArtifactUploadOperation extends OperationBase {
+  name;
+  patterns;
+  when;
+  constructor(name, patterns, when) {
+    super();
+    this.name = name;
+    this.patterns = patterns;
+    this.when = when;
   }
   get kind() {
-    return this.op.kind;
+    return "artifact-upload";
   }
   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 [];
+    return { kind: "artifact-upload", name: this.name, patterns: this.patterns, when: this.when };
   }
-  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);
-    }
+  cacheNormalize(_context) {
     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
+      kind: this.kind,
+      name: this.name,
+      patterns: this.patterns,
+      when: this.when
     };
   }
-  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] });
-  }
-  headers(values) {
-    let builder = this;
-    for (const [name, value] of Object.entries(values)) {
-      builder = builder.header(name, value);
-    }
-    return builder;
+}
+
+class ArtifactDownloadOperation extends OperationBase {
+  name;
+  destination;
+  constructor(name, destination) {
+    super();
+    this.name = name;
+    this.destination = destination;
   }
-  body(value, ...values) {
-    return new HttpBuilder({
-      ...this.op,
-      body: templateFromInput(value, values),
-      bodyPath: undefined
-    });
+  get kind() {
+    return "artifact-download";
   }
-  bodyPath(path) {
-    return new HttpBuilder({ ...this.op, bodyPath: path, body: undefined });
+  toOp() {
+    return { kind: "artifact-download", name: this.name, destination: this.destination };
   }
-  jsonBody(value) {
-    const body = JSON.stringify(value);
-    let builder = this.body(body);
-    if (!hasHeader(builder.op.headers, "Content-Type")) {
-      builder = builder.header("Content-Type", "application/json");
-    }
-    return builder;
+  cacheNormalize(_context) {
+    return { kind: this.kind, name: this.name, destination: this.destination };
   }
 }
-var buildRequest = (method, url, values) => new HttpBuilder({
-  kind: "http",
-  method,
-  url: templateFromInput(url, values),
-  headers: []
-});
-var http = {
-  request: (method, url, ...values) => buildRequest(method, url, values),
-  get: (url, ...values) => buildRequest("GET", url, values),
-  post: (url, ...values) => buildRequest("POST", url, values),
-  put: (url, ...values) => buildRequest("PUT", url, values),
-  patch: (url, ...values) => buildRequest("PATCH", url, values),
-  delete: (url, ...values) => buildRequest("DELETE", url, values),
-  head: (url, ...values) => buildRequest("HEAD", url, values),
-  options: (url, ...values) => buildRequest("OPTIONS", url, values)
-};
-// ../core/dist/ops/env.js
-class EnvOperation {
+
+class ArtifactUploadBuilder {
   name;
-  value;
-  constructor(name, value) {
+  patterns;
+  when;
+  constructor(name, patterns = [], when = "success") {
     this.name = name;
-    this.value = value;
+    this.patterns = patterns;
+    this.when = when;
   }
-  get kind() {
-    return "env";
+  paths(...patterns) {
+    return new ArtifactUploadBuilder(this.name, patterns, this.when);
   }
-  toOp() {
-    return { kind: "env", name: this.name, value: this.value };
+  whenSuccess() {
+    return new ArtifactUploadOperation(this.name, this.patterns, "success");
   }
-  analysisPlaceholder() {
-    if (typeof this.value === "string" || typeof this.value === "number") {
-      return this.value;
-    }
-    return "";
+  whenAlways() {
+    return new ArtifactUploadOperation(this.name, this.patterns, "always");
   }
-  extractDependencies(_taskName) {
-    return [];
+}
+
+class ArtifactDownloadBuilder {
+  name;
+  constructor(name) {
+    this.name = name;
   }
-  extractSecrets() {
-    const value = this.value;
-    if (typeof value === "object" && value !== null && isSecretRef(value)) {
-      return [value.name];
-    }
-    return [];
+  to(destination) {
+    return new ArtifactDownloadOperation(this.name, destination);
   }
-  extractRefs() {
-    return [];
+}
+var artifact2 = {
+  upload: (name) => new ArtifactUploadBuilder(name),
+  download: (name) => new ArtifactDownloadBuilder(name)
+};
+
+// ../core/src/ops/bind.ts
+class BindServiceOperation extends OperationBase {
+  service;
+  alias;
+  constructor(service2, alias) {
+    super();
+    this.service = service2;
+    if (alias)
+      this.alias = alias;
   }
-  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 };
+  get kind() {
+    return "bind-service";
+  }
+  toOp() {
+    const op = { kind: "bind-service", service: this.service };
+    if (this.alias)
+      op.alias = this.alias;
+    return op;
   }
-  cachePlaceholder(context) {
-    if (typeof this.value === "string" || typeof this.value === "number") {
-      return this.value;
-    }
-    return context.isPrimary ? "" : undefined;
+  cacheNormalize(_context) {
+    return { kind: this.kind, service: this.service, alias: this.alias ?? null };
   }
 }
-var env = (name, value) => new EnvOperation(name, value);
-// ../core/dist/ops/secret.js
-var secret = (name) => ({ kind: "secret", name });
-// ../core/dist/ops/ref.js
-var coerce = {
-  string: (value) => String(value),
-  number: (value) => Number(value),
-  boolean: (value) => Boolean(value),
-  json: (value) => value
-};
-var createRefFactory = (kind) => {
-  const ref = (name, parse) => ({
-    kind,
+var bind = (serviceInstance, alias) => new BindServiceOperation(serviceInstance, alias);
+
+// ../core/src/ops/bundle.ts
+var cloneBundle = (ref, patterns) => ({
+  ...ref,
+  patterns,
+  paths: (...nextPatterns) => cloneBundle(ref, nextPatterns.length > 0 ? nextPatterns : patterns)
+});
+var createBundleRef = (name) => {
+  const ref = {
+    kind: "bundle",
     name,
-    parse
-  });
-  return {
-    string: (name) => ref(name, coerce.string),
-    number: (name) => ref(name, coerce.number),
-    boolean: (name) => ref(name, coerce.boolean),
-    json: (name) => ref(name, coerce.json)
+    patterns: [],
+    paths: (...patterns) => cloneBundle(ref, patterns)
   };
+  return ref;
 };
-var param = createRefFactory("param");
-var out = createRefFactory("value");
-// ../core/dist/ops/operation-base.js
-class OperationBase {
-  analysisPlaceholder() {
+
+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;
   }
-  extractDependencies(_taskName) {
-    return [];
+}
+
+class UnpackOperation extends OperationBase {
+  from;
+  ref;
+  constructor(from, ref) {
+    super();
+    this.from = from;
+    this.ref = ref;
   }
-  extractSecrets() {
-    return [];
+  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 [];
+    return [{ type: "bundle", ref: this.ref }];
   }
-  cachePlaceholder(context) {
-    return context.value;
+  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/cache.js
+// ../core/src/ops/cache.ts
 class CacheOperation extends OperationBase {
   name;
   paths;
@@ -126328,232 +126151,459 @@ var cacheFn = (name, options) => new CacheOperation(name, options.paths, options
 cacheFn.dir = (name) => createCacheRef(name);
 cacheFn.mount = (ref) => new CacheMountOperation(ref);
 var cache2 = cacheFn;
-// ../core/dist/ops/artifact.js
-class ArtifactUploadOperation extends OperationBase {
+
+// ../core/src/ops/env.ts
+class EnvOperation {
   name;
-  patterns;
-  when;
-  constructor(name, patterns, when) {
-    super();
+  value;
+  constructor(name, value) {
     this.name = name;
-    this.patterns = patterns;
-    this.when = when;
+    this.value = value;
   }
   get kind() {
-    return "artifact-upload";
+    return "env";
   }
   toOp() {
-    return { kind: "artifact-upload", name: this.name, patterns: this.patterns, when: this.when };
+    return { kind: "env", name: this.name, value: this.value };
   }
-  cacheNormalize(_context) {
-    return {
-      kind: this.kind,
-      name: this.name,
-      patterns: this.patterns,
-      when: this.when
-    };
+  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);
 
-class ArtifactDownloadOperation extends OperationBase {
-  name;
-  destination;
-  constructor(name, destination) {
-    super();
-    this.name = name;
-    this.destination = destination;
+// ../core/src/ops/template.ts
+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 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 buildTemplateParts = (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 template;
+};
+var templateFromInput = (input, values) => {
+  if (isTemplateStringsArray(input)) {
+    return buildTemplateParts(input, values);
+  }
+  if (isTemplatePartArray(input)) {
+    return input;
+  }
+  if (Array.isArray(input)) {
+    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);
+  }
+};
+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/src/ops/http.ts
+var hasHeader = (headers, name) => headers.some((header) => header.name.toLowerCase() === name.toLowerCase());
+
+class HttpBuilder {
+  op;
+  constructor(op) {
+    this.op = op;
   }
   get kind() {
-    return "artifact-download";
+    return this.op.kind;
   }
   toOp() {
-    return { kind: "artifact-download", name: this.name, destination: this.destination };
+    return this.op;
   }
-  cacheNormalize(_context) {
-    return { kind: this.kind, name: this.name, destination: this.destination };
+  analysisPlaceholder() {
+    return { status: 200, ok: true, headers: {}, body: "" };
   }
-}
-
-class ArtifactUploadBuilder {
-  name;
-  patterns;
-  when;
-  constructor(name, patterns = [], when = "success") {
-    this.name = name;
-    this.patterns = patterns;
-    this.when = when;
+  extractDependencies(_taskName) {
+    return [];
   }
-  paths(...patterns) {
-    return new ArtifactUploadBuilder(this.name, patterns, this.when);
+  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);
   }
-  whenSuccess() {
-    return new ArtifactUploadOperation(this.name, this.patterns, "success");
+  extractRefs() {
+    return [];
   }
-  whenAlways() {
-    return new ArtifactUploadOperation(this.name, this.patterns, "always");
+  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
+    };
   }
-}
-
-class ArtifactDownloadBuilder {
-  name;
-  constructor(name) {
-    this.name = name;
+  cachePlaceholder(context) {
+    if (!context.isPrimary)
+      return;
+    return { status: 200, ok: true, headers: {}, body: "" };
   }
-  to(destination) {
-    return new ArtifactDownloadOperation(this.name, destination);
+  header(name, value, ...values) {
+    const next = { name, value: templateFromInput(value, values) };
+    return new HttpBuilder({ ...this.op, headers: [...this.op.headers, next] });
+  }
+  headers(values) {
+    let builder = this;
+    for (const [name, value] of Object.entries(values)) {
+      builder = builder.header(name, value);
+    }
+    return builder;
+  }
+  body(value, ...values) {
+    return new HttpBuilder({
+      ...this.op,
+      body: templateFromInput(value, values),
+      bodyPath: undefined
+    });
+  }
+  bodyPath(path) {
+    return new HttpBuilder({ ...this.op, bodyPath: path, body: undefined });
+  }
+  jsonBody(value) {
+    const body = JSON.stringify(value);
+    let builder = this.body(body);
+    if (!hasHeader(builder.op.headers, "Content-Type")) {
+      builder = builder.header("Content-Type", "application/json");
+    }
+    return builder;
   }
 }
-var artifact2 = {
-  upload: (name) => new ArtifactUploadBuilder(name),
-  download: (name) => new ArtifactDownloadBuilder(name)
-};
-// ../core/dist/ops/bundle.js
-var cloneBundle = (ref, patterns) => ({
-  ...ref,
-  patterns,
-  paths: (...nextPatterns) => cloneBundle(ref, nextPatterns.length > 0 ? nextPatterns : patterns)
+var buildRequest = (method, url, values) => new HttpBuilder({
+  kind: "http",
+  method,
+  url: templateFromInput(url, values),
+  headers: []
 });
-var createBundleRef = (name) => {
-  const ref = {
-    kind: "bundle",
+var http = {
+  request: (method, url, ...values) => buildRequest(method, url, values),
+  get: (url, ...values) => buildRequest("GET", url, values),
+  post: (url, ...values) => buildRequest("POST", url, values),
+  put: (url, ...values) => buildRequest("PUT", url, values),
+  patch: (url, ...values) => buildRequest("PATCH", url, values),
+  delete: (url, ...values) => buildRequest("DELETE", url, values),
+  head: (url, ...values) => buildRequest("HEAD", url, values),
+  options: (url, ...values) => buildRequest("OPTIONS", url, values)
+};
+
+// ../core/src/ops/ref.ts
+var coerce = {
+  string: (value) => String(value),
+  number: (value) => Number(value),
+  boolean: (value) => Boolean(value),
+  json: (value) => value
+};
+var createRefFactory = (kind) => {
+  const ref = (name, parse) => ({
+    kind,
     name,
-    patterns: [],
-    paths: (...patterns) => cloneBundle(ref, patterns)
+    parse
+  });
+  return {
+    string: (name) => ref(name, coerce.string),
+    number: (name) => ref(name, coerce.number),
+    boolean: (name) => ref(name, coerce.boolean),
+    json: (name) => ref(name, coerce.json)
   };
-  return ref;
 };
+var param = createRefFactory("param");
+var out = createRefFactory("value");
+
+// ../core/src/ops/output.ts
+var out2 = {
+  ...out,
+  bundle: (name) => createBundleRef(name)
+};
+var emit = (ref, value) => new EmitOperation(ref, value);
+var use = (from, ref) => new UseOperation(from, ref);
 
-class PackOperation extends OperationBase {
+class EmitOperation {
   ref;
-  constructor(ref) {
-    super();
+  value;
+  constructor(ref, value) {
     this.ref = ref;
+    this.value = value;
   }
   get kind() {
-    return "pack";
+    return "emit";
   }
   toOp() {
-    return { kind: "pack", ref: this.ref };
+    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, name: this.ref.name, patterns: this.ref.patterns };
+    return { kind: this.kind, ref: this.ref.name, value: this.value };
   }
   cachePlaceholder(_context) {
-    return;
+    return this.value;
   }
 }
 
-class UnpackOperation extends OperationBase {
+class UseOperation {
   from;
   ref;
   constructor(from, ref) {
-    super();
     this.from = from;
     this.ref = ref;
   }
   get kind() {
-    return "unpack";
+    return "use";
   }
   toOp() {
-    return { kind: "unpack", from: this.from, ref: this.ref };
+    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: "unpack" }];
+    return [{ from: this.from.config.name, to: taskName, type: "use" }];
+  }
+  extractSecrets() {
+    return [];
   }
   extractRefs() {
-    return [{ type: "bundle", ref: this.ref }];
+    return [{ type: "value", 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
-    };
+    return { kind: this.kind, from: this.from.config.name, ref: this.ref.name };
   }
-  cachePlaceholder(_context) {
-    return;
+  cachePlaceholder(context) {
+    return context.isPrimary ? this.ref.parse("") : undefined;
   }
 }
-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)
+// ../core/src/ops/report.ts
+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) => new ReportOperation("junit", path),
+  coverage: (path) => new ReportOperation("coverage", path)
 };
-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;
+// ../core/src/ops/secret.ts
+var secret = (name) => ({ kind: "secret", name });
+
+// ../core/src/ops/shell.ts
+class CommandBuilder {
+  op;
+  constructor(op) {
+    this.op = op;
   }
   get kind() {
-    return "emit";
+    return this.op.kind;
   }
   toOp() {
-    return { kind: "emit", ref: this.ref, value: this.value };
+    return this.op;
   }
   analysisPlaceholder() {
-    return this.value;
+    return "";
   }
   extractDependencies(_taskName) {
     return [];
   }
   extractSecrets() {
-    return [];
+    const names = new Set;
+    collectTemplateMetadata(this.op.template, (name) => names.add(name), () => {});
+    return Array.from(names);
   }
   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";
+  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)
+    };
   }
-  toOp() {
-    return { kind: "use", from: this.from, ref: this.ref };
+  cachePlaceholder(context) {
+    if (!context.isPrimary)
+      return;
+    if (this.op.capture === "ok")
+      return true;
+    if (this.op.capture === "code")
+      return 0;
+    return "";
   }
-  analysisPlaceholder() {
-    return this.ref.parse("");
+  stdout() {
+    return new CommandBuilder({ ...this.op, capture: "stdout" });
   }
-  extractDependencies(taskName) {
-    return [{ from: this.from.config.name, to: taskName, type: "use" }];
+  code() {
+    return new CommandBuilder({ ...this.op, capture: "code" });
   }
-  extractSecrets() {
-    return [];
+  ok() {
+    return new CommandBuilder({ ...this.op, capture: "ok" });
   }
-  extractRefs() {
-    return [{ type: "value", ref: this.ref }];
+  must() {
+    return new CommandBuilder({ ...this.op, capture: "must" });
   }
-  cacheNormalize(context) {
-    context.addDependency(this.from.config.name);
-    return { kind: this.kind, from: this.from.config.name, ref: this.ref.name };
+  cached(options) {
+    return new CommandBuilder({ ...this.op, cache: { enabled: true, ...options } });
   }
-  cachePlaceholder(context) {
-    return context.isPrimary ? this.ref.parse("") : undefined;
+  uncached() {
+    return new CommandBuilder({ ...this.op, cache: { enabled: false } });
   }
 }
-// ../core/dist/ops/summary.js
+var sh = (strings, ...values) => {
+  const template = buildTemplateParts(strings, values);
+  return new CommandBuilder({
+    kind: "command",
+    capture: "result",
+    template
+  });
+};
+
+// ../core/src/ops/summary.ts
 class SummaryOperation extends OperationBase {
   format;
   content;
@@ -126575,90 +126625,92 @@ class SummaryOperation extends OperationBase {
 var summary2 = {
   md: (content) => new SummaryOperation("md", content)
 };
-// ../core/dist/ops/annotate.js
-class AnnotateOperation extends OperationBase {
-  level;
+
+// ../core/src/dsl/pipeline-globals.ts
+var KITSI_GLOBALS_KEY = Symbol.for("kitsi.globals");
+var KITSI_GLOBALS = {
+  plan,
+  task,
+  step,
+  kit,
+  image,
+  service,
+  registry,
+  sh,
+  http,
+  secret,
+  env,
+  param,
+  out: out2,
+  emit,
+  use,
+  pack,
+  unpack,
+  artifact: artifact2,
+  cache: cache2,
+  cacheOr,
+  report,
+  annotate,
+  summary: summary2,
+  bind
+};
+var registerPipelineGlobals = () => {
+  const target = globalThis;
+  if (target[KITSI_GLOBALS_KEY])
+    return;
+  Object.assign(target, KITSI_GLOBALS);
+  Object.defineProperty(target, KITSI_GLOBALS_KEY, {
+    value: true,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+};
+// ../core/src/ops/errors.ts
+class OpErrorBuilder {
+  type;
   message;
-  location;
-  constructor(level, message, location) {
-    super();
-    this.level = level;
+  context = {};
+  constructor(type, message) {
+    this.type = type;
     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")
-};
-// ../core/dist/ops/report.js
-class ReportOperation extends OperationBase {
-  reportType;
-  path;
-  constructor(reportType, path) {
-    super();
-    this.reportType = reportType;
-    this.path = path;
+  inTask(task2) {
+    this.context.task = task2;
+    return this;
   }
-  get kind() {
-    return "report";
+  inStep(step2) {
+    this.context.step = step2;
+    return this;
   }
-  toOp() {
-    return { kind: "report", reportType: this.reportType, path: this.path };
+  causedBy(cause) {
+    this.context.cause = cause;
+    return this;
   }
-  cacheNormalize(_context) {
-    return { kind: this.kind, reportType: this.reportType, path: this.path };
+  build() {
+    return { type: this.type, message: this.message, ...this.context };
   }
 }
-var report = {
-  junit: (path) => new ReportOperation("junit", path),
-  coverage: (path) => new ReportOperation("coverage", path)
+var OpErrors = {
+  bundle: (message) => new OpErrorBuilder("bundle", message),
+  artifact: (message) => new OpErrorBuilder("artifact", message),
+  command: (message) => new OpErrorBuilder("command", message),
+  http: (message) => new OpErrorBuilder("http", message),
+  secret: (message) => new OpErrorBuilder("secret", message),
+  param: (message) => new OpErrorBuilder("param", message),
+  value: (message) => new OpErrorBuilder("value", message),
+  validation: (message) => new OpErrorBuilder("validation", message),
+  env: (message) => new OpErrorBuilder("env", message),
+  cache: (message) => new OpErrorBuilder("cache", message),
+  report: (message) => new OpErrorBuilder("report", message),
+  annotation: (message) => new OpErrorBuilder("annotation", message),
+  service: (message) => new OpErrorBuilder("service", message),
+  timeout: (message) => new OpErrorBuilder("timeout", message)
 };
-// ../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
+// ../core/src/engine/cache/coordinator.ts
 import { join as join4 } from "node:path";
 
-// ../core/dist/engine/executor/file-system.js
+// ../core/src/engine/executor/file-system.ts
 var import_picomatch2 = __toESM(require_picomatch2(), 1);
 import { mkdir as mkdir2, readFile as readFile3, readdir, stat, writeFile } from "node:fs/promises";
 import { dirname, join, relative } from "node:path";
@@ -126706,7 +126758,7 @@ var writeFiles = async (basePath, files) => {
   }));
 };
 
-// ../core/dist/engine/cache/serialize.js
+// ../core/src/engine/cache/serialize.ts
 var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var stableStringify = (value) => {
   if (value === null || value === undefined)
@@ -126726,7 +126778,7 @@ var stableStringify = (value) => {
   return JSON.stringify(String(value));
 };
 
-// ../core/dist/engine/cache/analyze.js
+// ../core/src/engine/cache/analyze.ts
 var createPlaceholderTracker = () => {
   let touched = false;
   const placeholder = new Proxy(() => {
@@ -126828,7 +126880,7 @@ var analyzeTaskSteps = (task2, workspace) => {
   return primary.analysis;
 };
 
-// ../core/dist/engine/cache/hasher.js
+// ../core/src/engine/cache/hasher.ts
 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";
@@ -126877,7 +126929,7 @@ var hashNamedValues = (values) => {
   return toHex(overall);
 };
 
-// ../core/dist/engine/cache/inference.js
+// ../core/src/engine/cache/inference.ts
 var trimCommand = (command) => command.replace(/\s+/g, " ").trim();
 var inferInputsFromCommand = (command) => {
   const normalized = trimCommand(command.toLowerCase());
@@ -126921,7 +126973,7 @@ var inferOutputsFromCommand = (command) => {
   return [];
 };
 
-// ../core/dist/engine/cache/store.js
+// ../core/src/engine/cache/store.ts
 import { existsSync } from "node:fs";
 import { mkdir as mkdir3, readFile as readFile5, readdir as readdir2, rm, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
 import { join as join3 } from "node:path";
@@ -127158,7 +127210,7 @@ class CacheStore {
   }
 }
 
-// ../core/dist/engine/cache/coordinator.js
+// ../core/src/engine/cache/coordinator.ts
 class CacheCoordinator {
   workspace;
   settings;
@@ -127897,7 +127949,7 @@ class CacheCoordinator {
   }
 }
 
-// ../core/dist/engine/handlers/annotate-handler.js
+// ../core/src/engine/handlers/annotate-handler.ts
 class AnnotateHandler {
   kind = "annotate";
   async execute(op, context, _state) {
@@ -127906,7 +127958,7 @@ class AnnotateHandler {
   }
 }
 
-// ../core/dist/engine/handlers/artifact-download-handler.js
+// ../core/src/engine/handlers/artifact-download-handler.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { mkdir as mkdir4, readFile as readFile6 } from "node:fs/promises";
 import { join as join5, relative as relative3 } from "node:path";
@@ -127942,7 +127994,7 @@ class ArtifactDownloadHandler {
   }
 }
 
-// ../core/dist/engine/handlers/artifact-upload-handler.js
+// ../core/src/engine/handlers/artifact-upload-handler.ts
 import { join as join6 } from "node:path";
 class ArtifactUploadHandler {
   kind = "artifact-upload";
@@ -127967,7 +128019,7 @@ class ArtifactUploadHandler {
   }
 }
 
-// ../core/dist/engine/handlers/bind-service-handler.js
+// ../core/src/engine/handlers/bind-service-handler.ts
 class BindServiceHandler {
   kind = "bind-service";
   async execute(op, context, _state) {
@@ -127976,7 +128028,7 @@ class BindServiceHandler {
   }
 }
 
-// ../core/dist/engine/handlers/cache-mount-handler.js
+// ../core/src/engine/handlers/cache-mount-handler.ts
 import { existsSync as existsSync3 } from "node:fs";
 import { mkdir as mkdir5 } from "node:fs/promises";
 import { join as join7 } from "node:path";
@@ -127994,7 +128046,7 @@ class CacheMountHandler {
   }
 }
 
-// ../core/dist/engine/handlers/command-handler.js
+// ../core/src/engine/handlers/command-handler.ts
 class CommandHandler {
   runner;
   kind = "command";
@@ -128006,7 +128058,7 @@ class CommandHandler {
   }
 }
 
-// ../core/dist/engine/handlers/emit-handler.js
+// ../core/src/engine/handlers/emit-handler.ts
 class EmitHandler {
   kind = "emit";
   async execute(op, _context, state) {
@@ -128015,7 +128067,7 @@ class EmitHandler {
   }
 }
 
-// ../core/dist/engine/handlers/env-handler.js
+// ../core/src/engine/handlers/env-handler.ts
 class EnvHandler {
   kind = "env";
   async execute(op, context, _state) {
@@ -128025,7 +128077,7 @@ class EnvHandler {
   }
 }
 
-// ../core/dist/engine/handlers/http-handler.js
+// ../core/src/engine/handlers/http-handler.ts
 import { readFile as readFile7 } from "node:fs/promises";
 import { isAbsolute, resolve } from "node:path";
 class HttpHandler {
@@ -128092,7 +128144,7 @@ class HttpHandler {
   }
 }
 
-// ../core/dist/engine/handlers/pack-handler.js
+// ../core/src/engine/handlers/pack-handler.ts
 class PackHandler {
   kind = "pack";
   async execute(op, context, state) {
@@ -128105,7 +128157,7 @@ class PackHandler {
   }
 }
 
-// ../core/dist/engine/handlers/registry.js
+// ../core/src/engine/handlers/registry.ts
 class OpHandlerRegistry {
   handlers = new Map;
   register(handler) {
@@ -128120,7 +128172,7 @@ class OpHandlerRegistry {
   }
 }
 
-// ../core/dist/engine/handlers/report-handler.js
+// ../core/src/engine/handlers/report-handler.ts
 class ReportHandler {
   kind = "report";
   async execute(op, context, _state) {
@@ -128134,7 +128186,7 @@ class ReportHandler {
   }
 }
 
-// ../core/dist/engine/handlers/summary-handler.js
+// ../core/src/engine/handlers/summary-handler.ts
 class SummaryHandler {
   kind = "summary";
   async execute(op, _context, state) {
@@ -128143,7 +128195,7 @@ class SummaryHandler {
   }
 }
 
-// ../core/dist/engine/handlers/unpack-handler.js
+// ../core/src/engine/handlers/unpack-handler.ts
 class UnpackHandler {
   executeTask;
   states;
@@ -128166,7 +128218,7 @@ class UnpackHandler {
   }
 }
 
-// ../core/dist/engine/handlers/use-handler.js
+// ../core/src/engine/handlers/use-handler.ts
 class UseHandler {
   executeTask;
   states;
@@ -128188,7 +128240,7 @@ class UseHandler {
   }
 }
 
-// ../core/dist/engine/executor/buffering-reporter.js
+// ../core/src/engine/executor/buffering-reporter.ts
 class BufferingReporter {
   target;
   taskBuffers = new Map;
@@ -128240,7 +128292,7 @@ class BufferingReporter {
   }
 }
 
-// ../core/dist/engine/executor/command-runner.js
+// ../core/src/engine/executor/command-runner.ts
 import { spawn } from "node:child_process";
 class CommandRunner {
   workspace;
@@ -128374,7 +128426,7 @@ class CommandRunner {
   }
 }
 
-// ../core/dist/engine/executor/value-resolver.js
+// ../core/src/engine/executor/value-resolver.ts
 class ValueResolver {
   states;
   params;
@@ -128437,7 +128489,7 @@ class ValueResolver {
   }
 }
 
-// ../core/dist/engine/executor/plan-runner.js
+// ../core/src/engine/executor/plan-runner.ts
 function mergeEnv(...sources) {
   const merged = {};
   for (const source of sources) {
@@ -128894,7 +128946,7 @@ class PlanRunner {
   }
 }
 
-// ../core/dist/engine/executor/executor.js
+// ../core/src/engine/executor/executor.ts
 var defaultLogger = {
   info: (message) => console.log(message),
   error: (message) => console.error(message),
@@ -128921,46 +128973,8 @@ var runPlan = async (registryOrPlan, planName, options = {}) => {
   return runner.run();
 };
 // ../cli/dist/bin/pipeline-authoring.js
-var KITSI_GLOBALS_KEY = Symbol.for("kitsi.globals");
 var KITSI_TYPES_VERSION = VERSION;
-var KITSI_GLOBALS = {
-  plan,
-  task,
-  step,
-  kit,
-  image,
-  service,
-  registry,
-  sh,
-  http,
-  secret,
-  env,
-  param,
-  out: out2,
-  emit,
-  use,
-  pack,
-  unpack,
-  artifact: artifact2,
-  cache: cache2,
-  cacheOr,
-  report,
-  annotate,
-  summary: summary2,
-  bind
-};
-var registerPipelineGlobals = () => {
-  const target = globalThis;
-  if (target[KITSI_GLOBALS_KEY])
-    return;
-  Object.assign(target, KITSI_GLOBALS);
-  Object.defineProperty(target, KITSI_GLOBALS_KEY, {
-    value: true,
-    enumerable: false,
-    configurable: false,
-    writable: false
-  });
-};
+var registerPipelineGlobals2 = registerPipelineGlobals;
 var KITSI_TYPES_HEADER = `// @kitsi-types v${KITSI_TYPES_VERSION}
 // Generated by kitsi types - do not edit manually
 `;
@@ -129003,7 +129017,7 @@ function parseTimeout(timeout) {
   }
 }
 async function loadPipeline(file, cwd) {
-  registerPipelineGlobals();
+  registerPipelineGlobals2();
   const resolved = resolvePath2(cwd, file);
   const moduleUrl = pathToFileURL(resolved).href;
   const loaded = await import(moduleUrl);