@sixb/core 0.0.1

package/dist/chunk-867jxh7c.js

@@ -0,0 +1,1156 @@
+// @bun
+import {
+  buildEventSelectorPredicate,
+  eventSelectorSpec
+} from "./chunk-74drx9gd.js";
+import {
+  compareDecimalValues,
+  isDecimalValue
+} from "./chunk-04b07a9q.js";
+
+// src/predicates/validation.ts
+var propertyOperators = new Set([
+  "eq",
+  "notEq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "isPresent",
+  "isMissing"
+]);
+var propertyValueOperators = new Set([
+  "eq",
+  "notEq",
+  "gt",
+  "gte",
+  "lt",
+  "lte"
+]);
+var linkOperators = new Set(["exists", "isMissing"]);
+function defaultError(message) {
+  return new Error(message);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertNonEmptyString(value, field, createError) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw createError(`${field} must not be empty.`);
+  }
+}
+function isPredicateValue(value) {
+  if (value === null) {
+    return true;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value);
+  }
+  return typeof value === "string" || typeof value === "boolean";
+}
+function assertPredicateShape(value, options = {}) {
+  const subject = options.subject ?? "Predicate";
+  const createError = options.createError ?? defaultError;
+  if (!isRecord(value)) {
+    throw createError(`${subject} predicate must be an object.`);
+  }
+  if (value.kind === "all" || value.kind === "any") {
+    if (!Array.isArray(value.predicates)) {
+      throw createError(`${subject} ${value.kind} predicate must declare predicates.`);
+    }
+    for (const predicate of value.predicates) {
+      assertPredicateShape(predicate, options);
+    }
+    return;
+  }
+  if (value.kind === "not") {
+    assertPredicateShape(value.predicate, options);
+    return;
+  }
+  if (value.kind === "property") {
+    assertNonEmptyString(value.propertyId, `${subject} property predicate propertyId`, createError);
+    if (!propertyOperators.has(value.op)) {
+      throw createError(`${subject} property predicate '${value.propertyId}' has invalid operator '${String(value.op)}'.`);
+    }
+    const op = value.op;
+    const hasValue = Object.hasOwn(value, "value");
+    if (propertyValueOperators.has(op)) {
+      if (!hasValue || !isPredicateValue(value.value)) {
+        throw createError(`${subject} property predicate '${value.propertyId}' must declare a value.`);
+      }
+      return;
+    }
+    if (hasValue) {
+      throw createError(`${subject} property predicate '${value.propertyId}' must not declare a value.`);
+    }
+    return;
+  }
+  if (value.kind === "field") {
+    assertNonEmptyString(value.field, `${subject} field predicate field`, createError);
+    if (value.op !== "eq") {
+      throw createError(`${subject} field predicate '${value.field}' has invalid operator '${String(value.op)}'.`);
+    }
+    if (!isPredicateValue(value.value)) {
+      throw createError(`${subject} field predicate '${value.field}' must declare a value.`);
+    }
+    return;
+  }
+  if (value.kind === "link") {
+    assertNonEmptyString(value.linkId, `${subject} link predicate linkId`, createError);
+    if (!linkOperators.has(value.op)) {
+      throw createError(`${subject} link predicate '${value.linkId}' has invalid operator '${String(value.op)}'.`);
+    }
+    return;
+  }
+  throw createError(`Unknown ${subject.toLowerCase()} predicate kind '${String(value.kind)}'.`);
+}
+
+// src/predicates/builders.ts
+function createFieldPredicate(field, value, options = {}) {
+  const subject = options.subject ?? "Predicate";
+  const createError = options.createError ?? defaultError2;
+  if (!field.trim()) {
+    throw createError(`${subject} predicate field must not be empty.`);
+  }
+  assertSerializablePredicateValue(value, subject, createError);
+  return { kind: "field", field, op: "eq", value };
+}
+function defaultError2(message) {
+  return new Error(message);
+}
+function assertSerializablePredicateValue(value, subject, createError) {
+  if (!isPredicateValue(value)) {
+    throw createError(`${subject} predicate values must be serializable scalar values.`);
+  }
+}
+function createPropertyPredicate(propertyId, op, value, options = {}) {
+  const subject = options.subject ?? "Predicate";
+  const createError = options.createError ?? defaultError2;
+  if (value !== undefined) {
+    assertSerializablePredicateValue(value, subject, createError);
+  }
+  return {
+    kind: "property",
+    propertyId,
+    op,
+    ...value !== undefined ? { value } : {}
+  };
+}
+function createPropertyPredicateBuilder(propertyId, options = {}) {
+  const wrap = options.wrap ?? ((predicate) => predicate);
+  const createPredicate = (op, value) => wrap(createPropertyPredicate(propertyId, op, value, options));
+  return {
+    eq(value) {
+      return createPredicate("eq", value);
+    },
+    notEq(value) {
+      return createPredicate("notEq", value);
+    },
+    gt(value) {
+      return createPredicate("gt", value);
+    },
+    gte(value) {
+      return createPredicate("gte", value);
+    },
+    lt(value) {
+      return createPredicate("lt", value);
+    },
+    lte(value) {
+      return createPredicate("lte", value);
+    },
+    isPresent() {
+      return createPredicate("isPresent");
+    },
+    isMissing() {
+      return createPredicate("isMissing");
+    }
+  };
+}
+function createLinkPredicateBuilder(linkId) {
+  return {
+    exists() {
+      return {
+        kind: "link",
+        linkId,
+        op: "exists"
+      };
+    },
+    isMissing() {
+      return {
+        kind: "link",
+        linkId,
+        op: "isMissing"
+      };
+    }
+  };
+}
+function allPredicates(predicates) {
+  return {
+    kind: "all",
+    predicates: [...predicates]
+  };
+}
+function anyPredicates(predicates) {
+  return {
+    kind: "any",
+    predicates: [...predicates]
+  };
+}
+function notPredicate(predicate) {
+  return {
+    kind: "not",
+    predicate
+  };
+}
+// src/predicates/evaluate.ts
+function evaluatePredicate(predicate, subject) {
+  switch (predicate.kind) {
+    case "all":
+      return predicate.predicates.every((child) => evaluatePredicate(child, subject));
+    case "any":
+      return predicate.predicates.some((child) => evaluatePredicate(child, subject));
+    case "not":
+      return !evaluatePredicate(predicate.predicate, subject);
+    case "property":
+      return evaluatePropertyPredicate(predicate, subject.properties ?? {});
+    case "field":
+      return evaluateFieldPredicate(predicate, subject.fields ?? {});
+    case "link":
+      return evaluateLinkPredicate(predicate, subject.links ?? {});
+  }
+}
+function evaluateFieldPredicate(predicate, fields) {
+  return predicateValueEquals(fields[predicate.field], predicate.value);
+}
+function evaluatePropertyPredicate(predicate, properties) {
+  const value = properties[predicate.propertyId];
+  const isPresent = value !== undefined && value !== null;
+  switch (predicate.op) {
+    case "eq":
+      return isPresent && predicateValueEquals(value, predicate.value);
+    case "notEq":
+      return !isPresent || !predicateValueEquals(value, predicate.value);
+    case "gt":
+      return compareOrderedValues(value, predicate.value, (comparison) => comparison > 0);
+    case "gte":
+      return compareOrderedValues(value, predicate.value, (comparison) => comparison >= 0);
+    case "lt":
+      return compareOrderedValues(value, predicate.value, (comparison) => comparison < 0);
+    case "lte":
+      return compareOrderedValues(value, predicate.value, (comparison) => comparison <= 0);
+    case "isPresent":
+      return isPresent;
+    case "isMissing":
+      return !isPresent;
+  }
+}
+function evaluateLinkPredicate(predicate, links) {
+  const exists = links[predicate.linkId] === true;
+  switch (predicate.op) {
+    case "exists":
+      return exists;
+    case "isMissing":
+      return !exists;
+  }
+}
+function predicateValueEquals(left, right) {
+  return isPredicateComparableValue(left) && right !== undefined && Object.is(left, right);
+}
+function isPredicateComparableValue(value) {
+  return value === null || typeof value === "string" || typeof value === "boolean" || isNumber(value);
+}
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function compareOrderedValues(left, right, matches) {
+  if (isNumber(left) && isNumber(right))
+    return matches(left - right);
+  if (isDecimalValue(left) && isDecimalValue(right)) {
+    return matches(compareDecimalValues(left, right));
+  }
+  return false;
+}
+// src/schedules/errors.ts
+class ScheduleValidationError extends Error {
+  name = "ScheduleValidationError";
+}
+
+class CronValidationError extends Error {
+  name = "CronValidationError";
+}
+
+// src/schedules/cron.ts
+function parseInteger(input, fieldName) {
+  if (!/^\d+$/.test(input)) {
+    throw new CronValidationError(`Invalid ${fieldName}: '${input}'.`);
+  }
+  return Number.parseInt(input, 10);
+}
+function createCronFieldMatcher(params) {
+  const { field, min, max, fieldName } = params;
+  const normalize = params.normalize ?? ((value) => value);
+  const input = field.trim();
+  if (!input) {
+    throw new CronValidationError(`Empty cron ${fieldName} field.`);
+  }
+  if (input === "*") {
+    return {
+      isAny: true,
+      values: null,
+      matches: () => true
+    };
+  }
+  const allowed = new Set;
+  const segments = input.split(",");
+  for (const segment of segments) {
+    if (!segment) {
+      throw new CronValidationError(`Invalid cron ${fieldName} field: '${input}'.`);
+    }
+    const stepParts = segment.split("/");
+    if (stepParts.length > 2) {
+      throw new CronValidationError(`Invalid cron ${fieldName} segment: '${segment}'.`);
+    }
+    const base = stepParts[0];
+    const step = stepParts[1] === undefined ? 1 : parseInteger(stepParts[1], `cron ${fieldName} step for '${segment}'`);
+    if (step <= 0) {
+      throw new CronValidationError(`Cron ${fieldName} step must be > 0 in segment '${segment}'.`);
+    }
+    let rangeStart;
+    let rangeEnd;
+    if (base === "*") {
+      rangeStart = min;
+      rangeEnd = max;
+    } else if (base.includes("-")) {
+      const [rawStart, rawEnd] = base.split("-");
+      if (!rawStart || !rawEnd) {
+        throw new CronValidationError(`Invalid cron ${fieldName} range: '${base}'.`);
+      }
+      rangeStart = parseInteger(rawStart, `cron ${fieldName} range start for '${base}'`);
+      rangeEnd = parseInteger(rawEnd, `cron ${fieldName} range end for '${base}'`);
+    } else {
+      const value = parseInteger(base, `cron ${fieldName} value '${base}'`);
+      rangeStart = value;
+      rangeEnd = value;
+    }
+    if (rangeStart > rangeEnd) {
+      throw new CronValidationError(`Cron ${fieldName} range start must be <= end in segment '${segment}'.`);
+    }
+    for (let value = rangeStart;value <= rangeEnd; value += step) {
+      const normalized = normalize(value);
+      if (normalized < min || normalized > max) {
+        throw new CronValidationError(`Cron ${fieldName} value ${value} is outside range ${min}-${max}.`);
+      }
+      allowed.add(normalized);
+    }
+  }
+  return {
+    isAny: false,
+    values: allowed,
+    matches(value) {
+      const normalized = normalize(value);
+      return allowed.has(normalized);
+    }
+  };
+}
+function createCronMatcher(expression) {
+  const parts = expression.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    throw new CronValidationError(`Invalid cron expression '${expression}'. Expected 5 fields (minute hour day month weekday).`);
+  }
+  const [minuteField, hourField, dayOfMonthField, monthField, dayOfWeekField] = parts;
+  const minute = createCronFieldMatcher({
+    field: minuteField,
+    min: 0,
+    max: 59,
+    fieldName: "minute"
+  });
+  const hour = createCronFieldMatcher({
+    field: hourField,
+    min: 0,
+    max: 23,
+    fieldName: "hour"
+  });
+  const dayOfMonth = createCronFieldMatcher({
+    field: dayOfMonthField,
+    min: 1,
+    max: 31,
+    fieldName: "day-of-month"
+  });
+  const month = createCronFieldMatcher({
+    field: monthField,
+    min: 1,
+    max: 12,
+    fieldName: "month"
+  });
+  const dayOfWeek = createCronFieldMatcher({
+    field: dayOfWeekField,
+    min: 0,
+    max: 6,
+    fieldName: "day-of-week",
+    normalize: (value) => value === 7 ? 0 : value
+  });
+  return (now) => {
+    if (!minute.matches(now.getMinutes()))
+      return false;
+    if (!hour.matches(now.getHours()))
+      return false;
+    if (!month.matches(now.getMonth() + 1))
+      return false;
+    const dayOfMonthMatches = dayOfMonth.matches(now.getDate());
+    const dayOfWeekMatches = dayOfWeek.matches(now.getDay());
+    const dayMatches = dayOfMonth.isAny || dayOfWeek.isAny ? dayOfMonthMatches && dayOfWeekMatches : dayOfMonthMatches || dayOfWeekMatches;
+    return dayMatches;
+  };
+}
+
+// src/schedules/builders.ts
+function assertNonEmpty(value, field) {
+  if (!value.trim()) {
+    throw new ScheduleValidationError(`Schedule ${field} must not be empty.`);
+  }
+}
+function validateTimezone(timezone) {
+  try {
+    Intl.DateTimeFormat(undefined, { timeZone: timezone });
+  } catch {
+    throw new ScheduleValidationError(`Invalid timezone '${timezone}'.`);
+  }
+}
+function createCondition(scope, predicate) {
+  return {
+    kind: "becomesTrue",
+    scope,
+    predicate
+  };
+}
+function createEventSchedulePropertyPredicateBuilder(scope, propertyId) {
+  return createPropertyPredicateBuilder(propertyId, {
+    subject: "Schedule",
+    createError: (message) => new ScheduleValidationError(message),
+    wrap: (predicate) => createCondition(scope, predicate)
+  });
+}
+function createPredicateSubject(scope) {
+  const properties = new Proxy({}, {
+    get(target, property) {
+      if (typeof property !== "string")
+        return;
+      target[property] ??= createEventSchedulePropertyPredicateBuilder(scope, property);
+      return target[property];
+    }
+  });
+  return {
+    p: properties,
+    all(...conditions) {
+      return createCondition(scope, allPredicates(conditions.map((condition) => condition.predicate)));
+    },
+    any(...conditions) {
+      return createCondition(scope, anyPredicates(conditions.map((condition) => condition.predicate)));
+    },
+    not(condition) {
+      return createCondition(scope, notPredicate(condition.predicate));
+    }
+  };
+}
+function createTargetPredicateSubject() {
+  const condition = (field, value) => createCondition("event.link", createFieldPredicate(field, value, {
+    subject: "Schedule",
+    createError: (message) => new ScheduleValidationError(message)
+  }));
+  return {
+    is(objectType) {
+      assertNonEmpty(objectType.id, "target object type id");
+      return condition("target.objectTypeId", objectType.id);
+    },
+    id: {
+      eq(value) {
+        assertNonEmpty(value, "target object id");
+        return condition("target.primaryId", value);
+      }
+    }
+  };
+}
+function createPredicateContext(selector) {
+  if (selector.topic === "objects") {
+    return { object: createPredicateSubject("event.object") };
+  }
+  if (selector.topic === "links") {
+    return {
+      link: createPredicateSubject("event.link"),
+      target: createTargetPredicateSubject()
+    };
+  }
+  return {};
+}
+function assertEventSource(source) {
+  if (!source.types || source.types.length === 0) {
+    throw new ScheduleValidationError("Schedule event source must select an event operation, e.g. .created(), .updated(), or .succeeded().");
+  }
+  switch (source.topic) {
+    case "objects":
+      assertNonEmpty(source.objectTypeId ?? "", "event source objectTypeId");
+      return;
+    case "links":
+      assertNonEmpty(source.objectTypeId ?? "", "event source objectTypeId");
+      assertNonEmpty(source.linkId ?? "", "event source linkId");
+      return;
+    case "rules":
+      assertNonEmpty(source.ruleId ?? "", "event source ruleId");
+      return;
+    case "actions":
+      assertNonEmpty(source.actionId ?? "", "event source actionId");
+      return;
+    case "datasets":
+      assertNonEmpty(source.datasetId ?? "", "event source datasetId");
+      return;
+    case "syncs":
+      assertNonEmpty(source.syncId ?? "", "event source syncId");
+      return;
+    case "pipelines":
+      assertNonEmpty(source.pipelineId ?? "", "event source pipelineId");
+      return;
+    default:
+      throw new ScheduleValidationError("Schedule event source must select object, link, rule, action, dataset, sync, or pipeline events.");
+  }
+}
+function defineSchedule(id) {
+  assertNonEmpty(id, "id");
+  return {
+    cron(expression, options) {
+      assertNonEmpty(expression, "cron expression");
+      createCronMatcher(expression);
+      if (options?.timezone !== undefined)
+        validateTimezone(options.timezone);
+      return {
+        kind: "schedule",
+        id,
+        trigger: {
+          type: "cron",
+          expression,
+          ...options?.timezone !== undefined ? { timezone: options.timezone } : {}
+        }
+      };
+    },
+    on(selector) {
+      const source = eventSelectorSpec(selector);
+      assertEventSource(source);
+      const base = {
+        kind: "schedule",
+        id,
+        trigger: {
+          type: "event",
+          source
+        }
+      };
+      if (source.topic !== "objects" && source.topic !== "links") {
+        return base;
+      }
+      Object.defineProperty(base, "where", {
+        enumerable: false,
+        value(callback) {
+          const condition = callback(createPredicateContext(source));
+          if (!condition || condition.kind !== "becomesTrue") {
+            throw new ScheduleValidationError("Schedule condition must be built from the event DSL.");
+          }
+          assertPredicateShape(condition.predicate, {
+            subject: "Schedule",
+            createError: (message) => new ScheduleValidationError(message)
+          });
+          return {
+            ...base,
+            trigger: {
+              ...base.trigger,
+              condition
+            }
+          };
+        }
+      });
+      return base;
+    }
+  };
+}
+// src/schedules/next-occurrence.ts
+var MAX_SEARCH_MS = 4 * 365.25 * 24 * 60 * 60 * 1000;
+var timezoneFormatterCache = new Map;
+function getTimezoneFormatter(timezone) {
+  let formatter = timezoneFormatterCache.get(timezone);
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      weekday: "short",
+      hour12: false
+    });
+    timezoneFormatterCache.set(timezone, formatter);
+  }
+  return formatter;
+}
+function getLocalComponents(date, timezone) {
+  if (timezone === undefined) {
+    return {
+      minute: date.getUTCMinutes(),
+      hour: date.getUTCHours(),
+      dayOfMonth: date.getUTCDate(),
+      month: date.getUTCMonth() + 1,
+      dayOfWeek: date.getUTCDay()
+    };
+  }
+  const formatter = getTimezoneFormatter(timezone);
+  const parts = formatter.formatToParts(date);
+  const get = (type) => {
+    const part = parts.find((p) => p.type === type);
+    if (!part)
+      throw new CronValidationError(`Failed to extract ${type} for timezone ${timezone}.`);
+    return part.value;
+  };
+  const weekdayStr = get("weekday");
+  const weekdayMap = {
+    Sun: 0,
+    Mon: 1,
+    Tue: 2,
+    Wed: 3,
+    Thu: 4,
+    Fri: 5,
+    Sat: 6
+  };
+  return {
+    minute: Number.parseInt(get("minute"), 10),
+    hour: Number.parseInt(get("hour"), 10) % 24,
+    dayOfMonth: Number.parseInt(get("day"), 10),
+    month: Number.parseInt(get("month"), 10),
+    dayOfWeek: weekdayMap[weekdayStr] ?? 0
+  };
+}
+function matchesDay(dayOfMonth, dayOfWeek, comp) {
+  const domMatches = dayOfMonth.matches(comp.dayOfMonth);
+  const dowMatches = dayOfWeek.matches(comp.dayOfWeek);
+  if (dayOfMonth.isAny || dayOfWeek.isAny) {
+    return domMatches && dowMatches;
+  }
+  return domMatches || dowMatches;
+}
+function nextCronOccurrence(expression, after, timezone) {
+  const parts = expression.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    throw new CronValidationError(`Invalid cron expression '${expression}'. Expected 5 fields (minute hour day month weekday).`);
+  }
+  const [minuteField, hourField, dayOfMonthField, monthField, dayOfWeekField] = parts;
+  const minuteMatcher = createCronFieldMatcher({
+    field: minuteField,
+    min: 0,
+    max: 59,
+    fieldName: "minute"
+  });
+  const hourMatcher = createCronFieldMatcher({
+    field: hourField,
+    min: 0,
+    max: 23,
+    fieldName: "hour"
+  });
+  const dayOfMonthMatcher = createCronFieldMatcher({
+    field: dayOfMonthField,
+    min: 1,
+    max: 31,
+    fieldName: "day-of-month"
+  });
+  const monthMatcher = createCronFieldMatcher({
+    field: monthField,
+    min: 1,
+    max: 12,
+    fieldName: "month"
+  });
+  const dayOfWeekMatcher = createCronFieldMatcher({
+    field: dayOfWeekField,
+    min: 0,
+    max: 6,
+    fieldName: "day-of-week",
+    normalize: (value) => value === 7 ? 0 : value
+  });
+  const startMs = after.getTime();
+  let candidateMs = Math.ceil(startMs / 60000) * 60000;
+  if (candidateMs <= startMs)
+    candidateMs += 60000;
+  const limitMs = startMs + MAX_SEARCH_MS;
+  while (candidateMs <= limitMs) {
+    const candidate = new Date(candidateMs);
+    const comp = getLocalComponents(candidate, timezone);
+    if (!monthMatcher.matches(comp.month)) {
+      if (timezone === undefined) {
+        const next = findNextMatchingMonth(candidate, monthMatcher);
+        candidateMs = next.getTime();
+      } else {
+        candidateMs += ((24 - comp.hour) * 60 - comp.minute) * 60000;
+      }
+      continue;
+    }
+    if (!matchesDay(dayOfMonthMatcher, dayOfWeekMatcher, comp)) {
+      if (timezone === undefined) {
+        const next = new Date(candidateMs);
+        next.setUTCDate(next.getUTCDate() + 1);
+        next.setUTCHours(0, 0, 0, 0);
+        candidateMs = next.getTime();
+      } else {
+        candidateMs += ((24 - comp.hour) * 60 - comp.minute) * 60000;
+      }
+      continue;
+    }
+    if (!hourMatcher.matches(comp.hour)) {
+      if (timezone === undefined) {
+        const next = new Date(candidateMs);
+        next.setUTCHours(next.getUTCHours() + 1, 0, 0, 0);
+        candidateMs = next.getTime();
+      } else {
+        candidateMs += (60 - comp.minute) * 60000;
+      }
+      continue;
+    }
+    if (!minuteMatcher.matches(comp.minute)) {
+      candidateMs += 60000;
+      continue;
+    }
+    return candidate;
+  }
+  throw new CronValidationError(`No matching occurrence found for '${expression}' within 4 years.`);
+}
+function findNextMatchingMonth(current, monthMatcher) {
+  const d = new Date(current);
+  d.setUTCDate(1);
+  d.setUTCHours(0, 0, 0, 0);
+  d.setUTCMonth(d.getUTCMonth() + 1);
+  for (let i = 0;i < 48; i++) {
+    if (monthMatcher.matches(d.getUTCMonth() + 1)) {
+      return d;
+    }
+    d.setUTCMonth(d.getUTCMonth() + 1);
+  }
+  return d;
+}
+// src/schedules/runtime.ts
+function eventScheduleSubscribedEventTypes(schedule) {
+  return schedule.trigger.source.types ?? [];
+}
+function evaluateEventSchedule(schedule, event) {
+  if (!buildEventSelectorPredicate(schedule.trigger.source)(event)) {
+    return null;
+  }
+  const eventContext = buildEventScheduleContext(event);
+  if (!eventContext) {
+    return null;
+  }
+  const condition = schedule.trigger.condition;
+  if (!condition) {
+    return {
+      schedule,
+      event: eventContext
+    };
+  }
+  const afterProperties = propertiesForScope(event, condition.scope);
+  const fields = fieldsForEvent(event);
+  if (!evaluatePredicate(condition.predicate, { properties: afterProperties, fields })) {
+    return null;
+  }
+  if (isUpdateEvent(event)) {
+    const beforeProperties = previousProperties(afterProperties, event.payload.propertyChanges);
+    if (evaluatePredicate(condition.predicate, { properties: beforeProperties, fields })) {
+      return null;
+    }
+  }
+  return {
+    schedule,
+    event: eventContext
+  };
+}
+function buildEventScheduleContext(event) {
+  switch (event.type) {
+    case "object.created":
+    case "object.updated":
+    case "object.deleted":
+      return {
+        object: {
+          objectTypeId: event.payload.objectTypeId,
+          primaryId: event.payload.primaryId,
+          p: currentProperties(event)
+        }
+      };
+    case "link.created":
+    case "link.updated":
+    case "link.deleted":
+      return {
+        source: {
+          objectTypeId: event.payload.sourceTypeId,
+          primaryId: event.payload.sourceId
+        },
+        target: {
+          objectTypeId: event.payload.targetTypeId,
+          primaryId: event.payload.targetId
+        },
+        link: {
+          id: event.payload.linkId,
+          p: currentProperties(event)
+        }
+      };
+    case "rule.triggered":
+    case "rule.resolved":
+      return {
+        ruleId: event.payload.ruleId,
+        subject: {
+          objectTypeId: event.payload.subject.objectTypeId,
+          primaryId: event.payload.subject.primaryId
+        }
+      };
+    case "action.requested":
+      return {
+        actionId: event.payload.actionId,
+        runId: event.payload.runId,
+        ...actionSubjectContext(event.payload.subject),
+        params: { ...event.payload.params }
+      };
+    case "action.completed":
+      return {
+        actionId: event.payload.actionId,
+        runId: event.payload.runId,
+        ...actionSubjectContext(event.payload.subject)
+      };
+    case "action.failed":
+      return {
+        actionId: event.payload.actionId,
+        runId: event.payload.runId,
+        ...actionSubjectContext(event.payload.subject),
+        error: event.payload.error
+      };
+    case "dataset.version.committed":
+      return { ...event.payload };
+    case "sync.run.finished":
+      return { ...event.payload };
+    case "pipeline.run.finished":
+      return { ...event.payload };
+    default:
+      return null;
+  }
+}
+function actionSubjectContext(subject) {
+  if (subject.kind !== "object" || subject.objectTypeId === undefined || subject.primaryId === undefined) {
+    return {};
+  }
+  return {
+    subject: {
+      objectTypeId: subject.objectTypeId,
+      primaryId: subject.primaryId
+    }
+  };
+}
+function fieldsForEvent(event) {
+  if (event.topic !== "links") {
+    return {};
+  }
+  return {
+    "target.objectTypeId": event.payload.targetTypeId,
+    "target.primaryId": event.payload.targetId
+  };
+}
+function propertiesForScope(event, scope) {
+  if (scope === "event.object" && event.topic !== "objects") {
+    return {};
+  }
+  if (scope === "event.link" && event.topic !== "links") {
+    return {};
+  }
+  return currentProperties(event);
+}
+function currentProperties(event) {
+  const payload = event.payload;
+  if (payload && typeof payload === "object" && "properties" in payload) {
+    return { ...payload.properties ?? {} };
+  }
+  if (payload && typeof payload === "object" && "propertyChanges" in payload) {
+    return propertiesFromChanges(payload.propertyChanges, "after");
+  }
+  return {};
+}
+function previousProperties(afterProperties, changes) {
+  const before = { ...afterProperties };
+  for (const [propertyId, change] of Object.entries(changes)) {
+    if (change.operation === "created") {
+      delete before[propertyId];
+      continue;
+    }
+    before[propertyId] = change.before;
+  }
+  return before;
+}
+function propertiesFromChanges(changes, side) {
+  const properties = {};
+  for (const [propertyId, change] of Object.entries(changes)) {
+    const value = propertyChangeValue(change, side);
+    if (value !== undefined) {
+      properties[propertyId] = value;
+    }
+  }
+  return properties;
+}
+function propertyChangeValue(change, side) {
+  if (side === "before") {
+    return change.operation === "created" ? undefined : change.before;
+  }
+  return change.after;
+}
+function isUpdateEvent(event) {
+  return event.type === "object.updated" || event.type === "link.updated";
+}
+// src/schedules/types.ts
+function isScheduleReference(value) {
+  return typeof value === "object" && value !== null && "type" in value && value.type === "schedule" && "scheduleId" in value && typeof value.scheduleId === "string" && value.scheduleId.trim().length > 0;
+}
+// src/schedules/validation.ts
+var objectEventTypes = new Set(["object.created", "object.updated", "object.deleted"]);
+var linkEventTypes = new Set(["link.created", "link.updated", "link.deleted"]);
+var ruleEventTypes = new Set(["rule.triggered", "rule.resolved"]);
+var actionEventTypes = new Set(["action.requested", "action.completed", "action.failed"]);
+var datasetEventTypes = new Set(["dataset.version.committed"]);
+var syncEventTypes = new Set(["sync.run.finished"]);
+var pipelineEventTypes = new Set(["pipeline.run.finished"]);
+var runStatuses = new Set(["succeeded", "failed", "cancelled"]);
+var linkIdentityFields = new Set(["target.objectTypeId", "target.primaryId"]);
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertNonEmptyString2(value, field, createError) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw createError(`${field} must not be empty.`);
+  }
+}
+function assertScheduleDefinition(value, createError = (message) => new ScheduleValidationError(message)) {
+  if (!isRecord2(value))
+    throw createError("Schedule definition must be an object.");
+  if (value.kind !== "schedule") {
+    throw createError("Schedule definition kind must be 'schedule'.");
+  }
+  assertNonEmptyString2(value.id, "Schedule id", createError);
+  if (!isRecord2(value.trigger))
+    throw createError(`Schedule "${value.id}" trigger must be an object.`);
+  if (value.trigger.type === "cron") {
+    assertNonEmptyString2(value.trigger.expression, `Schedule "${value.id}" cron expression`, createError);
+    if (value.trigger.timezone !== undefined && typeof value.trigger.timezone !== "string") {
+      throw createError(`Schedule "${value.id}" timezone must be a string.`);
+    }
+    return;
+  }
+  if (value.trigger.type !== "event") {
+    throw createError(`Schedule "${value.id}" trigger type is unsupported.`);
+  }
+  assertEventSourceShape(value.trigger.source, `Schedule "${value.id}" event source`, createError);
+  if (value.trigger.condition !== undefined) {
+    assertEventConditionShape(value.trigger.condition, `Schedule "${value.id}" condition`, createError);
+  }
+}
+function isScheduleDefinition(value) {
+  try {
+    assertScheduleDefinition(value, (message) => new Error(message));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateSchedulesAtStartup(schedules, ontology, options = {}) {
+  const seenIds = new Set;
+  for (const schedule of schedules) {
+    assertScheduleDefinition(schedule);
+    if (seenIds.has(schedule.id)) {
+      throw new ScheduleValidationError(`Duplicate schedule id: ${schedule.id}`);
+    }
+    seenIds.add(schedule.id);
+    if (schedule.trigger.type === "cron") {
+      createCronMatcher(schedule.trigger.expression);
+      if (schedule.trigger.timezone !== undefined)
+        validateTimezone2(schedule.trigger.timezone);
+      continue;
+    }
+    validateEventSchedule(schedule, ontology, options);
+  }
+}
+function validateTimezone2(timezone) {
+  try {
+    Intl.DateTimeFormat(undefined, { timeZone: timezone });
+  } catch {
+    throw new ScheduleValidationError(`Invalid timezone '${timezone}'.`);
+  }
+}
+function assertEventSourceShape(value, path, createError) {
+  if (!isRecord2(value))
+    throw createError(`${path} must be an event selector.`);
+  if (!Array.isArray(value.types) || value.types.length === 0) {
+    throw createError(`${path} must select at least one event type.`);
+  }
+  switch (value.topic) {
+    case "objects":
+      assertNonEmptyString2(value.objectTypeId, `${path} objectTypeId`, createError);
+      return;
+    case "links":
+      assertNonEmptyString2(value.objectTypeId, `${path} objectTypeId`, createError);
+      assertNonEmptyString2(value.linkId, `${path} linkId`, createError);
+      return;
+    case "rules":
+      assertNonEmptyString2(value.ruleId, `${path} ruleId`, createError);
+      return;
+    case "actions":
+      assertNonEmptyString2(value.actionId, `${path} actionId`, createError);
+      return;
+    case "datasets":
+      assertNonEmptyString2(value.datasetId, `${path} datasetId`, createError);
+      return;
+    case "syncs":
+      assertNonEmptyString2(value.syncId, `${path} syncId`, createError);
+      assertRunStatus(value.runStatus, path, createError);
+      return;
+    case "pipelines":
+      assertNonEmptyString2(value.pipelineId, `${path} pipelineId`, createError);
+      assertRunStatus(value.runStatus, path, createError);
+      return;
+    default:
+      throw createError(`${path} must select object, link, rule, action, dataset, sync, or pipeline events.`);
+  }
+}
+function assertRunStatus(value, path, createError) {
+  if (typeof value !== "string" || !runStatuses.has(value)) {
+    throw createError(`${path} must select succeeded, failed, or cancelled runs.`);
+  }
+}
+function assertEventConditionShape(value, path, createError) {
+  if (!isRecord2(value))
+    throw createError(`${path} must be an object.`);
+  if (value.kind !== "becomesTrue")
+    throw createError(`${path} kind must be 'becomesTrue'.`);
+  if (value.scope !== "event.object" && value.scope !== "event.link") {
+    throw createError(`${path} scope must be 'event.object' or 'event.link'.`);
+  }
+  assertPredicateShape(value.predicate, { subject: "Schedule", createError });
+}
+function validateEventSchedule(schedule, ontology, options) {
+  const { source } = schedule.trigger;
+  switch (source.topic) {
+    case "objects":
+    case "links": {
+      const objectTypeId = source.objectTypeId;
+      const objectType = objectTypeId ? ontology.getObjectTypeById(objectTypeId) : undefined;
+      if (!objectType) {
+        throw new ScheduleValidationError(`Schedule "${schedule.id}": unknown object type "${objectTypeId}".`);
+      }
+      if (source.topic === "objects")
+        validateObjectSource(schedule, objectType);
+      else
+        validateLinkSource(schedule, objectType);
+      return;
+    }
+    case "rules":
+      validateRegisteredSource(schedule, source.ruleId, options.registeredRuleIds, ruleEventTypes, "rule");
+      return;
+    case "actions":
+      validateRegisteredSource(schedule, source.actionId, options.registeredActionIds, actionEventTypes, "action");
+      return;
+    case "datasets":
+      validateRegisteredSource(schedule, source.datasetId, options.registeredDatasetIds, datasetEventTypes, "dataset");
+      return;
+    case "syncs":
+      validateRegisteredSource(schedule, source.syncId, options.registeredSyncIds, syncEventTypes, "sync");
+      return;
+    case "pipelines":
+      validateRegisteredSource(schedule, source.pipelineId, options.registeredPipelineIds, pipelineEventTypes, "pipeline");
+      return;
+  }
+}
+function validateObjectSource(schedule, objectType) {
+  validateEventTypes(schedule, objectEventTypes, "object");
+  const propertyIds = new Set(objectType.properties.map((property) => property.id));
+  validateSelectorProperty(schedule, propertyIds);
+  const condition = schedule.trigger.condition;
+  if (!condition)
+    return;
+  if (condition.scope !== "event.object") {
+    throw new ScheduleValidationError(`Schedule "${schedule.id}": object event sources can only use event.object conditions.`);
+  }
+  validateConditionPredicate(schedule, propertyIds, condition.predicate);
+}
+function validateLinkSource(schedule, objectType) {
+  validateEventTypes(schedule, linkEventTypes, "link");
+  const source = schedule.trigger.source;
+  const link = objectType.links.find((candidate) => candidate.id === source.linkId);
+  if (!link) {
+    throw new ScheduleValidationError(`Schedule "${schedule.id}": unknown link "${source.linkId}" on object type "${objectType.id}".`);
+  }
+  const propertyIds = new Set((link.properties ?? []).map((property) => property.id));
+  validateSelectorProperty(schedule, propertyIds);
+  const condition = schedule.trigger.condition;
+  if (!condition)
+    return;
+  if (condition.scope !== "event.link") {
+    throw new ScheduleValidationError(`Schedule "${schedule.id}": link event sources can only use event.link conditions.`);
+  }
+  validateConditionPredicate(schedule, propertyIds, condition.predicate, link);
+}
+function validateRegisteredSource(schedule, sourceId, registeredIds, supportedTypes, sourceKind) {
+  validateEventTypes(schedule, supportedTypes, sourceKind);
+  if (!registeredIds?.has(sourceId ?? "")) {
+    throw new ScheduleValidationError(`Schedule "${schedule.id}": unknown ${sourceKind} "${sourceId}".`);
+  }
+  if (schedule.trigger.condition) {
+    throw new ScheduleValidationError(`Schedule "${schedule.id}": ${sourceKind} event sources do not support .where() conditions.`);
+  }
+}
+function validateEventTypes(schedule, supportedTypes, sourceKind) {
+  for (const type of schedule.trigger.source.types ?? []) {
+    if (!supportedTypes.has(type)) {
+      throw new ScheduleValidationError(`Schedule "${schedule.id}": unsupported ${sourceKind} event type "${type}".`);
+    }
+  }
+}
+function validateSelectorProperty(schedule, propertyIds) {
+  const propertyId = schedule.trigger.source.propertyId;
+  if (propertyId !== undefined && !propertyIds.has(propertyId)) {
+    throw new ScheduleValidationError(`Schedule "${schedule.id}": unknown selector property "${propertyId}".`);
+  }
+}
+function validateConditionPredicate(schedule, propertyIds, predicate, link) {
+  if (predicate.kind === "all" || predicate.kind === "any") {
+    if (predicate.predicates.length === 0) {
+      throw new ScheduleValidationError(`Schedule "${schedule.id}": ${predicate.kind} predicate must contain at least one predicate.`);
+    }
+    for (const child of predicate.predicates) {
+      validateConditionPredicate(schedule, propertyIds, child, link);
+    }
+    return;
+  }
+  if (predicate.kind === "not") {
+    validateConditionPredicate(schedule, propertyIds, predicate.predicate, link);
+    return;
+  }
+  if (predicate.kind === "link") {
+    throw new ScheduleValidationError(`Schedule "${schedule.id}": link predicates are not supported in event conditions.`);
+  }
+  if (predicate.kind === "field") {
+    if (!link || !linkIdentityFields.has(predicate.field)) {
+      throw new ScheduleValidationError(`Schedule "${schedule.id}": unsupported event field predicate "${predicate.field}".`);
+    }
+    if (typeof predicate.value !== "string" || !predicate.value.trim()) {
+      throw new ScheduleValidationError(`Schedule "${schedule.id}": event field "${predicate.field}" must compare against a non-empty string.`);
+    }
+    if (predicate.field === "target.objectTypeId") {
+      const targetIds = Array.isArray(link.targetObjectTypeId) ? link.targetObjectTypeId : [link.targetObjectTypeId];
+      if (!targetIds.includes("*") && !targetIds.includes(predicate.value)) {
+        throw new ScheduleValidationError(`Schedule "${schedule.id}": object type "${predicate.value}" is not a target of link "${link.id}".`);
+      }
+    }
+    return;
+  }
+  if (!propertyIds.has(predicate.propertyId)) {
+    const source = schedule.trigger.source;
+    const subject = link ? `link "${link.id}"` : `object type "${source.objectTypeId}"`;
+    throw new ScheduleValidationError(`Schedule "${schedule.id}": unknown property "${predicate.propertyId}" on ${subject}.`);
+  }
+}
+export { assertPredicateShape, createPropertyPredicateBuilder, createLinkPredicateBuilder, allPredicates, anyPredicates, notPredicate, ScheduleValidationError, CronValidationError, createCronFieldMatcher, createCronMatcher, defineSchedule, nextCronOccurrence, eventScheduleSubscribedEventTypes, evaluateEventSchedule, buildEventScheduleContext, isScheduleReference, assertScheduleDefinition, isScheduleDefinition, validateSchedulesAtStartup };
+
+//# debugId=3E911BDE3A5674D064756E2164756E21