@scarn/sdk 0.0.0 → 0.8.0

package/dist/chunk-k4y5qt4y.js

@@ -0,0 +1,14 @@
+// @bun
+import {
+  exports_external
+} from "./chunk-skzxcba3.js";
+
+// src/managed-runtimes.ts
+var MANAGED_RUNTIME_IDS = ["bun1", "node24"];
+var DEFAULT_CODE_STEP_RUNTIME_ID = "bun1";
+var managedRuntimeIdSchema = exports_external.enum(MANAGED_RUNTIME_IDS);
+function isManagedRuntimeId(value) {
+  return MANAGED_RUNTIME_IDS.includes(value);
+}
+
+export { MANAGED_RUNTIME_IDS, DEFAULT_CODE_STEP_RUNTIME_ID, managedRuntimeIdSchema, isManagedRuntimeId };

package/dist/{chunk-eg1hcvhb.js → chunk-mz53r914.js}

@@ -45,15 +45,15 @@ function formatSite(site) {
 }
 
 // src/pipelines/errors.ts
-function formatIssue2(issue) {
+function formatIssue(issue) {
   return `${formatSite(issue.site)} (${issue.pointer === "" ? "/" : issue.pointer}): ${issue.message}`;
 }
 
-class PipelineBuildError2 extends Error {
+class PipelineBuildError extends Error {
   issues;
   constructor(key, issues) {
     super(`Pipeline "${key}" has ${String(issues.length)} build error${issues.length === 1 ? "" : "s"}:
-${issues.map((issue) => `  ${formatIssue2(issue)}`).join(`
+${issues.map((issue) => `  ${formatIssue(issue)}`).join(`
 `)}`);
     this.name = "PipelineBuildError";
     this.issues = issues;
@@ -69,18 +69,6 @@ class AuthoringError extends Error {
   }
 }
 
-// src/pipelines/model.ts
-function emptyChain(node) {
-  return {
-    node,
-    settings: {},
-    retry: [],
-    catch: [],
-    next: undefined,
-    site: captureSite()
-  };
-}
-
 // src/pipelines/registry.ts
 var nodes = new WeakMap;
 var targets = new WeakMap;
@@ -129,6 +117,18 @@ function requireNode(value, what) {
   return node;
 }
 
+// src/pipelines/model.ts
+function emptyChain(node) {
+  return {
+    node,
+    settings: {},
+    retry: [],
+    catch: [],
+    next: undefined,
+    site: captureSite()
+  };
+}
+
 // src/pipelines/chain.ts
 function next(data, change) {
   return chainValue({ ...data, ...change, site: captureSite() });
@@ -297,4 +297,4 @@ function bareStepHandle(source, local) {
   return stepHandleFor(stepNode(source, local));
 }
 
-export { captureSite, formatIssue2, PipelineBuildError2, AuthoringError, pendingChains, registerNode, registerTarget, registerEach, nodeOf, targetOf, eachOf, chainOf, requireNode, makeHandle, stepNode, stepCall, waitHandle, bareStepHandle };
+export { captureSite, formatIssue, PipelineBuildError, AuthoringError, pendingChains, registerNode, registerTarget, registerEach, nodeOf, targetOf, eachOf, chainOf, requireNode, makeHandle, stepNode, stepCall, waitHandle, bareStepHandle };

package/dist/{chunk-631ffb6r.js → chunk-ngy1fdcx.js}

@@ -1,6 +1,6 @@
 // @bun
 // src/contracts/artifact-markers.ts
-var ARTIFACT_MARKER_SCHEME2 = "artifact:";
+var ARTIFACT_MARKER_SCHEME = "artifact:";
 var SIGNAL_REF_PREFIX = "signal/";
 var MARKER_PATTERN = /(!?)\[((?:\\.|[^\\\]\n])*)\]\((?:<artifact:((?:\\.|[^\\<>\n])*)>|artifact:((?:\\.|[^\\()\s])*))\)/g;
 var unescapeMarkerText = (value) => value.replace(/\\(.)/g, "$1");
@@ -10,11 +10,11 @@ var formatMarkerDestination = (rawRef) => {
     if (/[\n\r]/.test(rawRef)) {
       throw new Error("Artifact marker refs cannot contain line breaks.");
     }
-    return `<${ARTIFACT_MARKER_SCHEME2}${rawRef.replace(/[\\<>]/g, "\\$&")}>`;
+    return `<${ARTIFACT_MARKER_SCHEME}${rawRef.replace(/[\\<>]/g, "\\$&")}>`;
   }
-  return `${ARTIFACT_MARKER_SCHEME2}${rawRef.replace(/[\\()]/g, "\\$&")}`;
+  return `${ARTIFACT_MARKER_SCHEME}${rawRef.replace(/[\\()]/g, "\\$&")}`;
 };
-function parseArtifactMarkerRef2(rawRef) {
+function parseArtifactMarkerRef(rawRef) {
   if (!rawRef.startsWith(SIGNAL_REF_PREFIX)) {
     return { type: "path", pattern: rawRef };
   }
@@ -26,18 +26,18 @@ function parseArtifactMarkerRef2(rawRef) {
     signalKey: rest.slice(slash + 1)
   };
 }
-function formatArtifactMarkerRef2(ref) {
+function formatArtifactMarkerRef(ref) {
   return ref.type === "signal" ? `${SIGNAL_REF_PREFIX}${ref.stepKey}/${ref.signalKey}` : ref.pattern;
 }
-function buildArtifactMarker2(kind, ref, text) {
-  const rawRef = formatArtifactMarkerRef2(ref);
+function buildArtifactMarker(kind, ref, text) {
+  const rawRef = formatArtifactMarkerRef(ref);
   if (rawRef.length === 0) {
     throw new Error("Artifact marker refs cannot be empty.");
   }
   const bang = kind === "embed" ? "!" : "";
   return `${bang}[${escapeMarkerText(text)}](${formatMarkerDestination(rawRef)})`;
 }
-function findArtifactMarkers2(text) {
+function findArtifactMarkers(text) {
   const matches = [];
   for (const match of text.matchAll(MARKER_PATTERN)) {
     const [whole, bang, label, bracketedRef, bareRef] = match;
@@ -46,7 +46,7 @@ function findArtifactMarkers2(text) {
       kind: bang === "!" ? "embed" : "link",
       text: unescapeMarkerText(label ?? ""),
       rawRef,
-      ref: parseArtifactMarkerRef2(rawRef),
+      ref: parseArtifactMarkerRef(rawRef),
       start: match.index,
       end: match.index + whole.length
     });
@@ -54,4 +54,4 @@ function findArtifactMarkers2(text) {
   return matches;
 }
 
-export { ARTIFACT_MARKER_SCHEME2, parseArtifactMarkerRef2, formatArtifactMarkerRef2, buildArtifactMarker2, findArtifactMarkers2 };
+export { ARTIFACT_MARKER_SCHEME, parseArtifactMarkerRef, formatArtifactMarkerRef, buildArtifactMarker, findArtifactMarkers };

package/dist/chunk-p7yrcmqm.js

@@ -0,0 +1,322 @@
+// @bun
+import {
+  exports_external
+} from "./chunk-skzxcba3.js";
+
+// src/contracts/pipeline-document/json.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function escapePointerSegment(segment) {
+  return String(segment).replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function jsonPointer(segments) {
+  return segments.map((segment) => `/${escapePointerSegment(segment)}`).join("");
+}
+function deepEqual(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (Array.isArray(left)) {
+    return Array.isArray(right) && left.length === right.length && left.every((item, index) => deepEqual(item, right[index]));
+  }
+  if (isJsonObject(left) && isJsonObject(right)) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    return leftKeys.length === rightKeys.length && leftKeys.every((key) => Object.hasOwn(right, key) && deepEqual(left[key], right[key]));
+  }
+  return false;
+}
+// src/contracts/pipeline-document/conditions/operators.ts
+var COMPARISON_OPERATORS = [
+  "equal",
+  "notEqual",
+  "lessThan",
+  "lessThanInclusive",
+  "greaterThan",
+  "greaterThanInclusive"
+];
+var CONDITION_OPERATORS = [
+  ...COMPARISON_OPERATORS,
+  "exists",
+  "isEmpty",
+  "contains",
+  "startsWith",
+  "endsWith",
+  "matches",
+  "before",
+  "after",
+  "some",
+  "every",
+  "none"
+];
+var COMPUTED_FUNCTIONS = [
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "count"
+];
+var ORDERING_OPERATORS = new Set([
+  "lessThan",
+  "lessThanInclusive",
+  "greaterThan",
+  "greaterThanInclusive"
+]);
+var STRING_OPERATORS = new Set([
+  "startsWith",
+  "endsWith",
+  "matches"
+]);
+var DATE_OPERATORS = new Set(["before", "after"]);
+var LIST_OPERATORS = new Set(["some", "every", "none"]);
+
+// src/contracts/pipeline-document/schema.ts
+var NODE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+var ALIAS_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var nodeIdSchema = exports_external.string().regex(NODE_ID_PATTERN, "Node ids may only contain letters, digits, '_' and '-'");
+var jsonValueSchema = exports_external.json();
+var literalSchema = exports_external.strictObject({ value: jsonValueSchema });
+var scalarArgSchema = exports_external.union([exports_external.string().min(1), literalSchema]);
+var listSchema = exports_external.strictObject({ list: exports_external.array(scalarArgSchema) });
+var argValueSchema = exports_external.union([
+  exports_external.string().min(1),
+  literalSchema,
+  listSchema
+]);
+var computedSourceSchema = exports_external.union([
+  exports_external.array(exports_external.string().min(1)).min(1),
+  exports_external.strictObject({
+    path: exports_external.string().min(1),
+    field: exports_external.string().min(1).optional(),
+    get where() {
+      return conditionSchema.optional();
+    }
+  })
+]);
+var LIST_OPS = new Set(["some", "every", "none"]);
+var UNARY_OPS = new Set(["exists", "isEmpty"]);
+var conditionSchema = exports_external.strictObject({
+  get all() {
+    return exports_external.array(conditionSchema).min(1).optional();
+  },
+  get any() {
+    return exports_external.array(conditionSchema).min(1).optional();
+  },
+  get not() {
+    return conditionSchema.optional();
+  },
+  path: exports_external.string().min(1).optional(),
+  sum: computedSourceSchema.optional(),
+  avg: computedSourceSchema.optional(),
+  min: computedSourceSchema.optional(),
+  max: computedSourceSchema.optional(),
+  count: computedSourceSchema.optional(),
+  weights: exports_external.array(exports_external.number()).min(1).optional(),
+  op: exports_external.enum(CONDITION_OPERATORS).optional(),
+  value: jsonValueSchema.optional(),
+  ref: exports_external.string().min(1).optional(),
+  get where() {
+    return conditionSchema.optional();
+  }
+}).superRefine((condition, ctx) => {
+  const combinators = ["all", "any", "not"].filter((key) => condition[key] !== undefined);
+  const lefts = ["path", ...COMPUTED_FUNCTIONS].filter((key) => condition[key] !== undefined);
+  if (combinators.length > 0) {
+    const extras = Object.keys(condition).filter((key) => key !== combinators[0]);
+    if (combinators.length > 1 || extras.length > 0) {
+      ctx.addIssue({
+        code: "custom",
+        message: `A condition with "${String(combinators[0])}" can't have other keys (found ${[...combinators.slice(1), ...extras].map((key) => `"${key}"`).join(", ")})`
+      });
+    }
+    return;
+  }
+  if (lefts.length !== 1) {
+    ctx.addIssue({
+      code: "custom",
+      message: lefts.length === 0 ? 'A condition needs exactly one of "path", "sum", "avg", "min", "max", "count", or a combinator "all", "any", "not"' : `A condition can have only one of ${lefts.map((key) => `"${key}"`).join(", ")}`
+    });
+    return;
+  }
+  if (condition.op === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: 'A condition needs "op"',
+      path: ["op"]
+    });
+    return;
+  }
+  const isList = LIST_OPS.has(condition.op);
+  const isUnary = UNARY_OPS.has(condition.op);
+  if (isList && condition.where === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: `"${condition.op}" needs a "where" condition`,
+      path: ["where"]
+    });
+  }
+  if (!isList && condition.where !== undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: `"where" is only allowed with "some", "every" or "none", not "${condition.op}"`,
+      path: ["where"]
+    });
+  }
+  const hasValue = condition.value !== undefined;
+  const hasRef = condition.ref !== undefined;
+  if ((isList || isUnary) && (hasValue || hasRef)) {
+    ctx.addIssue({
+      code: "custom",
+      message: `"${condition.op}" takes no "value" or "ref"`,
+      path: [hasValue ? "value" : "ref"]
+    });
+  }
+  if (!isList && !isUnary && hasValue === hasRef) {
+    ctx.addIssue({
+      code: "custom",
+      message: `"${condition.op}" needs exactly one of "value" or "ref"`
+    });
+  }
+  if (condition.weights !== undefined && condition.avg === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: '"weights" is only allowed with "avg"',
+      path: ["weights"]
+    });
+  }
+});
+var toleratedFailuresSchema = exports_external.union([
+  exports_external.strictObject({ count: exports_external.int().nonnegative() }),
+  exports_external.strictObject({ percent: exports_external.number().min(0).max(100) })
+]);
+var eachSchema = exports_external.strictObject({
+  over: exports_external.string().min(1),
+  maxConcurrency: exports_external.int().positive().optional(),
+  toleratedFailures: toleratedFailuresSchema.optional()
+});
+var routeShape = {
+  when: conditionSchema.optional(),
+  to: nodeIdSchema,
+  pipeline: exports_external.string().min(1).optional(),
+  args: exports_external.record(exports_external.string().min(1), argValueSchema).optional(),
+  each: eachSchema.optional(),
+  partial: exports_external.literal(true).optional()
+};
+function noPartialWithEach(route, ctx) {
+  if (route.each !== undefined && route.partial !== undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: `A route can't have both "each" and "partial"`,
+      path: ["partial"]
+    });
+  }
+}
+var routeSchema = exports_external.strictObject(routeShape).superRefine(noPartialWithEach);
+var otherwiseSchema = exports_external.strictObject(routeShape).omit({ when: true }).superRefine(noPartialWithEach);
+var startSchema = exports_external.strictObject(routeShape).omit({ partial: true });
+var MATCH_MODES = ["first", "all"];
+var nextSchema = exports_external.strictObject({
+  match: exports_external.enum(MATCH_MODES).optional(),
+  routes: exports_external.array(routeSchema).min(1),
+  otherwise: otherwiseSchema.optional()
+});
+var retrySchema = exports_external.strictObject({
+  on: exports_external.array(exports_external.string().min(1)).min(1),
+  maxAttempts: exports_external.int().positive(),
+  intervalSeconds: exports_external.number().nonnegative().optional(),
+  backoffRate: exports_external.number().positive().optional(),
+  maxDelaySeconds: exports_external.number().nonnegative().optional()
+});
+var catchSchema = exports_external.strictObject({
+  on: exports_external.array(exports_external.string().min(1)).min(1),
+  to: nodeIdSchema,
+  pipeline: exports_external.string().min(1).optional(),
+  args: exports_external.record(exports_external.string().min(1), argValueSchema).optional()
+});
+var stepNodeSchema = exports_external.strictObject({
+  kind: exports_external.literal("step"),
+  title: exports_external.string().optional(),
+  step: exports_external.string().min(1),
+  next: nextSchema.optional(),
+  retry: exports_external.array(retrySchema).optional(),
+  catch: exports_external.array(catchSchema).optional(),
+  timeoutSeconds: exports_external.int().positive().optional(),
+  heartbeatSeconds: exports_external.int().positive().optional(),
+  maxRuns: exports_external.int().positive().optional(),
+  maxTurns: exports_external.int().nonnegative().optional()
+});
+var DEFAULT_MAX_TURNS = 2;
+var DECISION_BODY_MODES = ["optional", "required"];
+var decisionActionSchema = exports_external.strictObject({
+  key: exports_external.string().min(1),
+  label: exports_external.string().min(1),
+  body: exports_external.enum(DECISION_BODY_MODES).optional()
+});
+var waitNodeSchema = exports_external.strictObject({
+  kind: exports_external.literal("wait"),
+  title: exports_external.string().optional(),
+  for: exports_external.enum(["decision", "reply", "event", "timer"]),
+  actions: exports_external.array(decisionActionSchema).optional(),
+  next: nextSchema.optional(),
+  catch: exports_external.array(catchSchema).optional(),
+  timeoutSeconds: exports_external.int().positive().optional(),
+  maxRuns: exports_external.int().positive().optional()
+});
+var succeedNodeSchema = exports_external.strictObject({
+  kind: exports_external.literal("succeed"),
+  title: exports_external.string().optional()
+});
+var failNodeSchema = exports_external.strictObject({
+  kind: exports_external.literal("fail"),
+  title: exports_external.string().optional(),
+  error: exports_external.string().min(1).optional(),
+  cause: exports_external.string().optional()
+});
+var nodeSchema = exports_external.discriminatedUnion("kind", [
+  stepNodeSchema,
+  waitNodeSchema,
+  succeedNodeSchema,
+  failNodeSchema
+]);
+var pipelineDocumentSchema = exports_external.strictObject({
+  $schema: exports_external.string().optional(),
+  schemaVersion: exports_external.literal(1),
+  key: exports_external.string().min(1),
+  title: exports_external.string().optional(),
+  timeoutSeconds: exports_external.int().positive().optional(),
+  workItemFields: exports_external.record(exports_external.string().regex(ALIAS_PATTERN, "Aliases must be identifiers (letters, digits, '_')"), exports_external.string().min(1)).optional(),
+  start: startSchema,
+  nodes: exports_external.record(nodeIdSchema, nodeSchema)
+});
+function pipelineDocumentJsonSchema() {
+  return exports_external.toJSONSchema(pipelineDocumentSchema, { io: "input" });
+}
+// src/contracts/pipeline-document/routes.ts
+function routeEntries(next) {
+  if (next === undefined) {
+    return [];
+  }
+  const entries = next.routes.map((route, index) => ({
+    kind: "route",
+    index,
+    route,
+    pointer: ["routes", index]
+  }));
+  if (next.otherwise !== undefined) {
+    entries.push({
+      kind: "otherwise",
+      index: 0,
+      route: next.otherwise,
+      pointer: ["otherwise"]
+    });
+  }
+  return entries;
+}
+function routeAt(next, kind, index) {
+  if (next === undefined) {
+    return;
+  }
+  return kind === "otherwise" ? next.otherwise : next.routes[index];
+}
+export { isJsonObject, jsonPointer, deepEqual, COMPARISON_OPERATORS, CONDITION_OPERATORS, COMPUTED_FUNCTIONS, ORDERING_OPERATORS, STRING_OPERATORS, DATE_OPERATORS, LIST_OPERATORS, NODE_ID_PATTERN, ALIAS_PATTERN, literalSchema, listSchema, argValueSchema, computedSourceSchema, conditionSchema, toleratedFailuresSchema, eachSchema, routeSchema, otherwiseSchema, startSchema, MATCH_MODES, nextSchema, retrySchema, catchSchema, stepNodeSchema, DEFAULT_MAX_TURNS, DECISION_BODY_MODES, decisionActionSchema, waitNodeSchema, succeedNodeSchema, failNodeSchema, nodeSchema, pipelineDocumentSchema, pipelineDocumentJsonSchema, routeEntries, routeAt };

package/dist/{chunk-h9yxx0hd.js → chunk-rt9tq4j6.js}

@@ -1,6 +1,6 @@
 // @bun
 // src/jsonc.ts
-var stripJsoncComments2 = (content) => {
+var stripJsoncComments = (content) => {
   let result = "";
   let inString = false;
   let escapeNextCharacter = false;
@@ -58,7 +58,7 @@ var stripJsoncComments2 = (content) => {
   }
   return result;
 };
-var stripTrailingCommas2 = (content) => {
+var stripTrailingCommas = (content) => {
   let result = "";
   let inString = false;
   let escapeNextCharacter = false;
@@ -87,12 +87,12 @@ var stripTrailingCommas2 = (content) => {
     if (character === ",") {
       let lookaheadIndex = index + 1;
       while (lookaheadIndex < content.length) {
-        const lookaheadCharacter = content.charAt(lookaheadIndex);
-        if (/\s/u.test(lookaheadCharacter)) {
+        const lookaheadCharacter2 = content.charAt(lookaheadIndex);
+        if (/\s/u.test(lookaheadCharacter2)) {
           lookaheadIndex += 1;
           continue;
         }
-        if (lookaheadCharacter === "}" || lookaheadCharacter === "]") {
+        if (lookaheadCharacter2 === "}" || lookaheadCharacter2 === "]") {
           break;
         }
         result += character;
@@ -111,6 +111,6 @@ var stripTrailingCommas2 = (content) => {
   }
   return result;
 };
-var parseJsonc2 = (content) => JSON.parse(stripTrailingCommas2(stripJsoncComments2(content)));
+var parseJsonc = (content) => JSON.parse(stripTrailingCommas(stripJsoncComments(content)));
 
-export { stripJsoncComments2, stripTrailingCommas2, parseJsonc2 };
+export { stripJsoncComments, stripTrailingCommas, parseJsonc };