@oxygen-agent/cli 1.246.0 → 1.256.13

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

@@ -0,0 +1,6 @@
+export declare const AGENCY_DIRECTORY_SERVICES: readonly ["Cold Email", "LinkedIn Outbound", "Lead Sourcing & Enrichment", "GTM Engineering", "Outreach Strategy & Consulting", "Copywriting & Messaging", "Deliverability & Infrastructure", "RevOps & CRM", "Campaign Management", "Training & Coaching"];
+export type AgencyDirectoryService = (typeof AGENCY_DIRECTORY_SERVICES)[number];
+export declare const AGENCY_DIRECTORY_REGIONS: readonly ["North America", "LATAM", "UK & Ireland", "DACH", "Nordics", "Europe", "APAC", "Middle East & Africa", "Global"];
+export type AgencyDirectoryRegion = (typeof AGENCY_DIRECTORY_REGIONS)[number];
+/** Case-insensitive lookup of a facet value's canonical casing. */
+export declare function canonicalDirectoryFacetValue(options: readonly string[], value: string): string | null;

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

@@ -0,0 +1,34 @@
+// Curated facet options for the public agency directory. Listings multi-select
+// from these fixed sets (validated server-side) so the public /agencies
+// filters never fragment into free-text variants. Modeled on Instantly's and
+// SmartLead's fixed service taxonomies, tuned to OXYGEN's GTM-engineering ICP.
+export const AGENCY_DIRECTORY_SERVICES = [
+    "Cold Email",
+    "LinkedIn Outbound",
+    "Lead Sourcing & Enrichment",
+    "GTM Engineering",
+    "Outreach Strategy & Consulting",
+    "Copywriting & Messaging",
+    "Deliverability & Infrastructure",
+    "RevOps & CRM",
+    "Campaign Management",
+    "Training & Coaching",
+];
+export const AGENCY_DIRECTORY_REGIONS = [
+    "North America",
+    "LATAM",
+    "UK & Ireland",
+    "DACH",
+    "Nordics",
+    "Europe",
+    "APAC",
+    "Middle East & Africa",
+    "Global",
+];
+/** Case-insensitive lookup of a facet value's canonical casing. */
+export function canonicalDirectoryFacetValue(options, value) {
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    return options.find((option) => option.toLowerCase() === normalized) ?? null;
+}

package/node_modules/@oxygen/shared/dist/email-tracking-token.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Signed token for native open/click tracking on cold email. The dispatcher MINTS
+ * the token at send time (one per tracked action) and bakes it into a tracking
+ * pixel URL (open) or a rewritten link (click); the public /api/t/* routes VERIFY
+ * it. The token is the ONLY credential those anonymous endpoints trust, so it
+ * binds org + action_id + kind — and, for a click, the SHA-256 hash of the exact
+ * destination URL, so a validly-signed click token can never be turned into an
+ * open-redirect to an arbitrary host: the route recomputes the hash of the `u`
+ * query param and refuses a mismatch.
+ *
+ * Kill switch / fail-closed: the signing key (EMAIL_TRACKING_SECRET, Doppler
+ * oxygen-shared) is read by both the dispatcher (mint) and web (verify). When it
+ * is UNSET, injection is DISABLED (no pixel, no link rewrite) and the public
+ * routes serve a benign 1x1 gif / plain redirect WITHOUT recording — never a
+ * crash, never a silent paid call.
+ *
+ * Layering mirrors email-unsubscribe-token.ts: pure crypto in @oxygen/shared so
+ * the worker/integrations mint path and the web verify route share one
+ * implementation, with no env policy baked in (the caller decides what null means).
+ */
+export type EmailTrackingKind = "open" | "click";
+export type EmailTrackingTokenPayload = {
+    /** Schema version; only v1 is accepted. */
+    v: 1;
+    /** Organization id (also the tenant the public route resolves + records into). */
+    org: string;
+    /** The action id the send belongs to — provenance for the recorded event. */
+    act: string;
+    /** open (pixel) or click (rewritten link). */
+    kind: EmailTrackingKind;
+    /** Click only: SHA-256 hex of the destination URL the token authorizes. */
+    uh?: string;
+    /** Sequence id, for provenance / signal advance. */
+    seq?: string;
+    /** Enrollment id, so open/click advances the exact journey. */
+    enr?: string;
+    /** Issued-at (epoch ms), recorded as provenance. */
+    iat: number;
+};
+type EnvLike = Record<string, string | undefined>;
+/** SHA-256 hex of a destination URL — the value bound into a click token's `uh`. */
+export declare function hashTrackingUrl(url: string): string;
+/**
+ * Sign a payload into `<base64url(json)>.<base64url(hmac-sha256)>`. The HMAC is
+ * computed over the encoded body, so any tamper invalidates the signature.
+ */
+export declare function signEmailTrackingToken(payload: EmailTrackingTokenPayload, secret: string): string;
+/**
+ * Verify a token's signature (constant-time) and shape. Returns the payload only
+ * when the signature matches AND it is a well-formed v1 payload; null on ANY
+ * problem (bad shape, blank/wrong secret, tampered body). Pure: the route maps
+ * null -> benign gif / plain redirect with no recording.
+ */
+export declare function verifyEmailTrackingToken(token: string, secret: string): EmailTrackingTokenPayload | null;
+/**
+ * Verify a click token AND that the supplied destination URL is the one it
+ * authorizes (constant-time hash compare). Returns the payload only when both the
+ * signature and the url-hash match; null otherwise. This is what stops the click
+ * route from being an open redirect — only the exact signed URL is honored.
+ */
+export declare function verifyEmailClickToken(token: string, destinationUrl: string, secret: string): EmailTrackingTokenPayload | null;
+/**
+ * The HMAC signing secret for tracking tokens, or null when unset. This is the
+ * kill switch: null means "tracking disabled" everywhere — the dispatcher skips
+ * injection and the public routes serve a benign response without recording.
+ */
+export declare function emailTrackingSigningSecret(env?: EnvLike): string | null;
+/**
+ * The public app base URL tracking links point at, trailing slash stripped.
+ * Prefers NEXT_PUBLIC_APP_URL, then OXYGEN_APP_URL, then the prod host. (A
+ * verified per-org tracking domain is used at send time when present; this is the
+ * fallback the token routes are always reachable at.)
+ */
+export declare function emailTrackingAppBaseUrl(env?: EnvLike): string;
+/** The open-pixel URL for a signed token: `<base>/api/t/o/<token>`. */
+export declare function buildOpenPixelUrl(token: string, baseUrl: string): string;
+/**
+ * The click-tracking URL for a signed token + destination: the destination rides
+ * in the `u` query param (the route recomputes its hash against the token's `uh`).
+ */
+export declare function buildClickTrackingUrl(token: string, destinationUrl: string, baseUrl: string): string;
+export {};

package/node_modules/@oxygen/shared/dist/email-tracking-token.js

@@ -0,0 +1,130 @@
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
+function base64urlEncode(value) {
+    return Buffer.from(value, "utf8").toString("base64url");
+}
+/** SHA-256 hex of a destination URL — the value bound into a click token's `uh`. */
+export function hashTrackingUrl(url) {
+    return createHash("sha256").update(url, "utf8").digest("hex");
+}
+/**
+ * Sign a payload into `<base64url(json)>.<base64url(hmac-sha256)>`. The HMAC is
+ * computed over the encoded body, so any tamper invalidates the signature.
+ */
+export function signEmailTrackingToken(payload, secret) {
+    const body = base64urlEncode(JSON.stringify(payload));
+    const signature = createHmac("sha256", secret).update(body).digest("base64url");
+    return `${body}.${signature}`;
+}
+/** Constant-time HMAC-SHA256 check; false on any error (bad base64, length mismatch). */
+function verifySignature(body, providedSig, secret) {
+    const expected = createHmac("sha256", secret).update(body).digest();
+    let provided;
+    try {
+        provided = Buffer.from(providedSig, "base64url");
+    }
+    catch {
+        return false;
+    }
+    return provided.length === expected.length && timingSafeEqual(provided, expected);
+}
+/** Decode + validate the base64url body; typed payload or null on any problem. */
+function parseTokenPayload(body) {
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const candidate = parsed;
+    if (candidate.v !== 1)
+        return null;
+    const org = typeof candidate.org === "string" ? candidate.org.trim() : "";
+    const act = typeof candidate.act === "string" ? candidate.act.trim() : "";
+    const kind = candidate.kind === "open" || candidate.kind === "click" ? candidate.kind : null;
+    if (!org || !act || !kind)
+        return null;
+    // A click token MUST bind a url hash; an open token must NOT (so a click token
+    // can't be replayed against the open route, or vice versa, to skip the check).
+    const uh = typeof candidate.uh === "string" && candidate.uh ? candidate.uh : undefined;
+    if (kind === "click" && !uh)
+        return null;
+    if (kind === "open" && uh)
+        return null;
+    return {
+        v: 1,
+        org,
+        act,
+        kind,
+        ...(uh ? { uh } : {}),
+        ...(typeof candidate.seq === "string" && candidate.seq ? { seq: candidate.seq } : {}),
+        ...(typeof candidate.enr === "string" && candidate.enr ? { enr: candidate.enr } : {}),
+        iat: typeof candidate.iat === "number" && Number.isFinite(candidate.iat) ? candidate.iat : 0,
+    };
+}
+/**
+ * Verify a token's signature (constant-time) and shape. Returns the payload only
+ * when the signature matches AND it is a well-formed v1 payload; null on ANY
+ * problem (bad shape, blank/wrong secret, tampered body). Pure: the route maps
+ * null -> benign gif / plain redirect with no recording.
+ */
+export function verifyEmailTrackingToken(token, secret) {
+    if (typeof token !== "string" || typeof secret !== "string" || !secret)
+        return null;
+    const dot = token.indexOf(".");
+    if (dot <= 0 || dot === token.length - 1)
+        return null;
+    const body = token.slice(0, dot);
+    const providedSig = token.slice(dot + 1);
+    if (!verifySignature(body, providedSig, secret))
+        return null;
+    return parseTokenPayload(body);
+}
+/**
+ * Verify a click token AND that the supplied destination URL is the one it
+ * authorizes (constant-time hash compare). Returns the payload only when both the
+ * signature and the url-hash match; null otherwise. This is what stops the click
+ * route from being an open redirect — only the exact signed URL is honored.
+ */
+export function verifyEmailClickToken(token, destinationUrl, secret) {
+    const payload = verifyEmailTrackingToken(token, secret);
+    if (!payload || payload.kind !== "click" || !payload.uh)
+        return null;
+    const expected = Buffer.from(payload.uh, "utf8");
+    const actual = Buffer.from(hashTrackingUrl(destinationUrl), "utf8");
+    if (expected.length !== actual.length || !timingSafeEqual(expected, actual))
+        return null;
+    return payload;
+}
+/**
+ * The HMAC signing secret for tracking tokens, or null when unset. This is the
+ * kill switch: null means "tracking disabled" everywhere — the dispatcher skips
+ * injection and the public routes serve a benign response without recording.
+ */
+export function emailTrackingSigningSecret(env = process.env) {
+    const secret = env.EMAIL_TRACKING_SECRET?.trim();
+    return secret ? secret : null;
+}
+/**
+ * The public app base URL tracking links point at, trailing slash stripped.
+ * Prefers NEXT_PUBLIC_APP_URL, then OXYGEN_APP_URL, then the prod host. (A
+ * verified per-org tracking domain is used at send time when present; this is the
+ * fallback the token routes are always reachable at.)
+ */
+export function emailTrackingAppBaseUrl(env = process.env) {
+    const raw = (env.NEXT_PUBLIC_APP_URL || env.OXYGEN_APP_URL || "https://oxygen-agent.com").trim();
+    return raw.replace(/\/+$/, "");
+}
+/** The open-pixel URL for a signed token: `<base>/api/t/o/<token>`. */
+export function buildOpenPixelUrl(token, baseUrl) {
+    return `${baseUrl.replace(/\/+$/, "")}/api/t/o/${encodeURIComponent(token)}`;
+}
+/**
+ * The click-tracking URL for a signed token + destination: the destination rides
+ * in the `u` query param (the route recomputes its hash against the token's `uh`).
+ */
+export function buildClickTrackingUrl(token, destinationUrl, baseUrl) {
+    return `${baseUrl.replace(/\/+$/, "")}/api/t/c/${encodeURIComponent(token)}?u=${encodeURIComponent(destinationUrl)}`;
+}

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

@@ -7,10 +7,13 @@ export * from "./cli-envelope.js";
 export * from "./cli-result.js";
 export * from "./column-types.js";
 export * from "./credit-guidance.js";
+export * from "./directory.js";
+export * from "./email-tracking-token.js";
 export * from "./email-unsubscribe-token.js";
 export * from "./linkedin-post-url.js";
 export * from "./linkedin-sequences.js";
 export * from "./networks.js";
+export * from "./sequence-template.js";
 export * from "./sequences.js";
 export * from "./log.js";
 export * from "./provider-request-outcomes.js";

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

@@ -7,10 +7,13 @@ export * from "./cli-envelope.js";
 export * from "./cli-result.js";
 export * from "./column-types.js";
 export * from "./credit-guidance.js";
+export * from "./directory.js";
+export * from "./email-tracking-token.js";
 export * from "./email-unsubscribe-token.js";
 export * from "./linkedin-post-url.js";
 export * from "./linkedin-sequences.js";
 export * from "./networks.js";
+export * from "./sequence-template.js";
 export * from "./sequences.js";
 export * from "./log.js";
 export * from "./provider-request-outcomes.js";

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

@@ -16,10 +16,19 @@
  * - message              — send a message; template supports {{column}} interp
  * - inmail               — send an InMail (works on non-connections)
  */
-export declare const LINKEDIN_SEQUENCE_STEP_KINDS: readonly ["visit_profile", "invite", "wait_for_connection", "wait", "message", "inmail", "branch", "stop"];
+import { type RenderTemplateOptions } from "./sequence-template.js";
+export declare const LINKEDIN_SEQUENCE_STEP_KINDS: readonly ["visit_profile", "invite", "wait_for_connection", "wait", "message", "inmail", "follow", "like_post", "comment_post", "withdraw_invite", "branch", "stop"];
 export type LinkedInSequenceStepKind = typeof LINKEDIN_SEQUENCE_STEP_KINDS[number];
-/** Conditions a `branch` step routes on. Both are LinkedIn-signal driven. */
-export declare const LINKEDIN_BRANCH_CONDITIONS: readonly ["connection_accepted", "already_connected"];
+/** LinkedIn reaction types for a `like_post` step. */
+export declare const LINKEDIN_POST_REACTIONS: readonly ["like", "celebrate", "support", "funny", "love", "insightful"];
+export type LinkedInPostReaction = typeof LINKEDIN_POST_REACTIONS[number];
+/**
+ * Conditions a `branch` step routes on. All are LinkedIn-signal driven.
+ * - connection_accepted / already_connected: connection-degree gates.
+ * - open_profile: is the lead an Open Profile (free InMail target)? Lets a
+ *   sequence route `branch open_profile → inmail : invite` (the Expandi play).
+ */
+export declare const LINKEDIN_BRANCH_CONDITIONS: readonly ["connection_accepted", "already_connected", "open_profile"];
 export type LinkedInBranchCondition = typeof LINKEDIN_BRANCH_CONDITIONS[number];
 /** Every step carries a stable id so branch edges can target it by reference. */
 export type LinkedInStepBase = {
@@ -50,6 +59,11 @@ export type LinkedInMessageStep = LinkedInStepBase & {
     kind: "message";
     /** Message body. Supports {{column}} interpolation from the source-table row. */
     template: string;
+    /** Files attached to the message (image / document), fetched + uploaded at send. */
+    attachments?: {
+        url: string;
+        name?: string;
+    }[];
 };
 export type LinkedInInMailStep = LinkedInStepBase & {
     kind: "inmail";
@@ -86,7 +100,34 @@ export type LinkedInBranchStep = LinkedInStepBase & {
 export type LinkedInStopStep = LinkedInStepBase & {
     kind: "stop";
 };
-export type LinkedInSequenceStep = LinkedInVisitProfileStep | LinkedInInviteStep | LinkedInWaitForConnectionStep | LinkedInWaitStep | LinkedInMessageStep | LinkedInInMailStep | LinkedInBranchStep | LinkedInStopStep;
+/** Follow the lead — no connection required. A light warm-up touch. */
+export type LinkedInFollowStep = LinkedInStepBase & {
+    kind: "follow";
+};
+/** Post-targeting steps share how they pick which of the lead's posts to act on. */
+type LinkedInPostTargetingBase = {
+    /** Only act on a post published within this many days. Defaults to 30. */
+    post_recency_days?: number;
+    /** What to do when the lead has no recent post to act on. Defaults to "skip". */
+    on_no_post?: "skip" | "stop";
+};
+export type LinkedInLikePostStep = LinkedInStepBase & LinkedInPostTargetingBase & {
+    kind: "like_post";
+    /** Reaction to leave. Defaults to "like". */
+    reaction?: LinkedInPostReaction;
+};
+export type LinkedInCommentPostStep = LinkedInStepBase & LinkedInPostTargetingBase & {
+    kind: "comment_post";
+    /** Comment text with {{column}} interpolation. Provide exactly one of this or ai_prompt. */
+    text_template?: string;
+    /** Prompt for an AI-generated comment (rendered against the row + post). Exactly one of this or text_template. */
+    ai_prompt?: string;
+};
+/** Withdraw the still-pending connection invite to this lead (a no-op if none is pending). */
+export type LinkedInWithdrawInviteStep = LinkedInStepBase & {
+    kind: "withdraw_invite";
+};
+export type LinkedInSequenceStep = LinkedInVisitProfileStep | LinkedInInviteStep | LinkedInWaitForConnectionStep | LinkedInWaitStep | LinkedInMessageStep | LinkedInInMailStep | LinkedInFollowStep | LinkedInLikePostStep | LinkedInCommentPostStep | LinkedInWithdrawInviteStep | LinkedInBranchStep | LinkedInStopStep;
 export type LinkedInSequenceDefinition = {
     steps: LinkedInSequenceStep[];
 };
@@ -96,11 +137,17 @@ export type LinkedInSequenceDefinition = {
  * that dispatch nothing. NOTE: this is the *action* kind, not the *quota* kind
  * — visit_profile maps to the quota kind profile_view downstream.
  */
-export declare const LINKEDIN_STEP_ACTION_KIND: Record<LinkedInSequenceStepKind, "visit_profile" | "invite" | "message" | "inmail" | null>;
+export type LinkedInStepActionKind = "visit_profile" | "invite" | "message" | "inmail" | "follow" | "like_post" | "comment_post" | "withdraw_invite";
+export declare const LINKEDIN_STEP_ACTION_KIND: Record<LinkedInSequenceStepKind, LinkedInStepActionKind | null>;
 /** Total delay in milliseconds a `wait` step introduces. */
 export declare function waitStepDelayMs(step: LinkedInWaitStep): number;
 /**
- * Render a {{column}} template against a row's values. Unknown placeholders
- * render empty. Used by the dispatch engine to produce the final message text.
+ * Render a sequence-copy template against a row's values. Delegates to the shared
+ * deterministic engine, so beyond `{{column}}` substitution it also handles
+ * `{{column|fallback}}`, `{{RANDOM|…}}` spintax, and `{% if … %}` conditionals.
+ * Unknown `{{column}}` placeholders render empty. Used by the dispatch engine to
+ * produce the final message text. Pass `{ seed }` to make spintax choices
+ * replayable (crash-safe); with no seed a stable template+values seed is derived.
  */
-export declare function renderLinkedInTemplate(template: string, values: Record<string, unknown>): string;
+export declare function renderLinkedInTemplate(template: string, values: Record<string, unknown>, options?: RenderTemplateOptions): string;
+export {};

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

@@ -16,6 +16,7 @@
  * - message              — send a message; template supports {{column}} interp
  * - inmail               — send an InMail (works on non-connections)
  */
+import { renderTemplate } from "./sequence-template.js";
 export const LINKEDIN_SEQUENCE_STEP_KINDS = [
     "visit_profile",
     "invite",
@@ -23,17 +24,23 @@ export const LINKEDIN_SEQUENCE_STEP_KINDS = [
     "wait",
     "message",
     "inmail",
+    // Social-graph steps (the "act like a human warming up a lead" palette):
+    "follow", // follow the lead (no connection needed) — a light touch before an invite
+    "like_post", // react to the lead's most recent post
+    "comment_post", // comment on the lead's most recent post (template or AI-generated)
+    "withdraw_invite", // withdraw a still-pending connection invite to this lead
     "branch",
     "stop",
 ];
-/** Conditions a `branch` step routes on. Both are LinkedIn-signal driven. */
-export const LINKEDIN_BRANCH_CONDITIONS = ["connection_accepted", "already_connected"];
+/** LinkedIn reaction types for a `like_post` step. */
+export const LINKEDIN_POST_REACTIONS = ["like", "celebrate", "support", "funny", "love", "insightful"];
 /**
- * The dispatch-queue action kind a step produces (matches the
- * ox_sequencer.sequence_actions.action_kind enum), or null for gate/wait steps
- * that dispatch nothing. NOTE: this is the *action* kind, not the *quota* kind
- * — visit_profile maps to the quota kind profile_view downstream.
+ * Conditions a `branch` step routes on. All are LinkedIn-signal driven.
+ * - connection_accepted / already_connected: connection-degree gates.
+ * - open_profile: is the lead an Open Profile (free InMail target)? Lets a
+ *   sequence route `branch open_profile → inmail : invite` (the Expandi play).
  */
+export const LINKEDIN_BRANCH_CONDITIONS = ["connection_accepted", "already_connected", "open_profile"];
 export const LINKEDIN_STEP_ACTION_KIND = {
     visit_profile: "visit_profile",
     invite: "invite",
@@ -41,6 +48,10 @@ export const LINKEDIN_STEP_ACTION_KIND = {
     wait: null,
     message: "message",
     inmail: "inmail",
+    follow: "follow",
+    like_post: "like_post",
+    comment_post: "comment_post",
+    withdraw_invite: "withdraw_invite",
     branch: null,
     stop: null,
 };
@@ -51,14 +62,13 @@ export function waitStepDelayMs(step) {
     return (days * 24 + hours) * 60 * 60 * 1000;
 }
 /**
- * Render a {{column}} template against a row's values. Unknown placeholders
- * render empty. Used by the dispatch engine to produce the final message text.
+ * Render a sequence-copy template against a row's values. Delegates to the shared
+ * deterministic engine, so beyond `{{column}}` substitution it also handles
+ * `{{column|fallback}}`, `{{RANDOM|…}}` spintax, and `{% if … %}` conditionals.
+ * Unknown `{{column}}` placeholders render empty. Used by the dispatch engine to
+ * produce the final message text. Pass `{ seed }` to make spintax choices
+ * replayable (crash-safe); with no seed a stable template+values seed is derived.
  */
-export function renderLinkedInTemplate(template, values) {
-    return template.replace(/\{\{\s*([\w.]+)\s*\}\}/g, (_match, key) => {
-        const value = values[key];
-        if (value === null || value === undefined)
-            return "";
-        return typeof value === "string" ? value : String(value);
-    });
+export function renderLinkedInTemplate(template, values, options) {
+    return renderTemplate(template, values, options);
 }

package/node_modules/@oxygen/shared/dist/sequence-template.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Deterministic sequence-copy template engine. Renders the copy of a sequence
+ * step (LinkedIn message / InMail / invite note, native email subject/body,
+ * WhatsApp message, Instantly custom fields) against a lead's row values in a
+ * SINGLE deterministic pass. Beyond the original `{{column}}` substitution it
+ * supports three composable, nestable constructs:
+ *
+ *  1. Inline fallback — `{{column|fallback text}}` renders the column's value, or
+ *     the literal fallback text when the column is missing/empty. `{{column}}`
+ *     with no `|` keeps the original behavior (empty when the column is missing).
+ *  2. Spintax — `{{RANDOM|option a|option b|option c}}` renders ONE option chosen
+ *     deterministically from the seed (never Math.random — retries/replays never
+ *     drift). Options may themselves contain `{{column}}`/fallback/spintax/
+ *     conditionals, which resolve AFTER selection.
+ *  3. Conditional blocks — `{% if column %}A{% endif %}` (truthy),
+ *     `{% if column == "x" %}A{% else %}B{% endif %}` (== / !=), and
+ *     `{% if column contains "x" %}A{% endif %}` (case-insensitive substring).
+ *     The `{% else %}` arm and the operator/quoted value are optional; either
+ *     branch may nest any construct.
+ *
+ * Determinism contract: the SAME (template, values, seed) always renders
+ * byte-identically. The sequencer dispatch passes an enrollment-scoped seed so a
+ * crash-replay of a step re-renders identically; with no seed the engine derives
+ * a stable seed from the template + values (still deterministic, just not
+ * enrollment-scoped). Pure — no I/O, no clock, no randomness.
+ *
+ * This is the single home for the render engine; `renderLinkedInTemplate`
+ * (linkedin-sequences.ts) and `renderSequenceTemplate` (sequences.ts) both
+ * delegate here so every surface renders copy identically.
+ */
+export type RenderTemplateOptions = {
+    /**
+     * Seed for spintax selection. When provided, ALL spintax choices in the
+     * template are derived from it, so the same (template, values, seed) renders
+     * byte-identically across retries/replays. When omitted, a stable seed is
+     * derived from the template + values (still deterministic, not enrollment-scoped).
+     */
+    seed?: string;
+};
+/**
+ * Deterministic, replayable FNV-1a hash → uint32. Stable across processes — the
+ * single hash used by both spintax selection here and A/B variant assignment in
+ * sequences.ts (which imports it from this module).
+ */
+export declare function hashVariantKey(value: string): number;
+/**
+ * Render a sequence-copy template against a lead's row values. Supports
+ * `{{column}}` substitution, `{{column|fallback}}`, `{{RANDOM|…}}` spintax, and
+ * `{% if … %}…{% endif %}` conditionals, in a single deterministic pass. Unknown
+ * `{{column}}` placeholders render empty; a malformed placeholder is left literal.
+ */
+export declare function renderTemplate(template: string, values: Record<string, unknown>, options?: RenderTemplateOptions): string;
+/**
+ * Every column key a template references — across bare `{{column}}` substitutions,
+ * `{{column|fallback}}` fallbacks, `{{RANDOM|…}}` spintax options, and both the
+ * condition and branches of `{% if … %}` blocks. Pure scan (no rendering), used by
+ * the start-preview variable-resolution check so a column referenced only inside a
+ * nested construct still surfaces. Deduplicated.
+ */
+export declare function templateColumnKeys(template: string): string[];