@stackwright-services/capabilities 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1365 @@
+// 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
+import { z } from "zod";
+var AggregateOperation = z.enum(["count", "sum", "avg", "min", "max"]);
+var CollectionAggregateInput = z.object({
+  items: z.array(z.unknown()),
+  field: z.string().min(1),
+  operation: AggregateOperation
+});
+var CollectionAggregateOutput = z.object({
+  result: 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
+import { z as z2 } from "zod";
+var CollectionFilterInput = z2.object({
+  items: z2.array(z2.unknown()),
+  conditions: z2.array(
+    z2.object({
+      field: z2.string().min(1),
+      op: z2.string().min(1),
+      value: z2.unknown().optional(),
+      value_field: z2.string().min(1).optional()
+    })
+  )
+});
+var CollectionFilterOutput = z2.object({
+  items: z2.array(z2.unknown()),
+  count: z2.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
+import { z as z3 } from "zod";
+var CollectionJoinInput = z3.object({
+  /** Left-side items array */
+  leftItems: z3.array(z3.unknown()),
+  /** Right-side items array */
+  rightItems: z3.array(z3.unknown()),
+  /** Field path on left items to join on */
+  leftField: z3.string().min(1),
+  /** Field path on right items to join on */
+  rightField: z3.string().min(1)
+});
+var CollectionJoinOutput = z3.object({
+  /** Merged items where left[leftField] === right[rightField] */
+  items: z3.array(
+    z3.object({
+      left: z3.unknown(),
+      right: z3.unknown()
+    })
+  ),
+  /** Count of matched items */
+  count: z3.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
+import { z as z4 } from "zod";
+var CollectionPaginateInput = z4.object({
+  items: z4.array(z4.unknown()),
+  page: z4.number().int().min(1),
+  pageSize: z4.number().int().min(1).max(1e3)
+});
+var CollectionPaginateOutput = z4.object({
+  items: z4.array(z4.unknown()),
+  total: z4.number(),
+  page: z4.number(),
+  pageSize: z4.number(),
+  hasNext: z4.boolean(),
+  hasPrevious: z4.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
+import { z as z5 } from "zod";
+var MathOperation = z5.object({
+  op: z5.enum(["add", "subtract", "multiply", "divide", "modulo", "round", "ceil", "floor"]),
+  fields: z5.array(z5.string().min(1)).min(1),
+  // field paths to read operands from
+  result_field: z5.string().min(1)
+  // dot-path where the result is written
+});
+var MathComputeInput = z5.object({
+  data: z5.record(z5.unknown()),
+  operations: z5.array(MathOperation).min(1)
+});
+var MathComputeOutput = z5.object({
+  data: z5.record(z5.unknown()),
+  computed_fields: z5.array(z5.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
+import { z as z6 } from "zod";
+var SortKey = z6.object({
+  field: z6.string().min(1),
+  // Explicit direction required — no silent defaults. Explicit is better than implicit.
+  direction: z6.enum(["asc", "desc"])
+});
+var CollectionSortInput = z6.object({
+  items: z6.array(z6.unknown()),
+  sortBy: z6.array(SortKey).min(1)
+});
+var CollectionSortOutput = z6.object({
+  items: z6.array(z6.unknown()),
+  count: z6.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
+import { z as z7 } from "zod";
+var DateShiftInput = z7.object({
+  date: z7.string().min(1),
+  duration: z7.string().regex(
+    /^P(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+S)?)?$/,
+    'Duration must be ISO 8601 format (e.g. "P3D", "PT1H30M")'
+  ),
+  direction: z7.enum(["add", "subtract"])
+});
+var DateShiftOutput = z7.object({
+  result: z7.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
+import { z as z8 } from "zod";
+var EventsFilterInput = z8.object({
+  /** The event payload to evaluate */
+  event: z8.unknown(),
+  /** Typed predicate conditions -- all must pass for the event to pass through */
+  conditions: z8.array(
+    z8.object({
+      field: z8.string().min(1),
+      op: z8.string().min(1),
+      value: z8.unknown()
+    })
+  ).min(1)
+});
+var EventsFilterOutput = z8.object({
+  /** The event if it passed all conditions, or null if filtered out */
+  event: z8.unknown().nullable(),
+  /** Whether the event passed all conditions */
+  passed: z8.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
+import { z as z9 } from "zod";
+var TextFormatInput = z9.object({
+  template: z9.string(),
+  params: z9.record(z9.string(), z9.union([z9.string(), z9.number(), z9.boolean()]))
+});
+var TextFormatOutput = z9.object({
+  result: z9.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
+import { z as z10 } from "zod";
+var UnitCategory = z10.enum(["length", "weight", "temperature", "volume"]);
+var UnitsConvertInput = z10.object({
+  value: z10.number(),
+  from: z10.string().min(1),
+  to: z10.string().min(1),
+  category: UnitCategory
+});
+var UnitsConvertOutput = z10.object({
+  result: z10.number(),
+  from: z10.string(),
+  to: z10.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
+import { FIELD_COMPARISON_OPERATORS } from "@stackwright-services/types";
+import { z as z11 } from "zod";
+var ValidationRule = z11.object({
+  /** The field path to validate (dot notation supported: "address.zip") */
+  field: z11.string().min(1),
+  /** Predicate operator to apply */
+  op: z11.string(),
+  /** Expected value for the predicate (literal value or field name for *_field ops) */
+  value: z11.unknown(),
+  /** Optional human-readable error message (defaults to auto-generated) */
+  message: z11.string().optional()
+});
+var ValidationCheckInput = z11.object({
+  /** Data object to validate */
+  data: z11.record(z11.unknown()),
+  /** Validation rules to apply */
+  rules: z11.array(ValidationRule).min(1)
+});
+var ValidationError = z11.object({
+  /** Field that failed validation */
+  field: z11.string(),
+  /** Operator that was applied */
+  rule: z11.string(),
+  /** Human-readable error message */
+  message: z11.string(),
+  /** The actual value found at the field */
+  actual: z11.unknown().optional()
+});
+var ValidationCheckOutput = z11.object({
+  /** Whether all rules passed */
+  valid: z11.boolean(),
+  /** Number of rules that passed */
+  passed_count: z11.number().int().min(0),
+  /** Number of rules that failed */
+  failed_count: z11.number().int().min(0),
+  /** Detailed errors for each failed rule */
+  errors: z11.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 = 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
+import { z as z12 } from "zod";
+var ServiceCallInput = z12.object({
+  /** The URL to call (raw HTTP fallback — always required so the effect works without a provider) */
+  url: z12.string().url(),
+  /** HTTP method */
+  method: z12.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: z12.string().optional(),
+  /**
+   * Operation name for provider delegation (e.g. "listUnits").
+   * Must be provided together with `source` to trigger provider delegation.
+   */
+  operation: z12.string().optional(),
+  /** Request headers */
+  headers: z12.record(z12.string(), z12.string()).optional(),
+  /** Request body (for POST/PUT/PATCH, or provider operation params when delegating) */
+  body: z12.unknown().optional(),
+  /** Expected response type (defaults to 'json') */
+  responseType: z12.enum(["json", "text"]).optional(),
+  /** Timeout in milliseconds (defaults to 30000) */
+  timeout: z12.number().positive().optional()
+});
+var ServiceCallOutput = z12.object({
+  /** HTTP status code */
+  status: z12.number(),
+  /** Response headers */
+  headers: z12.record(z12.string(), z12.string()),
+  /** Response body */
+  body: z12.unknown(),
+  /** Whether the call was successful (2xx status) */
+  ok: z12.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
+import { z as z13 } from "zod";
+var EventsPublishInput = z13.object({
+  /** Topic to publish to (e.g. "bus:equipment-status" or "equipment-status") */
+  topic: z13.string().min(1),
+  /** Message payload to publish */
+  payload: z13.unknown(),
+  /** Optional metadata to include with the message */
+  metadata: z13.object({
+    /** Logical source identifier */
+    source: z13.string().optional(),
+    /** Correlation ID for request-scoped grouping */
+    correlationId: z13.string().optional()
+  }).optional()
+});
+var EventsPublishOutput = z13.object({
+  /** Provider-assigned message ID */
+  messageId: z13.string(),
+  /** Topic the message was published to (without bus: prefix) */
+  topic: z13.string(),
+  /** Whether publishing succeeded */
+  success: z13.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
+import { z as z14 } from "zod";
+var NotificationChannel = z14.enum(["email", "sms", "push", "in-app"]);
+var NotifyUserInput = z14.object({
+  /** Recipient user identifier — the provider resolves this to a delivery address */
+  recipient: z14.string().min(1),
+  /** Delivery channel */
+  channel: NotificationChannel,
+  /** Template name for the notification content */
+  template: z14.string().min(1),
+  /** Typed payload for template interpolation */
+  payload: z14.unknown(),
+  /** Optional subject line (for email, push) */
+  subject: z14.string().optional(),
+  /** Optional metadata to include with the notification */
+  metadata: z14.object({
+    /** Logical source identifier */
+    source: z14.string().optional(),
+    /** Correlation ID for request-scoped grouping */
+    correlationId: z14.string().optional()
+  }).optional()
+});
+var NotifyUserOutput = z14.object({
+  /** Provider-assigned notification ID */
+  notificationId: z14.string(),
+  /** Channel the notification was sent through */
+  channel: z14.string(),
+  /** Whether sending succeeded */
+  success: z14.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
+import { z as z15 } from "zod";
+var HttpWebhookInput = z15.object({
+  /** Target URL -- must be declared statically in flow YAML */
+  url: z15.string().url(),
+  /** HTTP method -- only POST or PUT for webhooks (defaults to POST) */
+  method: z15.enum(["POST", "PUT"]).optional(),
+  /** Payload to send -- shape is flow-defined */
+  payload: z15.unknown(),
+  /** Additional headers to include */
+  headers: z15.record(z15.string()).optional(),
+  /** Request timeout in milliseconds (100ms - 30s, defaults to 5000) */
+  timeout_ms: z15.number().int().min(100).max(3e4).optional(),
+  /** Number of retry attempts on failure (0-3, defaults to 1) */
+  retry_count: z15.number().int().min(0).max(3).optional(),
+  /** Optional HMAC-SHA256 secret for request signing */
+  signature_secret: z15.string().optional()
+});
+var HttpWebhookOutput = z15.object({
+  /** Whether the webhook was delivered successfully */
+  success: z15.boolean(),
+  /** HTTP status code from the target */
+  status_code: z15.number().int(),
+  /** Response body (truncated to 4KB for safety) */
+  response_body: z15.string().optional(),
+  /** Number of attempts made (1 = first try succeeded) */
+  attempts: z15.number().int().min(1),
+  /** Total elapsed time in milliseconds */
+  elapsed_ms: z15.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);
+}
+export {
+  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.mjs.map