@stackwright-services/capabilities 0.0.1

package/dist/index.js

@@ -0,0 +1,1431 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CapabilityRegistry: () => CapabilityRegistry,
+  CollectionAggregateInput: () => CollectionAggregateInput,
+  CollectionAggregateOutput: () => CollectionAggregateOutput,
+  CollectionFilterInput: () => CollectionFilterInput,
+  CollectionFilterOutput: () => CollectionFilterOutput,
+  CollectionJoinInput: () => CollectionJoinInput,
+  CollectionJoinOutput: () => CollectionJoinOutput,
+  DateShiftInput: () => DateShiftInput,
+  DateShiftOutput: () => DateShiftOutput,
+  EventsFilterInput: () => EventsFilterInput,
+  EventsFilterOutput: () => EventsFilterOutput,
+  EventsPublishInput: () => EventsPublishInput,
+  EventsPublishOutput: () => EventsPublishOutput,
+  NotificationChannel: () => NotificationChannel,
+  NotifyUserInput: () => NotifyUserInput,
+  NotifyUserOutput: () => NotifyUserOutput,
+  ServiceCallInput: () => ServiceCallInput,
+  ServiceCallOutput: () => ServiceCallOutput,
+  TextFormatInput: () => TextFormatInput,
+  TextFormatOutput: () => TextFormatOutput,
+  UnitsConvertInput: () => UnitsConvertInput,
+  UnitsConvertOutput: () => UnitsConvertOutput,
+  collectionAggregateHandler: () => collectionAggregateHandler,
+  collectionFilterHandler: () => collectionFilterHandler,
+  collectionJoinHandler: () => collectionJoinHandler,
+  dateShiftHandler: () => dateShiftHandler,
+  defaultRegistry: () => defaultRegistry,
+  evaluatePredicate: () => evaluatePredicate,
+  eventsFilterHandler: () => eventsFilterHandler,
+  eventsPublishDefinition: () => eventsPublishDefinition,
+  eventsPublishHandler: () => eventsPublishHandler,
+  notifyUserDefinition: () => notifyUserDefinition,
+  notifyUserHandler: () => notifyUserHandler,
+  registerAllCapabilities: () => registerAllCapabilities,
+  registerEffects: () => registerEffects,
+  registerTransforms: () => registerTransforms,
+  serviceCallHandler: () => serviceCallHandler,
+  stripBusPrefix: () => stripBusPrefix,
+  textFormatHandler: () => textFormatHandler,
+  unitsConvertHandler: () => unitsConvertHandler
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/registry.ts
+var CapabilityRegistry = class {
+  capabilities = /* @__PURE__ */ new Map();
+  /**
+   * Register a capability. This is a security-relevant operation --
+   * every registration should be audited.
+   *
+   * @throws if a capability with the same name is already registered
+   */
+  register(definition, handler, inputSchema, outputSchema) {
+    if (this.capabilities.has(definition.name)) {
+      throw new Error(
+        `Capability "${definition.name}" is already registered. Duplicate registration is not allowed -- this is the audit chokepoint.`
+      );
+    }
+    this.capabilities.set(definition.name, {
+      definition,
+      handler,
+      inputSchema,
+      outputSchema
+    });
+  }
+  /**
+   * Look up a capability by name.
+   * @returns the registered capability, or undefined if not found
+   */
+  lookup(name) {
+    return this.capabilities.get(name);
+  }
+  /**
+   * Get a capability by name, throwing if not found.
+   * @throws if the capability is not registered
+   */
+  get(name) {
+    const capability = this.capabilities.get(name);
+    if (!capability) {
+      throw new Error(
+        `Capability "${name}" is not registered. Available capabilities: ${this.listNames().join(", ") || "(none)"}`
+      );
+    }
+    return capability;
+  }
+  /**
+   * List all registered capabilities.
+   */
+  listAll() {
+    return Array.from(this.capabilities.values());
+  }
+  /**
+   * List all registered capability names.
+   */
+  listNames() {
+    return Array.from(this.capabilities.keys());
+  }
+  /**
+   * Filter capabilities by kind (transform or effect).
+   */
+  filterByKind(kind) {
+    return this.listAll().filter((cap) => cap.definition.kind === kind);
+  }
+  /**
+   * Check if a capability is registered.
+   */
+  has(name) {
+    return this.capabilities.has(name);
+  }
+  /**
+   * Get the count of registered capabilities.
+   */
+  get size() {
+    return this.capabilities.size;
+  }
+  /**
+   * Clear all registrations. Primarily for testing.
+   */
+  clear() {
+    this.capabilities.clear();
+  }
+};
+var defaultRegistry = new CapabilityRegistry();
+
+// src/transforms/collection-aggregate.ts
+var import_zod = require("zod");
+var AggregateOperation = import_zod.z.enum(["count", "sum", "avg", "min", "max"]);
+var CollectionAggregateInput = import_zod.z.object({
+  items: import_zod.z.array(import_zod.z.unknown()),
+  field: import_zod.z.string().min(1),
+  operation: AggregateOperation
+});
+var CollectionAggregateOutput = import_zod.z.object({
+  result: import_zod.z.number()
+});
+function resolveFieldPath(item, path) {
+  const parts = path.split(".");
+  let current = item;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function extractNumericValues(items, field) {
+  return items.map((item, index) => {
+    const value = resolveFieldPath(item, field);
+    if (typeof value !== "number") {
+      throw new Error(
+        `Field "${field}" at index ${index} is not a number (got ${typeof value}). Numeric aggregation requires all values to be numbers.`
+      );
+    }
+    return value;
+  });
+}
+var collectionAggregateHandler = async (input) => {
+  const { items, field, operation } = input;
+  if (operation === "count") {
+    return { result: items.length };
+  }
+  if (items.length === 0) {
+    throw new Error(`Cannot compute ${operation} on an empty collection`);
+  }
+  const values = extractNumericValues(items, field);
+  let result;
+  switch (operation) {
+    case "sum":
+      result = values.reduce((acc, v) => acc + v, 0);
+      break;
+    case "avg":
+      result = values.reduce((acc, v) => acc + v, 0) / values.length;
+      break;
+    case "min":
+      result = Math.min(...values);
+      break;
+    case "max":
+      result = Math.max(...values);
+      break;
+  }
+  return { result };
+};
+var collectionAggregateDefinition = {
+  kind: "transform",
+  name: "collection.aggregate",
+  description: "Aggregate operations (count, sum, avg, min, max) on a field in an array",
+  inputSchema: "CollectionAggregateInput",
+  outputSchema: "CollectionAggregateOutput"
+};
+
+// src/transforms/collection-filter.ts
+var import_zod2 = require("zod");
+var CollectionFilterInput = import_zod2.z.object({
+  items: import_zod2.z.array(import_zod2.z.unknown()),
+  conditions: import_zod2.z.array(
+    import_zod2.z.object({
+      field: import_zod2.z.string().min(1),
+      op: import_zod2.z.string().min(1),
+      value: import_zod2.z.unknown().optional(),
+      value_field: import_zod2.z.string().min(1).optional()
+    })
+  )
+});
+var CollectionFilterOutput = import_zod2.z.object({
+  items: import_zod2.z.array(import_zod2.z.unknown()),
+  count: import_zod2.z.number()
+});
+function resolveFieldPath2(item, path) {
+  const parts = path.split(".");
+  let current = item;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function evaluatePredicate(item, condition) {
+  const fieldValue = resolveFieldPath2(item, condition.field);
+  const op = condition.op;
+  const target = condition.value;
+  switch (op) {
+    case "equals":
+      return fieldValue === target;
+    case "not_equals":
+      return fieldValue !== target;
+    case "in":
+      if (!Array.isArray(target)) return false;
+      return target.includes(fieldValue);
+    case "not_in":
+      if (!Array.isArray(target)) return true;
+      return !target.includes(fieldValue);
+    case "less_than":
+      return typeof fieldValue === "number" && typeof target === "number" ? fieldValue < target : false;
+    case "greater_than":
+      return typeof fieldValue === "number" && typeof target === "number" ? fieldValue > target : false;
+    case "less_than_or_equal":
+      return typeof fieldValue === "number" && typeof target === "number" ? fieldValue <= target : false;
+    case "greater_than_or_equal":
+      return typeof fieldValue === "number" && typeof target === "number" ? fieldValue >= target : false;
+    case "matches_prefix":
+      return typeof fieldValue === "string" && typeof target === "string" ? fieldValue.startsWith(target) : false;
+    case "contains":
+      return typeof fieldValue === "string" && typeof target === "string" ? fieldValue.includes(target) : false;
+    case "less_than_field": {
+      if (!condition.value_field) return false;
+      const otherValue = resolveFieldPath2(item, condition.value_field);
+      return typeof fieldValue === "number" && typeof otherValue === "number" ? fieldValue < otherValue : false;
+    }
+    case "greater_than_field": {
+      if (!condition.value_field) return false;
+      const otherValue = resolveFieldPath2(item, condition.value_field);
+      return typeof fieldValue === "number" && typeof otherValue === "number" ? fieldValue > otherValue : false;
+    }
+    case "equals_field": {
+      if (!condition.value_field) return false;
+      const otherValue = resolveFieldPath2(item, condition.value_field);
+      return fieldValue === otherValue;
+    }
+    default: {
+      const _exhaustive = op;
+      throw new Error(`Unsupported predicate operator: ${_exhaustive}`);
+    }
+  }
+}
+var collectionFilterHandler = async (input) => {
+  const { items, conditions } = input;
+  const filtered = items.filter(
+    (item) => conditions.every((condition) => evaluatePredicate(item, condition))
+  );
+  return { items: filtered, count: filtered.length };
+};
+var collectionFilterDefinition = {
+  kind: "transform",
+  name: "collection.filter",
+  description: "Filter an array of objects using typed predicate conditions",
+  inputSchema: "CollectionFilterInput",
+  outputSchema: "CollectionFilterOutput"
+};
+
+// src/transforms/collection-join.ts
+var import_zod3 = require("zod");
+var CollectionJoinInput = import_zod3.z.object({
+  /** Left-side items array */
+  leftItems: import_zod3.z.array(import_zod3.z.unknown()),
+  /** Right-side items array */
+  rightItems: import_zod3.z.array(import_zod3.z.unknown()),
+  /** Field path on left items to join on */
+  leftField: import_zod3.z.string().min(1),
+  /** Field path on right items to join on */
+  rightField: import_zod3.z.string().min(1)
+});
+var CollectionJoinOutput = import_zod3.z.object({
+  /** Merged items where left[leftField] === right[rightField] */
+  items: import_zod3.z.array(
+    import_zod3.z.object({
+      left: import_zod3.z.unknown(),
+      right: import_zod3.z.unknown()
+    })
+  ),
+  /** Count of matched items */
+  count: import_zod3.z.number()
+});
+function resolveFieldPath3(item, path) {
+  const parts = path.split(".");
+  let current = item;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+var collectionJoinHandler = async (input) => {
+  const { leftItems, rightItems, leftField, rightField } = input;
+  const rightIndex = /* @__PURE__ */ new Map();
+  for (const rightItem of rightItems) {
+    const key = resolveFieldPath3(rightItem, rightField);
+    if (key !== void 0) {
+      const existing = rightIndex.get(key) ?? [];
+      existing.push(rightItem);
+      rightIndex.set(key, existing);
+    }
+  }
+  const items = [];
+  for (const leftItem of leftItems) {
+    const key = resolveFieldPath3(leftItem, leftField);
+    if (key !== void 0) {
+      const matches = rightIndex.get(key);
+      if (matches) {
+        for (const rightItem of matches) {
+          items.push({ left: leftItem, right: rightItem });
+        }
+      }
+    }
+  }
+  return { items, count: items.length };
+};
+var collectionJoinDefinition = {
+  kind: "transform",
+  name: "collection.join",
+  description: "Join two arrays on matching field values for cross-domain data correlation",
+  inputSchema: "CollectionJoinInput",
+  outputSchema: "CollectionJoinOutput"
+};
+
+// src/transforms/collection-paginate.ts
+var import_zod4 = require("zod");
+var CollectionPaginateInput = import_zod4.z.object({
+  items: import_zod4.z.array(import_zod4.z.unknown()),
+  page: import_zod4.z.number().int().min(1),
+  pageSize: import_zod4.z.number().int().min(1).max(1e3)
+});
+var CollectionPaginateOutput = import_zod4.z.object({
+  items: import_zod4.z.array(import_zod4.z.unknown()),
+  total: import_zod4.z.number(),
+  page: import_zod4.z.number(),
+  pageSize: import_zod4.z.number(),
+  hasNext: import_zod4.z.boolean(),
+  hasPrevious: import_zod4.z.boolean()
+});
+var collectionPaginateHandler = async (input) => {
+  const { items, page, pageSize } = input;
+  const total = items.length;
+  const startIndex = (page - 1) * pageSize;
+  const pageItems = items.slice(startIndex, startIndex + pageSize);
+  return {
+    items: pageItems,
+    total,
+    page,
+    pageSize,
+    hasNext: startIndex + pageSize < total,
+    hasPrevious: page > 1
+  };
+};
+var collectionPaginateDefinition = {
+  kind: "transform",
+  name: "collection.paginate",
+  description: "Extract a page from an array with pagination metadata",
+  inputSchema: "CollectionPaginateInput",
+  outputSchema: "CollectionPaginateOutput"
+};
+
+// src/transforms/math-compute.ts
+var import_zod5 = require("zod");
+var MathOperation = import_zod5.z.object({
+  op: import_zod5.z.enum(["add", "subtract", "multiply", "divide", "modulo", "round", "ceil", "floor"]),
+  fields: import_zod5.z.array(import_zod5.z.string().min(1)).min(1),
+  // field paths to read operands from
+  result_field: import_zod5.z.string().min(1)
+  // dot-path where the result is written
+});
+var MathComputeInput = import_zod5.z.object({
+  data: import_zod5.z.record(import_zod5.z.unknown()),
+  operations: import_zod5.z.array(MathOperation).min(1)
+});
+var MathComputeOutput = import_zod5.z.object({
+  data: import_zod5.z.record(import_zod5.z.unknown()),
+  computed_fields: import_zod5.z.array(import_zod5.z.string())
+});
+function resolveFieldPath4(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function setFieldPath(obj, path, value) {
+  const parts = path.split(".");
+  const lastKey = parts.pop();
+  if (lastKey === void 0) return;
+  let current = obj;
+  for (const key of parts) {
+    if (current[key] === null || current[key] === void 0 || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[lastKey] = value;
+}
+function resolveNumber(data, field) {
+  const value = resolveFieldPath4(data, field);
+  return typeof value === "number" ? value : null;
+}
+var mathComputeHandler = async (input) => {
+  const { data, operations } = input;
+  const result = structuredClone(data);
+  const computedFields = [];
+  for (const { op, fields, result_field } of operations) {
+    const [firstField, secondField] = fields;
+    const a = firstField !== void 0 ? resolveNumber(result, firstField) : null;
+    let computed = null;
+    if (op === "round") {
+      computed = a !== null ? Math.round(a) : null;
+    } else if (op === "ceil") {
+      computed = a !== null ? Math.ceil(a) : null;
+    } else if (op === "floor") {
+      computed = a !== null ? Math.floor(a) : null;
+    } else {
+      const b = secondField !== void 0 ? resolveNumber(result, secondField) : null;
+      if (a !== null && b !== null) {
+        if (op === "add") computed = a + b;
+        else if (op === "subtract") computed = a - b;
+        else if (op === "multiply") computed = a * b;
+        else if (op === "divide") computed = b !== 0 ? a / b : null;
+        else if (op === "modulo") computed = b !== 0 ? a % b : null;
+      }
+    }
+    setFieldPath(result, result_field, computed);
+    computedFields.push(result_field);
+  }
+  return { data: result, computed_fields: computedFields };
+};
+var mathComputeDefinition = {
+  kind: "transform",
+  name: "math.compute",
+  description: "Safe arithmetic operations on typed numeric fields. Operations: add, subtract, multiply, divide, modulo, round, ceil, floor.",
+  inputSchema: "MathComputeInput",
+  outputSchema: "MathComputeOutput"
+};
+
+// src/transforms/collection-sort.ts
+var import_zod6 = require("zod");
+var SortKey = import_zod6.z.object({
+  field: import_zod6.z.string().min(1),
+  // Explicit direction required — no silent defaults. Explicit is better than implicit.
+  direction: import_zod6.z.enum(["asc", "desc"])
+});
+var CollectionSortInput = import_zod6.z.object({
+  items: import_zod6.z.array(import_zod6.z.unknown()),
+  sortBy: import_zod6.z.array(SortKey).min(1)
+});
+var CollectionSortOutput = import_zod6.z.object({
+  items: import_zod6.z.array(import_zod6.z.unknown()),
+  count: import_zod6.z.number()
+});
+function resolveFieldPath5(item, path) {
+  const parts = path.split(".");
+  let current = item;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function compareNonNilValues(a, b) {
+  if (typeof a === "number" && typeof b === "number") {
+    return a - b;
+  }
+  if (typeof a === "string" && typeof b === "string") {
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  if (typeof a === "number") return -1;
+  if (typeof b === "number") return 1;
+  const sa = String(a);
+  const sb = String(b);
+  return sa < sb ? -1 : sa > sb ? 1 : 0;
+}
+var collectionSortHandler = async (input) => {
+  const { items, sortBy } = input;
+  const sorted = [...items].sort((a, b) => {
+    for (const { field, direction } of sortBy) {
+      const aVal = resolveFieldPath5(a, field);
+      const bVal = resolveFieldPath5(b, field);
+      const aIsNil = aVal === null || aVal === void 0;
+      const bIsNil = bVal === null || bVal === void 0;
+      if (aIsNil && bIsNil) continue;
+      if (aIsNil) return 1;
+      if (bIsNil) return -1;
+      const cmp = compareNonNilValues(aVal, bVal);
+      if (cmp !== 0) {
+        return direction === "desc" ? -cmp : cmp;
+      }
+    }
+    return 0;
+  });
+  return { items: sorted, count: sorted.length };
+};
+var collectionSortDefinition = {
+  kind: "transform",
+  name: "collection.sort",
+  description: "Sort arrays by one or more fields with typed direction (asc/desc)",
+  inputSchema: "CollectionSortInput",
+  outputSchema: "CollectionSortOutput"
+};
+
+// src/transforms/date-shift.ts
+var import_zod7 = require("zod");
+var DateShiftInput = import_zod7.z.object({
+  date: import_zod7.z.string().min(1),
+  duration: import_zod7.z.string().regex(
+    /^P(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+S)?)?$/,
+    'Duration must be ISO 8601 format (e.g. "P3D", "PT1H30M")'
+  ),
+  direction: import_zod7.z.enum(["add", "subtract"])
+});
+var DateShiftOutput = import_zod7.z.object({
+  result: import_zod7.z.string()
+});
+function parseDuration(duration) {
+  const result = { days: 0, hours: 0, minutes: 0, seconds: 0 };
+  const dayMatch = duration.match(/(\d+)D/);
+  if (dayMatch?.[1]) result.days = parseInt(dayMatch[1], 10);
+  const timeSection = duration.match(/T(.+)$/);
+  if (timeSection?.[1]) {
+    const timePart = timeSection[1];
+    const hourMatch = timePart.match(/(\d+)H/);
+    const minMatch = timePart.match(/(\d+)M/);
+    const secMatch = timePart.match(/(\d+)S/);
+    if (hourMatch?.[1]) result.hours = parseInt(hourMatch[1], 10);
+    if (minMatch?.[1]) result.minutes = parseInt(minMatch[1], 10);
+    if (secMatch?.[1]) result.seconds = parseInt(secMatch[1], 10);
+  }
+  return result;
+}
+var dateShiftHandler = async (input) => {
+  const { date, duration, direction } = input;
+  const parsed = parseDuration(duration);
+  const totalMs = (parsed.days * 86400 + parsed.hours * 3600 + parsed.minutes * 60 + parsed.seconds) * 1e3;
+  const dateObj = new Date(date);
+  if (isNaN(dateObj.getTime())) {
+    throw new Error(`Invalid date: "${date}" is not a valid ISO 8601 date`);
+  }
+  const shift = direction === "add" ? totalMs : -totalMs;
+  const resultDate = new Date(dateObj.getTime() + shift);
+  return { result: resultDate.toISOString() };
+};
+var dateShiftDefinition = {
+  kind: "transform",
+  name: "date.shift",
+  description: "Add or subtract an ISO 8601 duration from a date",
+  inputSchema: "DateShiftInput",
+  outputSchema: "DateShiftOutput"
+};
+
+// src/transforms/events-filter.ts
+var import_zod8 = require("zod");
+var EventsFilterInput = import_zod8.z.object({
+  /** The event payload to evaluate */
+  event: import_zod8.z.unknown(),
+  /** Typed predicate conditions -- all must pass for the event to pass through */
+  conditions: import_zod8.z.array(
+    import_zod8.z.object({
+      field: import_zod8.z.string().min(1),
+      op: import_zod8.z.string().min(1),
+      value: import_zod8.z.unknown()
+    })
+  ).min(1)
+});
+var EventsFilterOutput = import_zod8.z.object({
+  /** The event if it passed all conditions, or null if filtered out */
+  event: import_zod8.z.unknown().nullable(),
+  /** Whether the event passed all conditions */
+  passed: import_zod8.z.boolean()
+});
+var eventsFilterHandler = async (input) => {
+  const { event, conditions } = input;
+  const passed = conditions.every(
+    (condition) => evaluatePredicate(event, condition)
+  );
+  return {
+    event: passed ? event : null,
+    passed
+  };
+};
+var eventsFilterDefinition = {
+  kind: "transform",
+  name: "events.filter",
+  description: "Filter a single event payload against typed predicate conditions. Returns the event if all conditions pass, null if filtered out.",
+  inputSchema: "EventsFilterInput",
+  outputSchema: "EventsFilterOutput"
+};
+
+// src/transforms/text-format.ts
+var import_zod9 = require("zod");
+var TextFormatInput = import_zod9.z.object({
+  template: import_zod9.z.string(),
+  params: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number(), import_zod9.z.boolean()]))
+});
+var TextFormatOutput = import_zod9.z.object({
+  result: import_zod9.z.string()
+});
+var textFormatHandler = async (input) => {
+  const { template, params } = input;
+  const result = template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    const value = params[key];
+    if (value === void 0) {
+      throw new Error(
+        `Missing template parameter: "${key}" (referenced in template but not provided)`
+      );
+    }
+    return String(value);
+  });
+  return { result };
+};
+var textFormatDefinition = {
+  kind: "transform",
+  name: "text.format",
+  description: "Template interpolation: replaces {{key}} placeholders with typed parameter values",
+  inputSchema: "TextFormatInput",
+  outputSchema: "TextFormatOutput"
+};
+
+// src/transforms/units-convert.ts
+var import_zod10 = require("zod");
+var UnitCategory = import_zod10.z.enum(["length", "weight", "temperature", "volume"]);
+var UnitsConvertInput = import_zod10.z.object({
+  value: import_zod10.z.number(),
+  from: import_zod10.z.string().min(1),
+  to: import_zod10.z.string().min(1),
+  category: UnitCategory
+});
+var UnitsConvertOutput = import_zod10.z.object({
+  result: import_zod10.z.number(),
+  from: import_zod10.z.string(),
+  to: import_zod10.z.string()
+});
+var CONVERSION_FACTORS = {
+  length: {
+    m: 1,
+    km: 1e3,
+    cm: 0.01,
+    mm: 1e-3,
+    mi: 1609.344,
+    yd: 0.9144,
+    ft: 0.3048,
+    in: 0.0254,
+    nm: 1852
+  },
+  weight: {
+    kg: 1,
+    g: 1e-3,
+    mg: 1e-6,
+    lb: 0.453592,
+    oz: 0.0283495,
+    ton: 1e3
+  },
+  volume: {
+    l: 1,
+    ml: 1e-3,
+    gal: 3.78541,
+    qt: 0.946353,
+    pt: 0.473176,
+    cup: 0.236588,
+    floz: 0.0295735
+  }
+};
+function convertTemperature(value, from, to) {
+  let celsius;
+  switch (from) {
+    case "C":
+      celsius = value;
+      break;
+    case "F":
+      celsius = (value - 32) * 5 / 9;
+      break;
+    case "K":
+      celsius = value - 273.15;
+      break;
+    default:
+      throw new Error(`Unknown temperature unit: ${from}`);
+  }
+  switch (to) {
+    case "C":
+      return celsius;
+    case "F":
+      return celsius * 9 / 5 + 32;
+    case "K":
+      return celsius + 273.15;
+    default:
+      throw new Error(`Unknown temperature unit: ${to}`);
+  }
+}
+var unitsConvertHandler = async (input) => {
+  const { value, from, to, category } = input;
+  let result;
+  if (category === "temperature") {
+    result = convertTemperature(value, from, to);
+  } else {
+    const factors = CONVERSION_FACTORS[category];
+    if (!factors) throw new Error(`Unknown unit category: ${category}`);
+    const fromFactor = factors[from];
+    const toFactor = factors[to];
+    if (fromFactor === void 0) throw new Error(`Unknown ${category} unit: ${from}`);
+    if (toFactor === void 0) throw new Error(`Unknown ${category} unit: ${to}`);
+    result = value * fromFactor / toFactor;
+  }
+  return { result, from, to };
+};
+var unitsConvertDefinition = {
+  kind: "transform",
+  name: "units.convert",
+  description: "Convert between measurement units (length, weight, temperature, volume)",
+  inputSchema: "UnitsConvertInput",
+  outputSchema: "UnitsConvertOutput"
+};
+
+// src/transforms/validation-check.ts
+var import_types = require("@stackwright-services/types");
+var import_zod11 = require("zod");
+var ValidationRule = import_zod11.z.object({
+  /** The field path to validate (dot notation supported: "address.zip") */
+  field: import_zod11.z.string().min(1),
+  /** Predicate operator to apply */
+  op: import_zod11.z.string(),
+  /** Expected value for the predicate (literal value or field name for *_field ops) */
+  value: import_zod11.z.unknown(),
+  /** Optional human-readable error message (defaults to auto-generated) */
+  message: import_zod11.z.string().optional()
+});
+var ValidationCheckInput = import_zod11.z.object({
+  /** Data object to validate */
+  data: import_zod11.z.record(import_zod11.z.unknown()),
+  /** Validation rules to apply */
+  rules: import_zod11.z.array(ValidationRule).min(1)
+});
+var ValidationError = import_zod11.z.object({
+  /** Field that failed validation */
+  field: import_zod11.z.string(),
+  /** Operator that was applied */
+  rule: import_zod11.z.string(),
+  /** Human-readable error message */
+  message: import_zod11.z.string(),
+  /** The actual value found at the field */
+  actual: import_zod11.z.unknown().optional()
+});
+var ValidationCheckOutput = import_zod11.z.object({
+  /** Whether all rules passed */
+  valid: import_zod11.z.boolean(),
+  /** Number of rules that passed */
+  passed_count: import_zod11.z.number().int().min(0),
+  /** Number of rules that failed */
+  failed_count: import_zod11.z.number().int().min(0),
+  /** Detailed errors for each failed rule */
+  errors: import_zod11.z.array(ValidationError)
+});
+var validationCheckDefinition = {
+  kind: "transform",
+  name: "validation.check",
+  description: "Run typed predicates against data fields and return structured validation results. Pure transform that composes with all 13 predicate operators. Powers form validation.",
+  inputSchema: "ValidationCheckInput",
+  outputSchema: "ValidationCheckOutput"
+};
+function getNestedField(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function defaultMessage(field, op, value) {
+  const valueStr = typeof value === "string" ? `"${value}"` : Array.isArray(value) ? `[${value.map((v) => JSON.stringify(v)).join(", ")}]` : JSON.stringify(value);
+  return `Field "${field}" failed ${op} check (expected: ${valueStr})`;
+}
+function toPredicateCondition(rule) {
+  const isFieldOp = import_types.FIELD_COMPARISON_OPERATORS.includes(rule.op);
+  if (isFieldOp) {
+    return {
+      field: rule.field,
+      op: rule.op,
+      value_field: String(rule.value)
+    };
+  }
+  return {
+    field: rule.field,
+    op: rule.op,
+    value: rule.value
+  };
+}
+var validationCheckHandler = async (input) => {
+  const { data, rules } = ValidationCheckInput.parse(input);
+  const errors = [];
+  for (const rule of rules) {
+    const fieldValue = getNestedField(data, rule.field);
+    const condition = toPredicateCondition(rule);
+    const passed = evaluatePredicate(data, condition);
+    if (!passed) {
+      errors.push({
+        field: rule.field,
+        rule: rule.op,
+        message: rule.message ?? defaultMessage(rule.field, rule.op, rule.value),
+        actual: fieldValue
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    passed_count: rules.length - errors.length,
+    failed_count: errors.length,
+    errors
+  };
+};
+
+// src/transforms/index.ts
+function registerTransforms(registry) {
+  registry.register(
+    unitsConvertDefinition,
+    unitsConvertHandler,
+    UnitsConvertInput,
+    UnitsConvertOutput
+  );
+  registry.register(textFormatDefinition, textFormatHandler, TextFormatInput, TextFormatOutput);
+  registry.register(
+    collectionFilterDefinition,
+    collectionFilterHandler,
+    CollectionFilterInput,
+    CollectionFilterOutput
+  );
+  registry.register(
+    collectionAggregateDefinition,
+    collectionAggregateHandler,
+    CollectionAggregateInput,
+    CollectionAggregateOutput
+  );
+  registry.register(
+    collectionJoinDefinition,
+    collectionJoinHandler,
+    CollectionJoinInput,
+    CollectionJoinOutput
+  );
+  registry.register(
+    collectionPaginateDefinition,
+    collectionPaginateHandler,
+    CollectionPaginateInput,
+    CollectionPaginateOutput
+  );
+  registry.register(mathComputeDefinition, mathComputeHandler, MathComputeInput, MathComputeOutput);
+  registry.register(
+    collectionSortDefinition,
+    collectionSortHandler,
+    CollectionSortInput,
+    CollectionSortOutput
+  );
+  registry.register(dateShiftDefinition, dateShiftHandler, DateShiftInput, DateShiftOutput);
+  registry.register(
+    eventsFilterDefinition,
+    eventsFilterHandler,
+    EventsFilterInput,
+    EventsFilterOutput
+  );
+  registry.register(
+    validationCheckDefinition,
+    validationCheckHandler,
+    ValidationCheckInput,
+    ValidationCheckOutput
+  );
+}
+
+// src/effects/service-call.ts
+var import_zod12 = require("zod");
+var ServiceCallInput = import_zod12.z.object({
+  /** The URL to call (raw HTTP fallback — always required so the effect works without a provider) */
+  url: import_zod12.z.string().url(),
+  /** HTTP method */
+  method: import_zod12.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
+  /**
+   * Data source ID for provider delegation (e.g. "equipment-api").
+   * When provided alongside `operation`, and a DataSourceProvider in context can resolve
+   * this source, the call is delegated to the provider instead of raw HTTP.
+   * Falls back to `url`+`method` when no provider is installed or source is not known.
+   */
+  source: import_zod12.z.string().optional(),
+  /**
+   * Operation name for provider delegation (e.g. "listUnits").
+   * Must be provided together with `source` to trigger provider delegation.
+   */
+  operation: import_zod12.z.string().optional(),
+  /** Request headers */
+  headers: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.string()).optional(),
+  /** Request body (for POST/PUT/PATCH, or provider operation params when delegating) */
+  body: import_zod12.z.unknown().optional(),
+  /** Expected response type (defaults to 'json') */
+  responseType: import_zod12.z.enum(["json", "text"]).optional(),
+  /** Timeout in milliseconds (defaults to 30000) */
+  timeout: import_zod12.z.number().positive().optional()
+});
+var ServiceCallOutput = import_zod12.z.object({
+  /** HTTP status code */
+  status: import_zod12.z.number(),
+  /** Response headers */
+  headers: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.string()),
+  /** Response body */
+  body: import_zod12.z.unknown(),
+  /** Whether the call was successful (2xx status) */
+  ok: import_zod12.z.boolean()
+});
+var serviceCallHandler = async (input, context) => {
+  const { url, method, headers, body, source, operation } = input;
+  const responseType = input.responseType ?? "json";
+  const timeout = input.timeout ?? 3e4;
+  if (source !== void 0 && operation !== void 0) {
+    const provider = context.dataSourceProvider;
+    if (provider !== void 0) {
+      const knownSources = provider.listSources();
+      const canResolve = knownSources.some((s) => s.id === source);
+      if (canResolve) {
+        context.logger.info(
+          `service.call: delegating ${source}/${operation} to DataSourceProvider`,
+          { source, operation }
+        );
+        const result = await provider.execute(source, operation, body);
+        return {
+          status: 200,
+          headers: {},
+          body: result.data,
+          ok: true
+        };
+      }
+      context.logger.info(
+        `service.call: source "${source}" not known to provider, falling back to HTTP`,
+        { source, operation, url }
+      );
+    } else {
+      context.logger.info(`service.call: no DataSourceProvider in context, falling back to HTTP`, {
+        source,
+        operation,
+        url
+      });
+    }
+  }
+  context.logger.info(`service.call: ${method} ${url}`, { method, url });
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const requestHeaders = new Headers(headers);
+    const fetchOptions = {
+      method,
+      headers: requestHeaders,
+      signal: controller.signal
+    };
+    if (body !== void 0 && ["POST", "PUT", "PATCH"].includes(method)) {
+      fetchOptions.body = JSON.stringify(body);
+      if (!requestHeaders.has("Content-Type")) {
+        requestHeaders.set("Content-Type", "application/json");
+      }
+    }
+    const response = await fetch(url, fetchOptions);
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    let responseBody;
+    if (responseType === "json") {
+      try {
+        responseBody = await response.json();
+      } catch {
+        responseBody = await response.text();
+      }
+    } else {
+      responseBody = await response.text();
+    }
+    context.logger.info(`service.call: ${method} ${url} -> ${response.status}`, {
+      status: response.status,
+      ok: response.ok
+    });
+    return {
+      status: response.status,
+      headers: responseHeaders,
+      body: responseBody,
+      ok: response.ok
+    };
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "AbortError") {
+      context.logger.error(`service.call: ${method} ${url} timed out after ${timeout}ms`);
+      return {
+        status: 408,
+        headers: {},
+        body: { error: `Request timed out after ${timeout}ms` },
+        ok: false
+      };
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+};
+var serviceCallDefinition = {
+  kind: "effect",
+  name: "service.call",
+  description: "Invoke an HTTP endpoint, or delegate to a DataSourceProvider when one is installed. Raw HTTP is the fallback escape hatch when no typed provider can resolve the target.",
+  inputSchema: "ServiceCallInput",
+  outputSchema: "ServiceCallOutput",
+  requiredPermissions: [
+    {
+      resource: "endpoint:*",
+      action: "invoke"
+    }
+  ]
+};
+
+// src/effects/events-publish.ts
+var import_zod13 = require("zod");
+var EventsPublishInput = import_zod13.z.object({
+  /** Topic to publish to (e.g. "bus:equipment-status" or "equipment-status") */
+  topic: import_zod13.z.string().min(1),
+  /** Message payload to publish */
+  payload: import_zod13.z.unknown(),
+  /** Optional metadata to include with the message */
+  metadata: import_zod13.z.object({
+    /** Logical source identifier */
+    source: import_zod13.z.string().optional(),
+    /** Correlation ID for request-scoped grouping */
+    correlationId: import_zod13.z.string().optional()
+  }).optional()
+});
+var EventsPublishOutput = import_zod13.z.object({
+  /** Provider-assigned message ID */
+  messageId: import_zod13.z.string(),
+  /** Topic the message was published to (without bus: prefix) */
+  topic: import_zod13.z.string(),
+  /** Whether publishing succeeded */
+  success: import_zod13.z.boolean()
+});
+function stripBusPrefix(topic) {
+  return topic.startsWith("bus:") ? topic.slice(4) : topic;
+}
+var eventsPublishHandler = async (input, context) => {
+  const { payload, metadata } = input;
+  const topic = stripBusPrefix(input.topic);
+  if (!context.messageBus) {
+    throw new Error(
+      "events.publish: No MessageBusProvider available in context. Ensure the runtime injects a MessageBusProvider into CapabilityContext.messageBus. Set MESSAGE_BUS_PROVIDER environment variable or pass a provider at startup."
+    );
+  }
+  context.logger.info(`events.publish: publishing to "${topic}"`, { topic });
+  const result = await context.messageBus.publish(topic, {
+    payload,
+    traceContext: { traceId: context.traceId },
+    metadata: {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...metadata?.source !== void 0 ? { source: metadata.source } : {},
+      ...metadata?.correlationId !== void 0 ? { correlationId: metadata.correlationId } : {}
+    }
+  });
+  context.logger.info(`events.publish: published to "${topic}" -> ${result.messageId}`, {
+    topic,
+    messageId: result.messageId,
+    success: result.success
+  });
+  return {
+    messageId: result.messageId,
+    topic: result.topic,
+    success: result.success
+  };
+};
+var eventsPublishDefinition = {
+  kind: "effect",
+  name: "events.publish",
+  description: "Publish a message to a message bus topic. Declares bus publish permissions for least-privilege derivation.",
+  inputSchema: "EventsPublishInput",
+  outputSchema: "EventsPublishOutput",
+  requiredPermissions: [
+    {
+      resource: "bus:*",
+      action: "publish"
+    }
+  ]
+};
+
+// src/effects/notify-user.ts
+var import_zod14 = require("zod");
+var NotificationChannel = import_zod14.z.enum(["email", "sms", "push", "in-app"]);
+var NotifyUserInput = import_zod14.z.object({
+  /** Recipient user identifier — the provider resolves this to a delivery address */
+  recipient: import_zod14.z.string().min(1),
+  /** Delivery channel */
+  channel: NotificationChannel,
+  /** Template name for the notification content */
+  template: import_zod14.z.string().min(1),
+  /** Typed payload for template interpolation */
+  payload: import_zod14.z.unknown(),
+  /** Optional subject line (for email, push) */
+  subject: import_zod14.z.string().optional(),
+  /** Optional metadata to include with the notification */
+  metadata: import_zod14.z.object({
+    /** Logical source identifier */
+    source: import_zod14.z.string().optional(),
+    /** Correlation ID for request-scoped grouping */
+    correlationId: import_zod14.z.string().optional()
+  }).optional()
+});
+var NotifyUserOutput = import_zod14.z.object({
+  /** Provider-assigned notification ID */
+  notificationId: import_zod14.z.string(),
+  /** Channel the notification was sent through */
+  channel: import_zod14.z.string(),
+  /** Whether sending succeeded */
+  success: import_zod14.z.boolean()
+});
+var notifyUserHandler = async (input, context) => {
+  const { recipient, channel, template, payload, subject, metadata } = input;
+  if (!context.notificationProvider) {
+    throw new Error(
+      "notify.user: No NotificationProvider available in context. Ensure the runtime injects a NotificationProvider into CapabilityContext.notificationProvider. Set NOTIFICATION_PROVIDER environment variable or pass a provider at startup."
+    );
+  }
+  context.logger.info(`notify.user: sending "${template}" via ${channel} to "${recipient}"`, {
+    recipient,
+    channel,
+    template
+  });
+  const result = await context.notificationProvider.send({
+    recipient,
+    channel,
+    template,
+    payload,
+    ...subject !== void 0 ? { subject } : {},
+    traceContext: { traceId: context.traceId },
+    metadata: {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...metadata?.source !== void 0 ? { source: metadata.source } : {},
+      ...metadata?.correlationId !== void 0 ? { correlationId: metadata.correlationId } : {}
+    }
+  });
+  context.logger.info(
+    `notify.user: sent "${template}" via ${channel} to "${recipient}" -> ${result.notificationId}`,
+    {
+      notificationId: result.notificationId,
+      channel: result.channel,
+      success: result.success
+    }
+  );
+  return {
+    notificationId: result.notificationId,
+    channel: result.channel,
+    success: result.success
+  };
+};
+var notifyUserDefinition = {
+  kind: "effect",
+  name: "notify.user",
+  description: "Send a notification to a user via email, SMS, push, or in-app channel. Template-based with typed payload. Declares notification permissions for least-privilege derivation.",
+  inputSchema: "NotifyUserInput",
+  outputSchema: "NotifyUserOutput",
+  requiredPermissions: [
+    {
+      resource: "notification:*",
+      action: "send"
+    }
+  ]
+};
+
+// src/effects/http-webhook.ts
+var import_zod15 = require("zod");
+var HttpWebhookInput = import_zod15.z.object({
+  /** Target URL -- must be declared statically in flow YAML */
+  url: import_zod15.z.string().url(),
+  /** HTTP method -- only POST or PUT for webhooks (defaults to POST) */
+  method: import_zod15.z.enum(["POST", "PUT"]).optional(),
+  /** Payload to send -- shape is flow-defined */
+  payload: import_zod15.z.unknown(),
+  /** Additional headers to include */
+  headers: import_zod15.z.record(import_zod15.z.string()).optional(),
+  /** Request timeout in milliseconds (100ms - 30s, defaults to 5000) */
+  timeout_ms: import_zod15.z.number().int().min(100).max(3e4).optional(),
+  /** Number of retry attempts on failure (0-3, defaults to 1) */
+  retry_count: import_zod15.z.number().int().min(0).max(3).optional(),
+  /** Optional HMAC-SHA256 secret for request signing */
+  signature_secret: import_zod15.z.string().optional()
+});
+var HttpWebhookOutput = import_zod15.z.object({
+  /** Whether the webhook was delivered successfully */
+  success: import_zod15.z.boolean(),
+  /** HTTP status code from the target */
+  status_code: import_zod15.z.number().int(),
+  /** Response body (truncated to 4KB for safety) */
+  response_body: import_zod15.z.string().optional(),
+  /** Number of attempts made (1 = first try succeeded) */
+  attempts: import_zod15.z.number().int().min(1),
+  /** Total elapsed time in milliseconds */
+  elapsed_ms: import_zod15.z.number()
+});
+var httpWebhookDefinition = {
+  kind: "effect",
+  name: "http.webhook",
+  description: "Invoke an outbound webhook with retry, timeout, and optional HMAC signature verification. More constrained than service.call -- URL is static and declared at compile time.",
+  inputSchema: "HttpWebhookInput",
+  outputSchema: "HttpWebhookOutput",
+  requiredPermissions: [{ resource: "webhook:$url", action: "invoke" }]
+};
+async function computeHmacSignature(payload, secret) {
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
+  return Array.from(new Uint8Array(signature)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var httpWebhookHandler = async (input, context) => {
+  const parsed = HttpWebhookInput.parse(input);
+  const url = parsed.url;
+  const method = parsed.method ?? "POST";
+  const payload = parsed.payload;
+  const headers = parsed.headers;
+  const timeout_ms = parsed.timeout_ms ?? 5e3;
+  const retry_count = parsed.retry_count ?? 1;
+  const signature_secret = parsed.signature_secret;
+  const body = typeof payload === "string" ? payload : JSON.stringify(payload);
+  const requestHeaders = {
+    "Content-Type": "application/json",
+    "User-Agent": "stackwright-services/webhook",
+    ...headers
+  };
+  if (signature_secret) {
+    const signature = await computeHmacSignature(body, signature_secret);
+    requestHeaders["X-Webhook-Signature"] = `sha256=${signature}`;
+  }
+  if (context.traceId) {
+    requestHeaders["X-Trace-Id"] = context.traceId;
+  }
+  context.logger.info(`http.webhook: ${method} ${url}`, { method, url });
+  let lastError;
+  let lastStatusCode = 0;
+  let attempts = 0;
+  const startTime = Date.now();
+  for (let attempt = 0; attempt <= retry_count; attempt++) {
+    attempts = attempt + 1;
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout_ms);
+      const response = await fetch(url, {
+        method,
+        headers: requestHeaders,
+        body,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const elapsed_ms2 = Date.now() - startTime;
+      const responseText = await response.text();
+      const response_body = responseText.length > 4096 ? responseText.slice(0, 4096) + "...[truncated]" : responseText;
+      if (response.ok) {
+        context.logger.info(`http.webhook: delivered successfully`, {
+          status: response.status,
+          attempts,
+          elapsed_ms: elapsed_ms2
+        });
+        return {
+          success: true,
+          status_code: response.status,
+          response_body,
+          attempts,
+          elapsed_ms: elapsed_ms2
+        };
+      }
+      if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+        context.logger.warn(`http.webhook: non-retryable failure`, {
+          status: response.status,
+          attempts
+        });
+        return {
+          success: false,
+          status_code: response.status,
+          response_body,
+          attempts,
+          elapsed_ms: elapsed_ms2
+        };
+      }
+      lastStatusCode = response.status;
+      lastError = new Error(`HTTP ${response.status}: ${response_body}`);
+      context.logger.warn(`http.webhook: retryable failure (attempt ${attempts})`, {
+        status: response.status
+      });
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (lastError.name !== "AbortError" && lastError.name !== "TypeError") {
+        break;
+      }
+      context.logger.warn(`http.webhook: network error (attempt ${attempts})`, {
+        error: lastError.message
+      });
+    }
+    if (attempt < retry_count) {
+      await new Promise((resolve) => setTimeout(resolve, 100 * Math.pow(2, attempt)));
+    }
+  }
+  const elapsed_ms = Date.now() - startTime;
+  context.logger.error(`http.webhook: all retries exhausted`, {
+    attempts,
+    elapsed_ms,
+    lastError: lastError?.message
+  });
+  return {
+    success: false,
+    status_code: lastStatusCode,
+    response_body: lastError?.message ?? "Unknown error",
+    attempts,
+    elapsed_ms
+  };
+};
+
+// src/effects/index.ts
+function registerEffects(registry) {
+  registry.register(serviceCallDefinition, serviceCallHandler, ServiceCallInput, ServiceCallOutput);
+  registry.register(
+    eventsPublishDefinition,
+    eventsPublishHandler,
+    EventsPublishInput,
+    EventsPublishOutput
+  );
+  registry.register(notifyUserDefinition, notifyUserHandler, NotifyUserInput, NotifyUserOutput);
+  registry.register(httpWebhookDefinition, httpWebhookHandler, HttpWebhookInput, HttpWebhookOutput);
+}
+
+// src/index.ts
+function registerAllCapabilities(registry) {
+  registerTransforms(registry);
+  registerEffects(registry);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CapabilityRegistry,
+  CollectionAggregateInput,
+  CollectionAggregateOutput,
+  CollectionFilterInput,
+  CollectionFilterOutput,
+  CollectionJoinInput,
+  CollectionJoinOutput,
+  DateShiftInput,
+  DateShiftOutput,
+  EventsFilterInput,
+  EventsFilterOutput,
+  EventsPublishInput,
+  EventsPublishOutput,
+  NotificationChannel,
+  NotifyUserInput,
+  NotifyUserOutput,
+  ServiceCallInput,
+  ServiceCallOutput,
+  TextFormatInput,
+  TextFormatOutput,
+  UnitsConvertInput,
+  UnitsConvertOutput,
+  collectionAggregateHandler,
+  collectionFilterHandler,
+  collectionJoinHandler,
+  dateShiftHandler,
+  defaultRegistry,
+  evaluatePredicate,
+  eventsFilterHandler,
+  eventsPublishDefinition,
+  eventsPublishHandler,
+  notifyUserDefinition,
+  notifyUserHandler,
+  registerAllCapabilities,
+  registerEffects,
+  registerTransforms,
+  serviceCallHandler,
+  stripBusPrefix,
+  textFormatHandler,
+  unitsConvertHandler
+});
+//# sourceMappingURL=index.js.map