@oxygen-agent/cli 1.177.0 → 1.184.3

package/node_modules/@oxygen/shared/dist/budget-scopes.d.ts

@@ -0,0 +1,4 @@
+export declare const PUBLIC_BUDGET_SCOPES: readonly ["org", "table", "workflow_trigger", "monitor"];
+export type PublicBudgetScope = (typeof PUBLIC_BUDGET_SCOPES)[number];
+export declare function formatPublicBudgetScopes(): string;
+export declare const PUBLIC_BUDGET_SCOPE_DESCRIPTION = "Cap scope: org (whole workspace), table (a single table), workflow_trigger (one workflow trigger), or monitor (one scheduled workflow).";

package/node_modules/@oxygen/shared/dist/budget-scopes.js

@@ -0,0 +1,9 @@
+export const PUBLIC_BUDGET_SCOPES = ["org", "table", "workflow_trigger", "monitor"];
+export function formatPublicBudgetScopes() {
+    const scopes = [...PUBLIC_BUDGET_SCOPES];
+    const last = scopes.pop();
+    if (!last)
+        return "";
+    return scopes.length === 0 ? last : `${scopes.join(", ")}, or ${last}`;
+}
+export const PUBLIC_BUDGET_SCOPE_DESCRIPTION = "Cap scope: org (whole workspace), table (a single table), workflow_trigger (one workflow trigger), or monitor (one scheduled workflow).";

package/node_modules/@oxygen/shared/dist/cell-format.d.ts

@@ -39,6 +39,12 @@ export type CellFormatOptions = {
  * escaping, ellipsis budgets) belong outside this function.
  */
 export declare function formatCellForDisplay(value: unknown, column: CellColumnLike | null | undefined, options: CellFormatOptions): string;
+/**
+ * Flatten markdown into a single line of readable plain text — for grid cells,
+ * CLI tables, and MCP previews where the rendered markdown would be noise.
+ * Drops syntax markers; keeps the words.
+ */
+export declare function markdownToPlainText(markdown: string): string;
 /**
  * Decide whether the same value-level + column-level guards used inside
  * `formatCellForDisplay`'s text path should rescue this string. Exposed so

package/node_modules/@oxygen/shared/dist/cell-format.js

@@ -14,6 +14,7 @@
  *     version strings, phone numbers, URLs): {@link rescueNumericText} returns
  *     null for those.
  */
+import { isMarkdownColumnSemantic } from "./select-options.js";
 const DEFAULT_LOCALE = "en-US";
 const INTEGER_RE = /^-?\d{1,15}$/;
 const DECIMAL_RE = /^-?\d{1,15}(?:\.\d{1,9})?$/;
@@ -65,6 +66,11 @@ export function formatCellForDisplay(value, column, options) {
         return formatTimestamp(value, options.surface);
     if (dataType === "numeric")
         return formatNumeric(value, locale, options.surface);
+    // Markdown cells collapse to a single-line plain-text preview for the grid,
+    // CLI, and MCP. The web record view renders the full markdown separately.
+    if (isMarkdownColumnSemantic(column?.semanticType ?? column?.semantic_type)) {
+        return markdownToPlainText(typeof value === "string" ? value : String(value));
+    }
     if (isEnrichmentPayload(value) && columnHasWrapperKind(column)) {
         const wrapped = readEnrichmentValue(value);
         if (wrapped !== undefined) {
@@ -94,6 +100,26 @@ export function formatCellForDisplay(value, column, options) {
     }
     return String(value);
 }
+/**
+ * Flatten markdown into a single line of readable plain text — for grid cells,
+ * CLI tables, and MCP previews where the rendered markdown would be noise.
+ * Drops syntax markers; keeps the words.
+ */
+export function markdownToPlainText(markdown) {
+    return markdown
+        .replace(/```[\s\S]*?```/g, " ") // fenced code blocks
+        .replace(/`([^`]+)`/g, "$1") // inline code
+        .replace(/!\[[^\]]*\]\([^)]*\)/g, " ") // images
+        .replace(/\[([^\]]+)\]\([^)]*\)/g, "$1") // links → label
+        .replace(/^\s{0,3}#{1,6}\s+/gm, "") // headings
+        .replace(/^\s*>\s?/gm, "") // blockquotes
+        .replace(/^\s*[-*+]\s+/gm, "") // bullet markers
+        .replace(/^\s*\d+\.\s+/gm, "") // ordered markers
+        .replace(/^\s*[-*_]{3,}\s*$/gm, " ") // horizontal rules
+        .replace(/[*_~]{1,3}([^*_~]+)[*_~]{1,3}/g, "$1") // bold / italic / strike
+        .replace(/\s+/g, " ")
+        .trim();
+}
 /**
  * Best-effort parse of a string that looks numeric (with or without thousands
  * grouping, with or without dotted IP-style separators) into a finite number.

package/node_modules/@oxygen/shared/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { OXYGEN_MINIMUM_CLI_VERSION, OXYGEN_VERSION } from "./version.js";
 export { WORKFLOW_TRIGGER_AUTO_PAUSE_METADATA_KEYS, clearWorkflowTriggerAutoPauseMetadata, } from "./workflow-trigger-metadata.js";
 export * from "./billing.js";
+export * from "./budget-scopes.js";
 export * from "./cell-format.js";
 export * from "./cli-envelope.js";
 export * from "./cli-result.js";

package/node_modules/@oxygen/shared/dist/index.js

@@ -1,6 +1,7 @@
 export { OXYGEN_MINIMUM_CLI_VERSION, OXYGEN_VERSION } from "./version.js";
 export { WORKFLOW_TRIGGER_AUTO_PAUSE_METADATA_KEYS, clearWorkflowTriggerAutoPauseMetadata, } from "./workflow-trigger-metadata.js";
 export * from "./billing.js";
+export * from "./budget-scopes.js";
 export * from "./cell-format.js";
 export * from "./cli-envelope.js";
 export * from "./cli-result.js";

package/node_modules/@oxygen/shared/dist/select-options.d.ts

@@ -8,6 +8,13 @@ export type SelectColumnSemantic = (typeof SELECT_COLUMN_SEMANTICS)[number];
 export declare function isSelectColumnSemantic(semanticType: string | null | undefined): boolean;
 export declare function isMultiSelectSemantic(semanticType: string | null | undefined): boolean;
 export declare function isStatusSemantic(semanticType: string | null | undefined): boolean;
+/**
+ * `markdown` is a semantic over the `text` dataType (storage stays text): the
+ * cell holds a long markdown body that renders as a "page" in the record view
+ * and as a compact plain-text preview in the grid. Notes, summaries, and call
+ * transcripts all use this.
+ */
+export declare function isMarkdownColumnSemantic(semanticType: string | null | undefined): boolean;
 export type SelectOption = {
     id: string;
     value: string;

package/node_modules/@oxygen/shared/dist/select-options.js

@@ -46,6 +46,15 @@ export function isMultiSelectSemantic(semanticType) {
 export function isStatusSemantic(semanticType) {
     return semanticType === "status";
 }
+/**
+ * `markdown` is a semantic over the `text` dataType (storage stays text): the
+ * cell holds a long markdown body that renders as a "page" in the record view
+ * and as a compact plain-text preview in the grid. Notes, summaries, and call
+ * transcripts all use this.
+ */
+export function isMarkdownColumnSemantic(semanticType) {
+    return semanticType === "markdown";
+}
 const MAX_OPTIONS = 200;
 // Normalize a raw options array (from a column `definition.options`, CLI/MCP, or
 // the editor) into canonical SelectOptions: dedupe by value, default colors,

package/node_modules/@oxygen/shared/dist/sequences.d.ts

@@ -35,8 +35,12 @@ export type SequenceChannel = (typeof SEQUENCE_CHANNELS)[number];
  * a signal — it's resolved on demand by the dispatcher via a connection branch,
  * `condition: "already_connected"`.)
  */
-export declare const SEQUENCE_SIGNALS: readonly ["linkedin_connected", "linkedin_replied", "email_sent", "email_opened", "email_clicked", "email_replied", "email_bounced"];
+export declare const SEQUENCE_SIGNALS: readonly ["linkedin_connected", "linkedin_replied", "email_sent", "email_opened", "email_clicked", "email_replied", "email_bounced", "company_hiring", "company_raised_funds", "job_change", "new_hire", "web_visit", "intent"];
 export type SequenceSignal = (typeof SEQUENCE_SIGNALS)[number];
+/** External GTM signals (the non-engagement subset of SEQUENCE_SIGNALS). */
+export declare const SEQUENCE_EXTERNAL_SIGNALS: readonly ["company_hiring", "company_raised_funds", "job_change", "new_hire", "web_visit", "intent"];
+export type SequenceExternalSignal = (typeof SEQUENCE_EXTERNAL_SIGNALS)[number];
+export declare function isExternalSequenceSignal(value: string): value is SequenceExternalSignal;
 /**
  * row_values keys an enrollment's email may live under, in send-precedence order.
  * The dispatcher picks the FIRST present key as the recipient address; the
@@ -44,6 +48,31 @@ export type SequenceSignal = (typeof SEQUENCE_SIGNALS)[number];
  * Single source of truth so the send path and the lookup path can't drift.
  */
 export declare const SEQUENCE_EMAIL_COLUMN_KEYS: readonly ["email", "email_address", "work_email", "primary_email", "Email"];
+/**
+ * A per-step / per-sequence send window. `days` are ISO weekdays (1=Mon … 7=Sun)
+ * on which sends are allowed; `start`/`end` are "HH:MM" local times. The window
+ * is evaluated in `timezone` by default; when `timezone_mode === "recipient"`
+ * the dispatcher reads the lead's IANA timezone from
+ * `recipient_timezone_column` in the enrolled row (falling back to `timezone`
+ * when the column is missing/invalid), so a 9-5 window lands in each
+ * recipient's local morning rather than the operator's. Unlike the LinkedIn
+ * per-account working hours, this gate also governs the native + Instantly email
+ * track (which otherwise has no send window at all).
+ */
+export type SequenceSendWindow = {
+    timezone: string;
+    /** Allowed ISO weekdays, 1=Mon … 7=Sun. Empty/absent → all days. */
+    days?: number[];
+    /** "HH:MM" inclusive start of the daily window. */
+    start: string;
+    /** "HH:MM" exclusive end of the daily window. */
+    end: string;
+    timezone_mode?: "fixed" | "recipient";
+    /** row_values key holding the lead's IANA timezone (timezone_mode="recipient"). */
+    recipient_timezone_column?: string;
+};
+/** Base content + up to this many alternates per A/B step (base counts as variant "a"). */
+export declare const MAX_STEP_VARIANTS = 5;
 export declare const SEQUENCE_STEP_KINDS: readonly ["visit_profile", "invite", "wait_for_connection", "message", "inmail", "email_send", "email_reply", "email_enroll", "email_move", "email_stop", "wait", "wait_for_signal", "branch", "stop"];
 export type SequenceStepKind = (typeof SEQUENCE_STEP_KINDS)[number];
 export type SequenceLinkedInVisitProfileStep = {
@@ -70,6 +99,10 @@ export type SequenceLinkedInMessageStep = {
     channel: "linkedin";
     kind: "message";
     template: string;
+    /** A/B alternates. Each overrides the base `template`; the base is variant "a". */
+    variants?: {
+        template?: string;
+    }[];
 };
 export type SequenceLinkedInInMailStep = {
     id: string;
@@ -77,6 +110,11 @@ export type SequenceLinkedInInMailStep = {
     kind: "inmail";
     subject_template: string;
     template: string;
+    /** A/B alternates over subject/body; the base is variant "a". */
+    variants?: {
+        subject_template?: string;
+        template?: string;
+    }[];
 };
 export type SequenceEmailEnrollStep = {
     id: string;
@@ -109,6 +147,13 @@ export type SequenceEmailSendStep = {
     subject_template: string;
     /** Body. Supports {{column}} interpolation. */
     body_template: string;
+    /** A/B alternates over subject/body; the base is variant "a". */
+    variants?: {
+        subject_template?: string;
+        body_template?: string;
+    }[];
+    /** Per-step send window (overrides the sequence-level email_send_window). */
+    send_window?: SequenceSendWindow;
 };
 /** Threaded follow-up in the same email thread as the lead's prior email_send. */
 export type SequenceEmailReplyStep = {
@@ -117,6 +162,12 @@ export type SequenceEmailReplyStep = {
     kind: "email_reply";
     /** Reply body. Supports {{column}} interpolation. */
     body_template: string;
+    /** A/B alternates over the reply body; the base is variant "a". */
+    variants?: {
+        body_template?: string;
+    }[];
+    /** Per-step send window (overrides the sequence-level email_send_window). */
+    send_window?: SequenceSendWindow;
 };
 export type SequenceWaitStep = {
     id: string;
@@ -236,3 +287,42 @@ export declare function sequenceTemplateVariables(definition: SequenceDefinition
  * Used by the dispatch planner for branch steps. Pure.
  */
 export declare function evaluateSequenceCondition(condition: SequenceSignalCondition, firedSignals: Iterable<string>): boolean;
+/** Variant label for an index: 0 → "a" (the base step), 1 → "b", … */
+export declare function sequenceVariantLabel(index: number): string;
+type StepVariantContent = Record<string, string>;
+/**
+ * The ordered list of fully-resolved content variants for a step: index 0 is the
+ * base step ("a"); each declared alternate is merged OVER the base (so a variant
+ * that sets only `subject_template` keeps the base body). Returns [] for steps
+ * with no copy.
+ */
+export declare function sequenceStepVariantContents(step: SequenceStep): StepVariantContent[];
+/** Number of A/B variants a step carries (1 = no test). */
+export declare function sequenceStepVariantCount(step: SequenceStep): number;
+/**
+ * Deterministically assign one variant to an enrollment for a step. The same
+ * (key, step) always resolves to the same variant — replayable, evenly
+ * distributed, and previewable in a dry run before any send. `key` is the
+ * enrollment id.
+ */
+export declare function selectStepVariant(step: SequenceStep, key: string): {
+    variantId: string;
+    index: number;
+    content: StepVariantContent;
+};
+/**
+ * Resolve which IANA timezone a send window evaluates in for a given lead row.
+ * "recipient" mode reads the lead's tz from `recipient_timezone_column`, falling
+ * back to the window's fixed `timezone` when the column is absent/blank.
+ */
+export declare function resolveSendWindowTimezone(window: SequenceSendWindow, rowValues: Record<string, unknown> | null | undefined): string;
+/**
+ * Is `now` inside the send window, evaluated in `timezone` (already resolved for
+ * recipient mode via resolveSendWindowTimezone)? Pure; Intl only
+ * (client-bundle-safe). An unresolvable timezone or malformed window fails OPEN
+ * (returns true) so a bad tz never permanently strands an enrollment — the hard
+ * send caps still bound it. A window with no `days` allows every weekday;
+ * start>end wraps past midnight.
+ */
+export declare function isWithinSendWindow(window: SequenceSendWindow, now: Date, timezone?: string): boolean;
+export {};

package/node_modules/@oxygen/shared/dist/sequences.js

@@ -44,7 +44,32 @@ export const SEQUENCE_SIGNALS = [
     "email_clicked",
     "email_replied",
     "email_bounced",
+    // External GTM signals — recorded onto an enrollment by an Oxygen monitor,
+    // enrichment column, or the published `sequences signal` callable (NOT a
+    // provider webhook). branch / wait_for_signal consume these identically to
+    // engagement signals, so a funding/hiring/job-change event can pause,
+    // re-target, or advance a *running* sequence. The lookup that produced the
+    // signal is the metered+approved step; recording the signal is free internal
+    // state and never itself sends.
+    "company_hiring",
+    "company_raised_funds",
+    "job_change",
+    "new_hire",
+    "web_visit",
+    "intent",
 ];
+/** External GTM signals (the non-engagement subset of SEQUENCE_SIGNALS). */
+export const SEQUENCE_EXTERNAL_SIGNALS = [
+    "company_hiring",
+    "company_raised_funds",
+    "job_change",
+    "new_hire",
+    "web_visit",
+    "intent",
+];
+export function isExternalSequenceSignal(value) {
+    return SEQUENCE_EXTERNAL_SIGNALS.includes(value);
+}
 /**
  * row_values keys an enrollment's email may live under, in send-precedence order.
  * The dispatcher picks the FIRST present key as the recipient address; the
@@ -52,6 +77,8 @@ export const SEQUENCE_SIGNALS = [
  * Single source of truth so the send path and the lookup path can't drift.
  */
 export const SEQUENCE_EMAIL_COLUMN_KEYS = ["email", "email_address", "work_email", "primary_email", "Email"];
+/** Base content + up to this many alternates per A/B step (base counts as variant "a"). */
+export const MAX_STEP_VARIANTS = 5;
 export const SEQUENCE_STEP_KINDS = [
     // linkedin channel (native dispatch)
     "visit_profile",
@@ -216,12 +243,20 @@ raw, index, options, issues) {
         }
         case "message": {
             const template = requiredTemplate(raw.template, `${path}.template`, issues);
-            return { id, channel: "linkedin", kind: "message", template: template ?? "" };
+            const variants = normalizeVariants(raw.variants, `${path}.variants`, ["template"], issues);
+            return {
+                id, channel: "linkedin", kind: "message", template: template ?? "",
+                ...(variants ? { variants: variants } : {}),
+            };
         }
         case "inmail": {
             const subject = requiredTemplate(raw.subject_template, `${path}.subject_template`, issues);
             const template = requiredTemplate(raw.template, `${path}.template`, issues);
-            return { id, channel: "linkedin", kind: "inmail", subject_template: subject ?? "", template: template ?? "" };
+            const variants = normalizeVariants(raw.variants, `${path}.variants`, ["subject_template", "template"], issues);
+            return {
+                id, channel: "linkedin", kind: "inmail", subject_template: subject ?? "", template: template ?? "",
+                ...(variants ? { variants: variants } : {}),
+            };
         }
         case "email_enroll": {
             const subsequenceId = optionalString(raw.subsequence_id, `${path}.subsequence_id`, issues);
@@ -239,11 +274,23 @@ raw, index, options, issues) {
         case "email_send": {
             const subject = requiredTemplate(raw.subject_template, `${path}.subject_template`, issues);
             const body = requiredTemplate(raw.body_template, `${path}.body_template`, issues);
-            return { id, channel: "email", kind: "email_send", subject_template: subject ?? "", body_template: body ?? "" };
+            const variants = normalizeVariants(raw.variants, `${path}.variants`, ["subject_template", "body_template"], issues);
+            const sendWindow = normalizeSendWindow(raw.send_window, `${path}.send_window`, issues);
+            return {
+                id, channel: "email", kind: "email_send", subject_template: subject ?? "", body_template: body ?? "",
+                ...(variants ? { variants: variants } : {}),
+                ...(sendWindow ? { send_window: sendWindow } : {}),
+            };
         }
         case "email_reply": {
             const body = requiredTemplate(raw.body_template, `${path}.body_template`, issues);
-            return { id, channel: "email", kind: "email_reply", body_template: body ?? "" };
+            const variants = normalizeVariants(raw.variants, `${path}.variants`, ["body_template"], issues);
+            const sendWindow = normalizeSendWindow(raw.send_window, `${path}.send_window`, issues);
+            return {
+                id, channel: "email", kind: "email_reply", body_template: body ?? "",
+                ...(variants ? { variants: variants } : {}),
+                ...(sendWindow ? { send_window: sendWindow } : {}),
+            };
         }
         case "email_stop":
             return { id, channel: "email", kind: "email_stop" };
@@ -465,18 +512,12 @@ export function sequenceTemplateVariables(definition) {
     for (const step of definition.steps) {
         if (step.kind === "invite")
             scan(step.note_template);
-        if (step.kind === "message")
-            scan(step.template);
-        if (step.kind === "inmail") {
-            scan(step.subject_template);
-            scan(step.template);
+        // Scan base + every A/B variant's copy so a column referenced only in a
+        // variant still surfaces in the start preview's variable-resolution check.
+        for (const content of sequenceStepVariantContents(step)) {
+            for (const value of Object.values(content))
+                scan(value);
         }
-        if (step.kind === "email_send") {
-            scan(step.subject_template);
-            scan(step.body_template);
-        }
-        if (step.kind === "email_reply")
-            scan(step.body_template);
     }
     return [...vars];
 }
@@ -496,6 +537,230 @@ export function evaluateSequenceCondition(condition, firedSignals) {
         return condition.any.some((c) => evaluateSequenceCondition(c, fired));
     return !evaluateSequenceCondition(condition.not, fired);
 }
+// ===== A/B variants =====
+const VARIANT_ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+/** Variant label for an index: 0 → "a" (the base step), 1 → "b", … */
+export function sequenceVariantLabel(index) {
+    return VARIANT_ALPHABET[index % VARIANT_ALPHABET.length] ?? "a";
+}
+/** Deterministic, replayable FNV-1a hash → uint32. Stable across processes. */
+function hashVariantKey(value) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < value.length; i += 1) {
+        hash ^= value.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}
+function baseVariantContent(step) {
+    switch (step.kind) {
+        case "email_send": return { subject_template: step.subject_template, body_template: step.body_template };
+        case "email_reply": return { body_template: step.body_template };
+        case "message": return { template: step.template };
+        case "inmail": return { subject_template: step.subject_template, template: step.template };
+        default: return null;
+    }
+}
+/**
+ * The ordered list of fully-resolved content variants for a step: index 0 is the
+ * base step ("a"); each declared alternate is merged OVER the base (so a variant
+ * that sets only `subject_template` keeps the base body). Returns [] for steps
+ * with no copy.
+ */
+export function sequenceStepVariantContents(step) {
+    const base = baseVariantContent(step);
+    if (!base)
+        return [];
+    const variants = step.variants;
+    if (!variants || variants.length === 0)
+        return [base];
+    return [base, ...variants.map((variant) => ({ ...base, ...variant }))];
+}
+/** Number of A/B variants a step carries (1 = no test). */
+export function sequenceStepVariantCount(step) {
+    return sequenceStepVariantContents(step).length;
+}
+/**
+ * Deterministically assign one variant to an enrollment for a step. The same
+ * (key, step) always resolves to the same variant — replayable, evenly
+ * distributed, and previewable in a dry run before any send. `key` is the
+ * enrollment id.
+ */
+export function selectStepVariant(step, key) {
+    const contents = sequenceStepVariantContents(step);
+    if (contents.length === 0)
+        return { variantId: "a", index: 0, content: {} };
+    const index = contents.length > 1 ? hashVariantKey(`${key}:${step.id}`) % contents.length : 0;
+    const content = contents[index] ?? contents[0] ?? {};
+    return { variantId: sequenceVariantLabel(index), index, content };
+}
+// ===== Send windows =====
+function hhmmToMinutes(value) {
+    const match = /^(\d{1,2}):(\d{2})$/.exec(value.trim());
+    if (!match)
+        return null;
+    const hours = Number(match[1]);
+    const minutes = Number(match[2]);
+    if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59)
+        return null;
+    return hours * 60 + minutes;
+}
+const ISO_WEEKDAY = { Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6, Sun: 7 };
+/**
+ * Resolve which IANA timezone a send window evaluates in for a given lead row.
+ * "recipient" mode reads the lead's tz from `recipient_timezone_column`, falling
+ * back to the window's fixed `timezone` when the column is absent/blank.
+ */
+export function resolveSendWindowTimezone(window, rowValues) {
+    if (window.timezone_mode === "recipient" && window.recipient_timezone_column) {
+        const raw = rowValues?.[window.recipient_timezone_column];
+        if (typeof raw === "string" && raw.trim())
+            return raw.trim();
+    }
+    return window.timezone;
+}
+/**
+ * Is `now` inside the send window, evaluated in `timezone` (already resolved for
+ * recipient mode via resolveSendWindowTimezone)? Pure; Intl only
+ * (client-bundle-safe). An unresolvable timezone or malformed window fails OPEN
+ * (returns true) so a bad tz never permanently strands an enrollment — the hard
+ * send caps still bound it. A window with no `days` allows every weekday;
+ * start>end wraps past midnight.
+ */
+export function isWithinSendWindow(window, now, timezone) {
+    const tz = timezone && timezone.trim() ? timezone.trim() : window.timezone;
+    const parts = tzParts(now, tz) ?? tzParts(now, window.timezone) ?? tzParts(now, "UTC");
+    if (!parts)
+        return true; // unresolvable tz → fail open (caps still apply)
+    const startM = hhmmToMinutes(window.start);
+    const endM = hhmmToMinutes(window.end);
+    if (startM === null || endM === null)
+        return true; // malformed window → fail open
+    if (window.days && window.days.length > 0 && !window.days.includes(parts.isoWeekday))
+        return false;
+    if (startM === endM)
+        return false; // empty window
+    const minutes = parts.hour * 60 + parts.minute;
+    return startM < endM ? minutes >= startM && minutes < endM : minutes >= startM || minutes < endM;
+}
+function tzParts(now, tz) {
+    try {
+        const formatted = new Intl.DateTimeFormat("en-US", {
+            timeZone: tz, hour12: false, weekday: "short", hour: "2-digit", minute: "2-digit",
+        }).formatToParts(now);
+        let hour = 0;
+        let minute = 0;
+        let weekday = "Mon";
+        for (const part of formatted) {
+            if (part.type === "hour")
+                hour = Number(part.value) % 24;
+            else if (part.type === "minute")
+                minute = Number(part.value);
+            else if (part.type === "weekday")
+                weekday = part.value;
+        }
+        return { hour, minute, isoWeekday: ISO_WEEKDAY[weekday] ?? 1 };
+    }
+    catch {
+        return null;
+    }
+}
+// ===== Validation helpers for variants + send windows =====
+function normalizeVariants(raw, path, fields, issues) {
+    if (raw === undefined || raw === null)
+        return undefined;
+    if (!Array.isArray(raw)) {
+        issues.push({ path, message: "variants must be an array." });
+        return undefined;
+    }
+    if (raw.length === 0)
+        return undefined;
+    if (raw.length > MAX_STEP_VARIANTS - 1) {
+        issues.push({ path, message: `at most ${MAX_STEP_VARIANTS - 1} alternate variants (the base step is variant "a").` });
+    }
+    const out = [];
+    raw.slice(0, MAX_STEP_VARIANTS - 1).forEach((entry, i) => {
+        if (!isRecord(entry)) {
+            issues.push({ path: `${path}[${i}]`, message: "each variant must be an object." });
+            return;
+        }
+        const variant = {};
+        for (const field of fields) {
+            const value = entry[field];
+            if (value === undefined || value === null)
+                continue;
+            const template = requiredTemplate(value, `${path}[${i}].${field}`, issues);
+            if (template !== undefined)
+                variant[field] = template;
+        }
+        if (Object.keys(variant).length === 0) {
+            issues.push({ path: `${path}[${i}]`, message: `a variant must override at least one of: ${fields.join(", ")}.` });
+        }
+        else {
+            out.push(variant);
+        }
+    });
+    return out.length > 0 ? out : undefined;
+}
+function normalizeSendWindow(raw, path, issues) {
+    if (raw === undefined || raw === null)
+        return undefined;
+    if (!isRecord(raw)) {
+        issues.push({ path, message: "send_window must be an object." });
+        return undefined;
+    }
+    const timezone = typeof raw.timezone === "string" && raw.timezone.trim() ? raw.timezone.trim() : undefined;
+    if (!timezone)
+        issues.push({ path: `${path}.timezone`, message: "timezone (IANA, e.g. America/New_York) is required." });
+    const start = normalizeHhmm(raw.start, `${path}.start`, issues);
+    const end = normalizeHhmm(raw.end, `${path}.end`, issues);
+    const days = normalizeWeekdays(raw.days, `${path}.days`, issues);
+    const mode = raw.timezone_mode === "recipient" ? "recipient" : "fixed";
+    const column = mode === "recipient"
+        ? optionalString(raw.recipient_timezone_column, `${path}.recipient_timezone_column`, issues)
+        : undefined;
+    if (mode === "recipient" && !column) {
+        issues.push({ path: `${path}.recipient_timezone_column`, message: 'recipient_timezone_column is required when timezone_mode is "recipient".' });
+    }
+    return {
+        timezone: timezone ?? "UTC",
+        ...(days ? { days } : {}),
+        start: start ?? "09:00",
+        end: end ?? "17:00",
+        timezone_mode: mode,
+        ...(column ? { recipient_timezone_column: column } : {}),
+    };
+}
+function normalizeHhmm(value, path, issues) {
+    if (value === undefined || value === null) {
+        issues.push({ path, message: 'is required as "HH:MM".' });
+        return undefined;
+    }
+    if (typeof value !== "string" || hhmmToMinutes(value) === null) {
+        issues.push({ path, message: 'must be "HH:MM" (00:00–23:59).' });
+        return undefined;
+    }
+    return value.trim();
+}
+function normalizeWeekdays(value, path, issues) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!Array.isArray(value)) {
+        issues.push({ path, message: "days must be an array of ISO weekdays (1=Mon … 7=Sun)." });
+        return undefined;
+    }
+    const out = [];
+    for (const entry of value) {
+        const num = Number(entry);
+        if (!Number.isInteger(num) || num < 1 || num > 7) {
+            issues.push({ path, message: "each day must be an integer 1–7 (1=Mon … 7=Sun)." });
+            continue;
+        }
+        if (!out.includes(num))
+            out.push(num);
+    }
+    return out.length > 0 ? out.sort((a, b) => a - b) : undefined;
+}
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }

package/node_modules/@oxygen/shared/dist/signup-lead-webhook.d.ts

@@ -0,0 +1,39 @@
+/** Request timeout shared by the direct emit and the durable worker retry. */
+export declare const SIGNUP_LEAD_WEBHOOK_TIMEOUT_MS = 10000;
+/**
+ * Classification of a signup-lead webhook target URL. Drives which internal
+ * Oxygen secret header (if any) is attached, and doubles as a log field on the
+ * emit path.
+ */
+export type SignupLeadWebhookTarget = "missing" | "external" | "oxygen_table_webhook" | "oxygen_workflow_webhook" | "oxygen_internal" | "invalid_url";
+/** True for the canonical Oxygen apex domain and its subdomains only. */
+export declare function isOxygenHostname(hostname: string): boolean;
+/**
+ * Classify a webhook target URL so the caller can decide whether to attach the
+ * internal table/workflow secret. Only genuine oxygen-agent.com hosts receive
+ * internal secrets; external hosts with Oxygen-looking paths are "external" and
+ * must never be trusted with the internal webhook secret.
+ */
+export declare function classifySignupLeadWebhookTarget(value: string | null | undefined): SignupLeadWebhookTarget;
+/** HMAC-SHA256 hex digest of the request body keyed by the webhook secret. */
+export declare function signSignupLeadWebhookBody(secret: string, body: string): string;
+export type BuildSignupLeadWebhookHeadersInput = {
+    /** The destination URL — classified to decide the internal secret header. */
+    webhookUrl: string;
+    /** The flattened signup-lead payload (already serialized into `body`). */
+    payload: Record<string, unknown>;
+    /** The exact serialized request body the signature is computed over. */
+    body: string;
+    /** The shared webhook secret, or null/undefined to send the request unsigned. */
+    secret: string | null | undefined;
+    /** Injectable clock for the signature timestamp (defaults to the current time). */
+    now?: Date;
+};
+/**
+ * Build the complete header set for a signup-lead webhook request. Produces
+ * identical output for the request-time emit and the durable worker retry so
+ * the two transports stay in lockstep. Header values fall back to safe defaults
+ * for the worker's untyped (DB-sourced) payload; for the web emitter's typed
+ * payload the fallbacks are no-ops.
+ */
+export declare function buildSignupLeadWebhookHeaders(input: BuildSignupLeadWebhookHeadersInput): Record<string, string>;