@xemahq/dsl 0.1.1

package/dist/schema/workflow.schema.json

@@ -0,0 +1,373 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://xema.dev/schemas/workflow/v1alpha1/Workflow.json",
+  "title": "Xema Workflow",
+  "description": "Authoring shape for a Xema workflow document (system or custom).",
+  "type": "object",
+  "required": ["apiVersion", "kind", "metadata", "on", "jobs"],
+  "additionalProperties": false,
+  "properties": {
+    "apiVersion": {
+      "type": "string",
+      "const": "xema.dev/workflow/v1alpha1"
+    },
+    "kind": {
+      "type": "string",
+      "const": "Workflow"
+    },
+    "metadata": { "$ref": "#/$defs/Metadata" },
+    "on": { "$ref": "#/$defs/Triggers" },
+    "concurrency": { "$ref": "#/$defs/Concurrency" },
+    "defaults": { "$ref": "#/$defs/Defaults" },
+    "permissions": { "$ref": "#/$defs/Permissions" },
+    "vars": {
+      "type": "object",
+      "description": "Static key/value pairs bound into every job's expression context as `vars.*`.",
+      "additionalProperties": true
+    },
+    "requires": { "$ref": "#/$defs/Requires" },
+    "jobs": {
+      "type": "object",
+      "minProperties": 1,
+      "additionalProperties": { "$ref": "#/$defs/Job" },
+      "propertyNames": { "$ref": "#/$defs/JobKey" }
+    },
+    "outputs": {
+      "type": "object",
+      "description": "Workflow-level named outputs. Each key references a (job, outputName) pair via fromJob/fromOutput and declares the kind of value surfaced.",
+      "additionalProperties": { "$ref": "#/$defs/WorkflowOutput" },
+      "propertyNames": { "type": "string", "pattern": "^[a-z][a-z0-9_-]{0,62}$" }
+    }
+  },
+  "$defs": {
+    "Metadata": {
+      "type": "object",
+      "required": ["name", "version"],
+      "additionalProperties": false,
+      "properties": {
+        "name": { "type": "string", "pattern": "^[a-z][a-z0-9-]{0,62}$" },
+        "version": { "type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+(-[A-Za-z0-9.-]+)?$" },
+        "title": { "type": "string", "maxLength": 120 },
+        "description": { "type": "string", "maxLength": 4000 },
+        "category": { "type": "string", "minLength": 1, "maxLength": 120 },
+        "tags": {
+          "type": "array",
+          "items": { "type": "string", "pattern": "^[a-z][a-z0-9-]{0,62}$" },
+          "uniqueItems": true
+        }
+      }
+    },
+    "JobKey": {
+      "type": "string",
+      "pattern": "^[a-z][a-z0-9_-]{0,62}$"
+    },
+    "Requires": {
+      "type": "object",
+      "description": "Wallet (variable + secret bundle) contracts the workflow needs at dispatch time. Resolved by the engine against project-registry-api before the run is started.",
+      "additionalProperties": false,
+      "properties": {
+        "wallets": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 32,
+          "uniqueItems": true,
+          "items": {
+            "type": "string",
+            "pattern": "^[a-z][a-z0-9-]{0,62}$",
+            "description": "Wallet name unique within the workflow's project/org scope."
+          }
+        },
+        "integrations": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 16,
+          "description": "Integration adapter kinds the workflow consumes. Biome-shipped workflows declare these so biome-host-api can cross-validate against the biome's manifest at boot.",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["adapterKind", "capabilities"],
+            "properties": {
+              "adapterKind": {
+                "type": "string",
+                "pattern": "^[a-z][a-z0-9-]*$",
+                "description": "Adapter kind slug (e.g. 'scm', 'tracker', 'documentation')."
+              },
+              "capabilities": {
+                "type": "array",
+                "minItems": 1,
+                "uniqueItems": true,
+                "items": {
+                  "type": "string",
+                  "pattern": "^[a-z]+(\\.[a-z][a-z0-9-]*)+$",
+                  "description": "Capability slug in <domain>.<verb-qualifier> form."
+                }
+              },
+              "optional": {
+                "type": "boolean",
+                "description": "Whether the workflow can degrade if the integration is unbound."
+              }
+            }
+          }
+        }
+      }
+    },
+    "Triggers": {
+      "type": "object",
+      "description": "At least one trigger must be declared.",
+      "minProperties": 1,
+      "additionalProperties": false,
+      "properties": {
+        "workflow_dispatch": { "$ref": "#/$defs/WorkflowDispatchTrigger" },
+        "schedule": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 16,
+          "items": { "$ref": "#/$defs/ScheduleTrigger" }
+        },
+        "webhook": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 32,
+          "items": { "$ref": "#/$defs/WebhookTrigger" }
+        },
+        "workflow_call": { "$ref": "#/$defs/WorkflowCallTrigger" }
+      }
+    },
+    "WorkflowDispatchTrigger": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "inputs": { "$ref": "#/$defs/InputSchemaMap" }
+      }
+    },
+    "ScheduleTrigger": {
+      "type": "object",
+      "required": ["cron"],
+      "additionalProperties": false,
+      "properties": {
+        "cron": {
+          "type": "string",
+          "description": "Standard 5-field cron expression.",
+          "pattern": "^[^\\s]+\\s+[^\\s]+\\s+[^\\s]+\\s+[^\\s]+\\s+[^\\s]+$"
+        },
+        "timezone": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9+_/-]+$" },
+        "inputs": {
+          "type": "object",
+          "description": "Pre-bound inputs for every fire.",
+          "additionalProperties": true
+        }
+      }
+    },
+    "WebhookTrigger": {
+      "type": "object",
+      "required": ["event"],
+      "additionalProperties": false,
+      "properties": {
+        "event": { "type": "string", "pattern": "^[a-z][a-z0-9._]*$" },
+        "secretRef": { "type": "string", "minLength": 1 },
+        "filters": {
+          "type": "object",
+          "additionalProperties": { "type": "string" }
+        }
+      }
+    },
+    "WorkflowCallTrigger": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "inputs": { "$ref": "#/$defs/InputSchemaMap" },
+        "outputs": {
+          "type": "object",
+          "additionalProperties": { "type": "string" }
+        }
+      }
+    },
+    "InputSchemaMap": {
+      "type": "object",
+      "additionalProperties": { "$ref": "#/$defs/InputSchemaEntry" }
+    },
+    "InputSchemaEntry": {
+      "type": "object",
+      "required": ["type"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": ["string", "number", "integer", "boolean", "object", "array"]
+        },
+        "required": { "type": "boolean", "default": false },
+        "default": {},
+        "description": { "type": "string", "maxLength": 1000 },
+        "enum": { "type": "array", "minItems": 1 },
+        "items": { "type": "object" }
+      }
+    },
+    "Concurrency": {
+      "type": "object",
+      "required": ["group", "mode"],
+      "additionalProperties": false,
+      "properties": {
+        "group": { "type": "string", "minLength": 1 },
+        "mode": {
+          "type": "string",
+          "enum": ["allow", "queue", "cancel_in_progress", "skip"]
+        }
+      }
+    },
+    "Defaults": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "retry": { "$ref": "#/$defs/RetryPolicy" },
+        "timeout": { "$ref": "#/$defs/Timeout" }
+      }
+    },
+    "Timeout": {
+      "type": "string",
+      "description": "Duration literal: <int><unit> where unit is one of s, m, h. Hours cap at 168 (1 week).",
+      "pattern": "^([1-9][0-9]*)(s|m|h)$"
+    },
+    "RetryPolicy": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "maxAttempts": { "type": "integer", "minimum": 1, "maximum": 20 },
+        "initialInterval": { "$ref": "#/$defs/Timeout" },
+        "backoffCoefficient": { "type": "number", "minimum": 1.0, "maximum": 10.0 },
+        "maximumInterval": { "$ref": "#/$defs/Timeout" },
+        "nonRetryableErrorTypes": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 1 }
+        }
+      }
+    },
+    "Permissions": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "repos": { "$ref": "#/$defs/PermissionScope" },
+        "kb": { "$ref": "#/$defs/PermissionScope" },
+        "backlog": { "$ref": "#/$defs/PermissionScope" },
+        "integrations": { "$ref": "#/$defs/PermissionScope" },
+        "artifacts": { "$ref": "#/$defs/PermissionScope" },
+        "memory": { "$ref": "#/$defs/PermissionScope" }
+      }
+    },
+    "PermissionScope": {
+      "type": "string",
+      "enum": ["none", "read", "limited", "write"]
+    },
+    "Job": {
+      "type": "object",
+      "required": ["uses"],
+      "additionalProperties": false,
+      "properties": {
+        "title": { "type": "string", "maxLength": 120 },
+        "needs": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/JobKey" },
+          "uniqueItems": true
+        },
+        "if": { "type": "string", "minLength": 1 },
+        "strategy": { "$ref": "#/$defs/Strategy" },
+        "matrixGather": {
+          "type": "array",
+          "description": "List of upstream jobKeys whose per-entry outputs should be flattened. For each key listed here, `needs.<key>.outputs` is reshaped from `{ kind: 'matrix', outputs: [...] }` to the flat array `[...]` before the job's `with:` expressions and `if:` are evaluated. Authors use this for synthesizer / coordinator jobs that need to aggregate across a matrix. Each key must be a declared job with a matrix strategy; the compiler auto-adds every key here to `needs` so authors do not have to duplicate.",
+          "items": { "$ref": "#/$defs/JobKey" },
+          "minItems": 1,
+          "uniqueItems": true
+        },
+        "uses": { "$ref": "#/$defs/UsesRef" },
+        "with": { "type": "object", "additionalProperties": true },
+        "outputs": {
+          "type": "object",
+          "additionalProperties": { "type": "string" }
+        },
+        "retry": { "$ref": "#/$defs/RetryPolicy" },
+        "timeout": { "$ref": "#/$defs/Timeout" },
+        "permissions": { "$ref": "#/$defs/Permissions" }
+      }
+    },
+    "UsesRef": {
+      "type": "string",
+      "description": "Either <namespace>/<actionId>[@<ver>] (e.g. xema/agent@1.0.0, or xema/agent for the latest-at-compile shorthand from plan §G) or xema://workflow/<slug>[@<ver>] for reusable workflow refs. When the version is omitted, the engine pins the resolved version into the CompiledRun at compile time — replays remain deterministic.",
+      "pattern": "^([a-z][a-z0-9-]*/[a-z][a-z0-9-]*(@[0-9]+(\\.[0-9]+(\\.[0-9]+(-[A-Za-z0-9.-]+)?)?)?)?|xema://workflow/[a-z][a-z0-9-]*(@[0-9]+\\.[0-9]+\\.[0-9]+(-[A-Za-z0-9.-]+)?)?)$"
+    },
+    "Strategy": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "matrix": {
+          "type": "object",
+          "minProperties": 1,
+          "additionalProperties": {
+            "type": "array",
+            "minItems": 1,
+            "maxItems": 64
+          }
+        },
+        "dynamic": {
+          "type": "object",
+          "required": ["from", "as"],
+          "additionalProperties": false,
+          "properties": {
+            "from": { "type": "string", "minLength": 1 },
+            "as": { "type": "string", "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$" },
+            "maxEntries": { "type": "integer", "minimum": 1, "maximum": 64 },
+            "keyBy": {
+              "type": "string",
+              "minLength": 1,
+              "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*(\\.[a-zA-Z_][a-zA-Z0-9_]*)*$"
+            }
+          }
+        },
+        "maxParallel": { "type": "integer", "minimum": 1, "maximum": 64 }
+      },
+      "oneOf": [
+        { "required": ["matrix"] },
+        { "required": ["dynamic"] }
+      ]
+    },
+    "WorkflowOutput": {
+      "type": "object",
+      "required": ["kind", "slug", "fromJob", "fromOutput"],
+      "oneOf": [
+        {
+          "additionalProperties": false,
+          "properties": {
+            "kind": { "const": "deliverable" },
+            "slug": { "type": "string", "pattern": "^[a-z][a-z0-9-]{0,62}$" },
+            "fromJob": { "type": "string", "pattern": "^[a-z][a-z0-9_-]{0,62}$" },
+            "fromOutput": { "type": "string", "minLength": 1 },
+            "description": { "type": "string", "maxLength": 4000 },
+            "deliverableSpecRef": { "type": "string", "minLength": 1 }
+          },
+          "required": ["kind", "slug", "fromJob", "fromOutput", "deliverableSpecRef"]
+        },
+        {
+          "additionalProperties": false,
+          "properties": {
+            "kind": { "const": "structured" },
+            "slug": { "type": "string", "pattern": "^[a-z][a-z0-9-]{0,62}$" },
+            "fromJob": { "type": "string", "pattern": "^[a-z][a-z0-9_-]{0,62}$" },
+            "fromOutput": { "type": "string", "minLength": 1 },
+            "description": { "type": "string", "maxLength": 4000 },
+            "schemaRef": { "type": "string", "minLength": 1 }
+          },
+          "required": ["kind", "slug", "fromJob", "fromOutput"]
+        },
+        {
+          "additionalProperties": false,
+          "properties": {
+            "kind": { "const": "text" },
+            "slug": { "type": "string", "pattern": "^[a-z][a-z0-9-]{0,62}$" },
+            "fromJob": { "type": "string", "pattern": "^[a-z][a-z0-9_-]{0,62}$" },
+            "fromOutput": { "type": "string", "minLength": 1 },
+            "description": { "type": "string", "maxLength": 4000 }
+          },
+          "required": ["kind", "slug", "fromJob", "fromOutput"]
+        }
+      ]
+    }
+  }
+}

package/dist/workflow/index.d.ts

@@ -0,0 +1,14 @@
+export { WorkflowDslError, isWorkflowDslError } from './lib/errors';
+export { validateActionInputs, type ActionInputValidationFailure, type ActionInputValidationResult, } from './lib/action-input-validator';
+export { InstallationResourceKind, collectInstallationResourceHints, type InstallationResourceFieldHint, } from './lib/installation-resource-kind';
+export type { InstallationCompileScope } from './lib/compiler/types';
+export { parseAndValidateActionYaml, parseAndValidateReusableWorkflowYaml, parseAndValidateWorkflowYaml, validateActionManifest, validateReusableWorkflowDocument, validateWorkflowDocument, } from './lib/validate';
+export { EMPTY_CONTEXT_SEEDS, ExpressionFunction, ExpressionNodeKind, ExpressionRoot, compileExpression, evaluateExpression, extractInterpolations, isInterpolationWrapped, stripInterpolation, type ExpressionContext, type ExpressionNode, type NeedsEntry, } from './lib/expression';
+export { parseDurationMs } from './lib/duration';
+export { DispatchInputFieldType, DispatchInputStringFormat, extractDispatchInputDescriptors, type DispatchInputDescriptor, } from './lib/dispatch-inputs';
+export { dispatchInputsToJsonSchema } from './lib/dispatch-inputs/to-json-schema';
+export { serializeWorkflowDocument } from './lib/serializer';
+export { canonicalJsonSha256, canonicalJsonStringify, compileManifestSource, compileWorkflow, getWorkspaceManifestContract, isAgentShapedAction, type CompileInput, type ResolvedAgent, type ResolvedDeliverableSpec, type ResolvedRef, } from './lib/compiler';
+export { extractZodTopLevelObjectKeys, extractJsonSchemaTopLevelKeys, } from './lib/deliverable-spec-keys';
+export type { ActionContract, ActionManifest, ActionManifestMetadata, ActionManifestRetryDefaults, ActionManifestSpec, ActionManifestTimeoutDefaults, WorkspaceManifestActionContract, ScheduleDeclaration, WebhookDeclaration, WorkflowCallDeclaration, WorkflowConcurrencyDeclaration, WorkflowDefaults, WorkflowDispatchDeclaration, WorkflowDocument, WorkflowDynamicStrategyDeclaration, WorkflowInputDeclaration, WorkflowJobDeclaration, WorkflowMetadata, WorkflowPermissions, WorkflowRetryDeclaration, WorkflowStrategyDeclaration, WorkflowTriggerDeclarations, } from './lib/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/workflow/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/workflow/index.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACpE,OAAO,EACL,oBAAoB,EACpB,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,GACjC,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,wBAAwB,EACxB,gCAAgC,EAChC,KAAK,6BAA6B,GACnC,MAAM,kCAAkC,CAAC;AAC1C,YAAY,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EACL,0BAA0B,EAC1B,oCAAoC,EACpC,4BAA4B,EAC5B,sBAAsB,EACtB,gCAAgC,EAChC,wBAAwB,GACzB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,sBAAsB,EACtB,kBAAkB,EAClB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,UAAU,GAChB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,+BAA+B,EAC/B,KAAK,uBAAuB,GAC7B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AAClF,OAAO,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,qBAAqB,EACrB,eAAe,EACf,4BAA4B,EAC5B,mBAAmB,EACnB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,KAAK,WAAW,GACjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,4BAA4B,EAC5B,6BAA6B,GAC9B,MAAM,6BAA6B,CAAC;AACrC,YAAY,EACV,cAAc,EACd,cAAc,EACd,sBAAsB,EACtB,2BAA2B,EAC3B,kBAAkB,EAClB,6BAA6B,EAC7B,+BAA+B,EAC/B,mBAAmB,EACnB,kBAAkB,EAClB,uBAAuB,EACvB,8BAA8B,EAC9B,gBAAgB,EAChB,2BAA2B,EAC3B,gBAAgB,EAChB,kCAAkC,EAClC,wBAAwB,EACxB,sBAAsB,EACtB,gBAAgB,EAChB,mBAAmB,EACnB,wBAAwB,EACxB,2BAA2B,EAC3B,2BAA2B,GAC5B,MAAM,aAAa,CAAC"}

package/dist/workflow/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractJsonSchemaTopLevelKeys = exports.extractZodTopLevelObjectKeys = exports.isAgentShapedAction = exports.getWorkspaceManifestContract = exports.compileWorkflow = exports.compileManifestSource = exports.canonicalJsonStringify = exports.canonicalJsonSha256 = exports.serializeWorkflowDocument = exports.dispatchInputsToJsonSchema = exports.extractDispatchInputDescriptors = exports.DispatchInputStringFormat = exports.DispatchInputFieldType = exports.parseDurationMs = exports.stripInterpolation = exports.isInterpolationWrapped = exports.extractInterpolations = exports.evaluateExpression = exports.compileExpression = exports.ExpressionRoot = exports.ExpressionNodeKind = exports.ExpressionFunction = exports.EMPTY_CONTEXT_SEEDS = exports.validateWorkflowDocument = exports.validateReusableWorkflowDocument = exports.validateActionManifest = exports.parseAndValidateWorkflowYaml = exports.parseAndValidateReusableWorkflowYaml = exports.parseAndValidateActionYaml = exports.collectInstallationResourceHints = exports.InstallationResourceKind = exports.validateActionInputs = exports.isWorkflowDslError = exports.WorkflowDslError = void 0;
+var errors_1 = require("./lib/errors");
+Object.defineProperty(exports, "WorkflowDslError", { enumerable: true, get: function () { return errors_1.WorkflowDslError; } });
+Object.defineProperty(exports, "isWorkflowDslError", { enumerable: true, get: function () { return errors_1.isWorkflowDslError; } });
+var action_input_validator_1 = require("./lib/action-input-validator");
+Object.defineProperty(exports, "validateActionInputs", { enumerable: true, get: function () { return action_input_validator_1.validateActionInputs; } });
+var installation_resource_kind_1 = require("./lib/installation-resource-kind");
+Object.defineProperty(exports, "InstallationResourceKind", { enumerable: true, get: function () { return installation_resource_kind_1.InstallationResourceKind; } });
+Object.defineProperty(exports, "collectInstallationResourceHints", { enumerable: true, get: function () { return installation_resource_kind_1.collectInstallationResourceHints; } });
+var validate_1 = require("./lib/validate");
+Object.defineProperty(exports, "parseAndValidateActionYaml", { enumerable: true, get: function () { return validate_1.parseAndValidateActionYaml; } });
+Object.defineProperty(exports, "parseAndValidateReusableWorkflowYaml", { enumerable: true, get: function () { return validate_1.parseAndValidateReusableWorkflowYaml; } });
+Object.defineProperty(exports, "parseAndValidateWorkflowYaml", { enumerable: true, get: function () { return validate_1.parseAndValidateWorkflowYaml; } });
+Object.defineProperty(exports, "validateActionManifest", { enumerable: true, get: function () { return validate_1.validateActionManifest; } });
+Object.defineProperty(exports, "validateReusableWorkflowDocument", { enumerable: true, get: function () { return validate_1.validateReusableWorkflowDocument; } });
+Object.defineProperty(exports, "validateWorkflowDocument", { enumerable: true, get: function () { return validate_1.validateWorkflowDocument; } });
+var expression_1 = require("./lib/expression");
+Object.defineProperty(exports, "EMPTY_CONTEXT_SEEDS", { enumerable: true, get: function () { return expression_1.EMPTY_CONTEXT_SEEDS; } });
+Object.defineProperty(exports, "ExpressionFunction", { enumerable: true, get: function () { return expression_1.ExpressionFunction; } });
+Object.defineProperty(exports, "ExpressionNodeKind", { enumerable: true, get: function () { return expression_1.ExpressionNodeKind; } });
+Object.defineProperty(exports, "ExpressionRoot", { enumerable: true, get: function () { return expression_1.ExpressionRoot; } });
+Object.defineProperty(exports, "compileExpression", { enumerable: true, get: function () { return expression_1.compileExpression; } });
+Object.defineProperty(exports, "evaluateExpression", { enumerable: true, get: function () { return expression_1.evaluateExpression; } });
+Object.defineProperty(exports, "extractInterpolations", { enumerable: true, get: function () { return expression_1.extractInterpolations; } });
+Object.defineProperty(exports, "isInterpolationWrapped", { enumerable: true, get: function () { return expression_1.isInterpolationWrapped; } });
+Object.defineProperty(exports, "stripInterpolation", { enumerable: true, get: function () { return expression_1.stripInterpolation; } });
+var duration_1 = require("./lib/duration");
+Object.defineProperty(exports, "parseDurationMs", { enumerable: true, get: function () { return duration_1.parseDurationMs; } });
+var dispatch_inputs_1 = require("./lib/dispatch-inputs");
+Object.defineProperty(exports, "DispatchInputFieldType", { enumerable: true, get: function () { return dispatch_inputs_1.DispatchInputFieldType; } });
+Object.defineProperty(exports, "DispatchInputStringFormat", { enumerable: true, get: function () { return dispatch_inputs_1.DispatchInputStringFormat; } });
+Object.defineProperty(exports, "extractDispatchInputDescriptors", { enumerable: true, get: function () { return dispatch_inputs_1.extractDispatchInputDescriptors; } });
+var to_json_schema_1 = require("./lib/dispatch-inputs/to-json-schema");
+Object.defineProperty(exports, "dispatchInputsToJsonSchema", { enumerable: true, get: function () { return to_json_schema_1.dispatchInputsToJsonSchema; } });
+var serializer_1 = require("./lib/serializer");
+Object.defineProperty(exports, "serializeWorkflowDocument", { enumerable: true, get: function () { return serializer_1.serializeWorkflowDocument; } });
+var compiler_1 = require("./lib/compiler");
+Object.defineProperty(exports, "canonicalJsonSha256", { enumerable: true, get: function () { return compiler_1.canonicalJsonSha256; } });
+Object.defineProperty(exports, "canonicalJsonStringify", { enumerable: true, get: function () { return compiler_1.canonicalJsonStringify; } });
+Object.defineProperty(exports, "compileManifestSource", { enumerable: true, get: function () { return compiler_1.compileManifestSource; } });
+Object.defineProperty(exports, "compileWorkflow", { enumerable: true, get: function () { return compiler_1.compileWorkflow; } });
+Object.defineProperty(exports, "getWorkspaceManifestContract", { enumerable: true, get: function () { return compiler_1.getWorkspaceManifestContract; } });
+Object.defineProperty(exports, "isAgentShapedAction", { enumerable: true, get: function () { return compiler_1.isAgentShapedAction; } });
+var deliverable_spec_keys_1 = require("./lib/deliverable-spec-keys");
+Object.defineProperty(exports, "extractZodTopLevelObjectKeys", { enumerable: true, get: function () { return deliverable_spec_keys_1.extractZodTopLevelObjectKeys; } });
+Object.defineProperty(exports, "extractJsonSchemaTopLevelKeys", { enumerable: true, get: function () { return deliverable_spec_keys_1.extractJsonSchemaTopLevelKeys; } });
+//# sourceMappingURL=index.js.map

package/dist/workflow/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/workflow/index.ts"],"names":[],"mappings":";;;AAeA,uCAAoE;AAA3D,0GAAA,gBAAgB,OAAA;AAAE,4GAAA,kBAAkB,OAAA;AAC7C,uEAIsC;AAHpC,8HAAA,oBAAoB,OAAA;AAItB,+EAI0C;AAHxC,sIAAA,wBAAwB,OAAA;AACxB,8IAAA,gCAAgC,OAAA;AAIlC,2CAOwB;AANtB,sHAAA,0BAA0B,OAAA;AAC1B,gIAAA,oCAAoC,OAAA;AACpC,wHAAA,4BAA4B,OAAA;AAC5B,kHAAA,sBAAsB,OAAA;AACtB,4HAAA,gCAAgC,OAAA;AAChC,oHAAA,wBAAwB,OAAA;AAE1B,+CAa0B;AAZxB,iHAAA,mBAAmB,OAAA;AACnB,gHAAA,kBAAkB,OAAA;AAClB,gHAAA,kBAAkB,OAAA;AAClB,4GAAA,cAAc,OAAA;AACd,+GAAA,iBAAiB,OAAA;AACjB,gHAAA,kBAAkB,OAAA;AAClB,mHAAA,qBAAqB,OAAA;AACrB,oHAAA,sBAAsB,OAAA;AACtB,gHAAA,kBAAkB,OAAA;AAKpB,2CAAiD;AAAxC,2GAAA,eAAe,OAAA;AACxB,yDAK+B;AAJ7B,yHAAA,sBAAsB,OAAA;AACtB,4HAAA,yBAAyB,OAAA;AACzB,kIAAA,+BAA+B,OAAA;AAGjC,uEAAkF;AAAzE,4HAAA,0BAA0B,OAAA;AACnC,+CAA6D;AAApD,uHAAA,yBAAyB,OAAA;AAClC,2CAWwB;AAVtB,+GAAA,mBAAmB,OAAA;AACnB,kHAAA,sBAAsB,OAAA;AACtB,iHAAA,qBAAqB,OAAA;AACrB,2GAAA,eAAe,OAAA;AACf,wHAAA,4BAA4B,OAAA;AAC5B,+GAAA,mBAAmB,OAAA;AAMrB,qEAGqC;AAFnC,qIAAA,4BAA4B,OAAA;AAC5B,sIAAA,6BAA6B,OAAA"}

package/dist/workflow/lib/action-input-validator.d.ts

@@ -0,0 +1,10 @@
+export interface ActionInputValidationFailure {
+    readonly path: string;
+    readonly message: string;
+}
+export interface ActionInputValidationResult {
+    readonly valid: boolean;
+    readonly failures: readonly ActionInputValidationFailure[];
+}
+export declare function validateActionInputs(schema: Readonly<Record<string, unknown>>, value: unknown): ActionInputValidationResult;
+//# sourceMappingURL=action-input-validator.d.ts.map

package/dist/workflow/lib/action-input-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-input-validator.d.ts","sourceRoot":"","sources":["../../../src/workflow/lib/action-input-validator.ts"],"names":[],"mappings":"AA+EA,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,SAAS,4BAA4B,EAAE,CAAC;CAC5D;AAaD,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,KAAK,EAAE,OAAO,GACb,2BAA2B,CAU7B"}

package/dist/workflow/lib/action-input-validator.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateActionInputs = validateActionInputs;
+const _2020_1 = __importDefault(require("ajv/dist/2020"));
+const ajv_formats_1 = __importDefault(require("ajv-formats"));
+const ajv = new _2020_1.default({
+    strict: false,
+    allErrors: true,
+    useDefaults: false,
+    validateFormats: true,
+});
+(0, ajv_formats_1.default)(ajv);
+ajv.addKeyword({
+    keyword: 'x-installation-resource',
+    metaSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['kind'],
+        properties: {
+            kind: { type: 'string', enum: ['wallet', 'repo', 'project', 'channel', 'space'] },
+        },
+    },
+});
+const validatorCache = new WeakMap();
+function validateActionInputs(schema, value) {
+    const validate = compileOrGet(schema);
+    if (validate(value)) {
+        return { valid: true, failures: [] };
+    }
+    const errors = validate.errors ?? [];
+    return {
+        valid: false,
+        failures: errors.map(formatError),
+    };
+}
+function compileOrGet(schema) {
+    const cached = validatorCache.get(schema);
+    if (cached)
+        return cached;
+    const compiled = ajv.compile(schema);
+    validatorCache.set(schema, compiled);
+    return compiled;
+}
+function formatError(err) {
+    const dotted = err.instancePath
+        .replace(/^\//, '')
+        .split('/')
+        .filter((seg) => seg.length > 0)
+        .join('.');
+    const path = dotted.length > 0 ? `inputs.${dotted}` : 'inputs';
+    if (err.keyword === 'required' && typeof err.params?.['missingProperty'] === 'string') {
+        const missing = err.params['missingProperty'];
+        const subPath = path === 'inputs' ? `inputs.${missing}` : `${path}.${missing}`;
+        return { path: subPath, message: 'is required but missing' };
+    }
+    if (err.keyword === 'additionalProperties' && typeof err.params?.['additionalProperty'] === 'string') {
+        const extra = err.params['additionalProperty'];
+        const subPath = path === 'inputs' ? `inputs.${extra}` : `${path}.${extra}`;
+        return { path: subPath, message: 'is not declared on this action — remove it from the with-block' };
+    }
+    return {
+        path,
+        message: err.message ?? `failed ${err.keyword} check`,
+    };
+}
+//# sourceMappingURL=action-input-validator.js.map

package/dist/workflow/lib/action-input-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-input-validator.js","sourceRoot":"","sources":["../../../src/workflow/lib/action-input-validator.ts"],"names":[],"mappings":"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"}

package/dist/workflow/lib/compiler/action-shape.d.ts

@@ -0,0 +1,5 @@
+import type { ActionManifest, AgentCompositionActionContract, WorkspaceManifestActionContract } from '../types';
+export declare function getWorkspaceManifestContract(actionManifest: ActionManifest | null): WorkspaceManifestActionContract | null;
+export declare function isAgentShapedAction(actionManifest: ActionManifest | null): actionManifest is ActionManifest;
+export declare function getAgentCompositionContract(actionManifest: ActionManifest | null): AgentCompositionActionContract | null;
+//# sourceMappingURL=action-shape.d.ts.map

package/dist/workflow/lib/compiler/action-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-shape.d.ts","sourceRoot":"","sources":["../../../../src/workflow/lib/compiler/action-shape.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,8BAA8B,EAC9B,+BAA+B,EAChC,MAAM,UAAU,CAAC;AAUlB,wBAAgB,4BAA4B,CAC1C,cAAc,EAAE,cAAc,GAAG,IAAI,GACpC,+BAA+B,GAAG,IAAI,CAUxC;AAWD,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,cAAc,GAAG,IAAI,GACpC,cAAc,IAAI,cAAc,CASlC;AAUD,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,cAAc,GAAG,IAAI,GACpC,8BAA8B,GAAG,IAAI,CAUvC"}

package/dist/workflow/lib/compiler/action-shape.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkspaceManifestContract = getWorkspaceManifestContract;
+exports.isAgentShapedAction = isAgentShapedAction;
+exports.getAgentCompositionContract = getAgentCompositionContract;
+function getWorkspaceManifestContract(actionManifest) {
+    if (!actionManifest)
+        return null;
+    const contracts = actionManifest.spec.consumes;
+    if (!contracts || contracts.length === 0)
+        return null;
+    for (const c of contracts) {
+        if (c.kind === 'workspace-manifest' && c.version === 'v1') {
+            return c;
+        }
+    }
+    return null;
+}
+function isAgentShapedAction(actionManifest) {
+    if (!actionManifest)
+        return false;
+    if (getWorkspaceManifestContract(actionManifest) !== null)
+        return true;
+    const inputs = actionManifest.spec.inputs;
+    const properties = inputs?.properties;
+    if (!properties)
+        return false;
+    return 'compositionRef' in properties && 'mounts' in properties;
+}
+function getAgentCompositionContract(actionManifest) {
+    if (!actionManifest)
+        return null;
+    const contracts = actionManifest.spec.consumes;
+    if (!contracts || contracts.length === 0)
+        return null;
+    for (const c of contracts) {
+        if (c.kind === 'agent-composition' && c.version === 'v1') {
+            return c;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=action-shape.js.map

package/dist/workflow/lib/compiler/action-shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-shape.js","sourceRoot":"","sources":["../../../../src/workflow/lib/compiler/action-shape.ts"],"names":[],"mappings":";;AAcA,oEAYC;AAWD,kDAWC;AAUD,kEAYC;AAxDD,SAAgB,4BAA4B,CAC1C,cAAqC;IAErC,IAAI,CAAC,cAAc;QAAE,OAAO,IAAI,CAAC;IACjC,MAAM,SAAS,GAAG,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC;IAC/C,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACtD,KAAK,MAAM,CAAC,IAAI,SAAS,EAAE,CAAC;QAC1B,IAAI,CAAC,CAAC,IAAI,KAAK,oBAAoB,IAAI,CAAC,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YAC1D,OAAO,CAAC,CAAC;QACX,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAWD,SAAgB,mBAAmB,CACjC,cAAqC;IAErC,IAAI,CAAC,cAAc;QAAE,OAAO,KAAK,CAAC;IAClC,IAAI,4BAA4B,CAAC,cAAc,CAAC,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACvE,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,MAEtB,CAAC;IACd,MAAM,UAAU,GAAG,MAAM,EAAE,UAAU,CAAC;IACtC,IAAI,CAAC,UAAU;QAAE,OAAO,KAAK,CAAC;IAC9B,OAAO,gBAAgB,IAAI,UAAU,IAAI,QAAQ,IAAI,UAAU,CAAC;AAClE,CAAC;AAUD,SAAgB,2BAA2B,CACzC,cAAqC;IAErC,IAAI,CAAC,cAAc;QAAE,OAAO,IAAI,CAAC;IACjC,MAAM,SAAS,GAAG,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC;IAC/C,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACtD,KAAK,MAAM,CAAC,IAAI,SAAS,EAAE,CAAC;QAC1B,IAAI,CAAC,CAAC,IAAI,KAAK,mBAAmB,IAAI,CAAC,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YACzD,OAAO,CAAC,CAAC;QACX,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/workflow/lib/compiler/canonical-json.d.ts

@@ -0,0 +1,3 @@
+export declare function canonicalJsonStringify(value: unknown): string;
+export declare function canonicalJsonSha256(value: unknown): string;
+//# sourceMappingURL=canonical-json.d.ts.map

package/dist/workflow/lib/compiler/canonical-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-json.d.ts","sourceRoot":"","sources":["../../../../src/workflow/lib/compiler/canonical-json.ts"],"names":[],"mappings":"AAeA,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE7D;AAGD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE1D"}