@oxygen-agent/cli 1.696.2 → 1.717.1

package/dist/transcript.js

@@ -116,8 +116,8 @@ function countEvents(buf) {
 }
 // Redact obvious credentials from transcript text before it leaves the machine.
 // Agent JSONL can embed API keys, auth headers, and tokens captured from tool
-// calls / shell output; scrub the common shapes so `oxygen feedback` never ships
-// raw secrets to the support API. Best-effort (not a guarantee) and deliberately
+// calls / shell output; scrub the common shapes before an explicitly requested
+// attachment reaches the support API. Best-effort (not a guarantee) and deliberately
 // conservative — it targets credential shapes, not general prose, so the
 // transcript stays useful for debugging.
 const SECRET_PATTERNS = [

package/node_modules/@oxygen/recipe-sdk/dist/index.d.ts

@@ -5,6 +5,8 @@ export type RecipeRuntime = "durable";
 export type RecipeToolRunOptions = {
     key?: string;
     optional?: boolean;
+    /** Pin this call to one provider account for every replay/scheduled run. */
+    connectionId?: string;
 };
 export type RecipeToolApi = {
     run: <T = unknown>(toolId: string, payload?: Record<string, unknown>, options?: RecipeToolRunOptions) => Promise<T>;
@@ -145,6 +147,8 @@ export type RecipeWaitResult = {
 };
 export type RecipeContext = {
     input: unknown;
+    /** Operator-managed settings from the recipe manifest, separate from the trigger payload. */
+    configuration: Record<string, unknown>;
     mode: WorkflowMode;
     organizationId: string;
     tools: RecipeToolApi;

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

@@ -125,7 +125,7 @@ export declare const BASE_PRICING_PLANS: {
         readonly automationOverageCentsPerMillion: null;
         readonly automationOverageEnabledDefault: false;
         readonly byokEnabled: false;
-        readonly description: "No active plan. Start a 7-day Starter trial to use OXYGEN — existing credit balances remain spendable.";
+        readonly description: "No active plan. Start a 7-day trial on a self-serve plan to use OXYGEN — existing credit balances remain spendable.";
         readonly ctaLabel: "Start trial";
         readonly features: readonly ["Existing credits stay spendable", "Read access to your workspace"];
     };

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

@@ -145,10 +145,11 @@ export function resolveCreditTopupPack(id) {
         return null;
     return CREDIT_TOPUP_PACKS.find((pack) => pack.id === id) ?? null;
 }
-// Card-required free trial: every new signup starts a Stripe trial on the Starter
-// plan, gets TRIAL_CREDIT_GRANT credits (a value-demonstration budget sized to the
-// guided first outcome — NOT the full plan allowance), and converts to paid on
-// credit exhaustion or when the trial clock elapses, whichever comes first.
+// Card-required free trial: every new signup chooses a self-serve Stripe plan,
+// gets TRIAL_CREDIT_GRANT credits (a value-demonstration budget sized to the
+// guided first outcome — NOT the selected plan's full allowance), and converts
+// to that paid plan on credit exhaustion or when the trial clock elapses,
+// whichever comes first. Starter remains the signup default.
 export const TRIAL_PERIOD_DAYS = 7;
 export const TRIAL_CREDIT_GRANT = 20_000;
 // Onboarding walkthrough (2026-07-21): completing the in-product walkthrough
@@ -160,7 +161,7 @@ export const WALKTHROUGH_COMPLETION_BONUS_CREDITS = 1_000;
 export const WALKTHROUGH_SCRAPE_MAX_CREDITS = 2_000;
 export const BASE_PRICING_PLANS = {
     // Fully retired as a distribution surface (2026-07-22; entry is the
-    // card-required Starter trial). The tier survives only as the unentitled
+    // card-required self-serve trial). The tier survives only as the unentitled
     // fallback for churned / never-subscribed orgs: zero monthly credits means
     // ensureCurrentPlanCreditGrant short-circuits — no monthly minting AND no
     // rollover-cap claw-back of leftover balances, which stay spendable.
@@ -175,7 +176,7 @@ export const BASE_PRICING_PLANS = {
         automationOverageCentsPerMillion: null,
         automationOverageEnabledDefault: false,
         byokEnabled: false,
-        description: "No active plan. Start a 7-day Starter trial to use OXYGEN — existing credit balances remain spendable.",
+        description: "No active plan. Start a 7-day trial on a self-serve plan to use OXYGEN — existing credit balances remain spendable.",
         ctaLabel: "Start trial",
         features: [
             "Existing credits stay spendable",

package/node_modules/@oxygen/shared/dist/dnc-identities.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Source-neutral identities accepted by the unified DNC write contract.
+ *
+ * The existing mixed-text suppression importer intentionally remains separate:
+ * a bare domain there means an email-domain block. Typed `company_domain` and
+ * `linkedin_company` entries are organization-wide and stop every Sequence
+ * channel. Keeping the two contracts distinct preserves backwards compatibility
+ * while letting HubSpot, Tables, CSVs, webhooks, and future CRM adapters share one
+ * explicit ingestion boundary.
+ */
+export declare const DNC_IDENTITY_KINDS: readonly ["email", "phone", "linkedin_person", "company_domain", "linkedin_company"];
+export type DncIdentityKind = (typeof DNC_IDENTITY_KINDS)[number];
+export type DncIdentityInput = {
+    kind: DncIdentityKind;
+    value: string;
+    reason?: string;
+    source?: string;
+    detail?: string;
+    metadata?: Record<string, unknown>;
+};
+export type CompanyDncIdentity = {
+    kind: "domain" | "linkedin_company";
+    value: string;
+    key: string;
+};
+/** Canonical company hostname, without scheme, path, port, www, or trailing dot. */
+export declare function normalizeCompanyDncDomain(value: unknown): string | null;
+/** Canonical public LinkedIn organization URL (`/company/` or `/school/`). */
+export declare function normalizeLinkedinCompanyUrl(value: unknown): string | null;
+/**
+ * Final shape normalization shared by all typed DNC adapters. Tenant DB writers
+ * still apply their ledger-specific validators before persistence.
+ */
+export declare function normalizeDncIdentityValue(kind: DncIdentityKind, value: unknown): string | null;
+export declare function companyDncIdentityKey(kind: CompanyDncIdentity["kind"], value: string): string;
+/**
+ * Every explicit identity that can represent one LinkedIn person at the DNC
+ * boundary. Provider ids remain opaque/case-sensitive; public profile URLs are
+ * canonicalized to the same stable key used by typed importers. The helper is
+ * source-neutral so enrollment, planning, dispatch, and final provider
+ * boundaries cannot drift onto different subsets of identity fields.
+ */
+export declare function linkedinPersonDncKeys(input: {
+    leadProviderId?: unknown;
+    leadProfileUrl?: unknown;
+    rowValues?: Record<string, unknown> | null;
+}): string[];
+/**
+ * Extract only explicit company identities from an enrollment row. We never
+ * derive a company-wide block from a person's email domain: one person's opt-out
+ * must not silently suppress their entire employer.
+ */
+export declare function companyDncIdentitiesFromRowValues(rowValues: Record<string, unknown> | null | undefined): CompanyDncIdentity[];

package/node_modules/@oxygen/shared/dist/dnc-identities.js

@@ -0,0 +1,175 @@
+import { normalizeLinkedinProfileUrl } from "./linkedin-url.js";
+import { LINKEDIN_MEMBER_URN_PATTERN } from "./suppression-entries.js";
+/**
+ * Source-neutral identities accepted by the unified DNC write contract.
+ *
+ * The existing mixed-text suppression importer intentionally remains separate:
+ * a bare domain there means an email-domain block. Typed `company_domain` and
+ * `linkedin_company` entries are organization-wide and stop every Sequence
+ * channel. Keeping the two contracts distinct preserves backwards compatibility
+ * while letting HubSpot, Tables, CSVs, webhooks, and future CRM adapters share one
+ * explicit ingestion boundary.
+ */
+export const DNC_IDENTITY_KINDS = [
+    "email",
+    "phone",
+    "linkedin_person",
+    "company_domain",
+    "linkedin_company",
+];
+const E164_PATTERN = /^\+[1-9]\d{1,14}$/;
+const DOMAIN_PATTERN = /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+const COMPANY_DOMAIN_ROW_KEYS = [
+    "company_domain",
+    "companyDomain",
+    "domain",
+    "website_domain",
+    "websiteDomain",
+];
+const LINKEDIN_COMPANY_ROW_KEYS = [
+    "company_linkedin_url",
+    "companyLinkedinUrl",
+    "linkedin_company_url",
+    "linkedinCompanyUrl",
+    "linkedin_company_page",
+    "linkedinCompanyPage",
+];
+const LINKEDIN_PERSON_ROW_KEYS = [
+    "linkedin_url",
+    "linkedinUrl",
+    "person_linkedin_url",
+    "personLinkedinUrl",
+    "lead_profile_url",
+    "leadProfileUrl",
+];
+function readNonEmptyString(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}
+/** Canonical company hostname, without scheme, path, port, www, or trailing dot. */
+export function normalizeCompanyDncDomain(value) {
+    const raw = readNonEmptyString(value)?.toLowerCase();
+    if (!raw || raw.includes("@") || /\s/.test(raw))
+        return null;
+    try {
+        const parsed = new URL(raw.includes("://") ? raw : `https://${raw}`);
+        if (parsed.username || parsed.password)
+            return null;
+        const hostname = parsed.hostname.replace(/^www\./, "").replace(/\.$/, "");
+        if (!DOMAIN_PATTERN.test(hostname))
+            return null;
+        return hostname;
+    }
+    catch {
+        return null;
+    }
+}
+/** Canonical public LinkedIn organization URL (`/company/` or `/school/`). */
+export function normalizeLinkedinCompanyUrl(value) {
+    const raw = readNonEmptyString(value);
+    if (!raw || /\s/.test(raw))
+        return null;
+    try {
+        const parsed = new URL(raw.includes("://") ? raw : `https://${raw}`);
+        const hostname = parsed.hostname.toLowerCase();
+        if (hostname !== "linkedin.com" && !hostname.endsWith(".linkedin.com"))
+            return null;
+        const match = parsed.pathname.match(/^\/(company|school)\/([^/?#]+)\/?$/i);
+        if (!match?.[1] || !match[2])
+            return null;
+        return `https://www.linkedin.com/${match[1].toLowerCase()}/${match[2].toLowerCase()}`;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Final shape normalization shared by all typed DNC adapters. Tenant DB writers
+ * still apply their ledger-specific validators before persistence.
+ */
+export function normalizeDncIdentityValue(kind, value) {
+    const raw = readNonEmptyString(value);
+    if (!raw)
+        return null;
+    switch (kind) {
+        case "email": {
+            const email = raw.toLowerCase();
+            return email.includes("@") && !/\s/.test(email) ? email : null;
+        }
+        case "phone":
+            return E164_PATTERN.test(raw) ? raw : null;
+        case "linkedin_person": {
+            const profile = normalizeLinkedinProfileUrl(raw);
+            if (profile)
+                return profile.normalized;
+            return LINKEDIN_MEMBER_URN_PATTERN.test(raw) ? raw : null;
+        }
+        case "company_domain":
+            return normalizeCompanyDncDomain(raw);
+        case "linkedin_company":
+            return normalizeLinkedinCompanyUrl(raw);
+    }
+}
+export function companyDncIdentityKey(kind, value) {
+    return `${kind}:${value}`;
+}
+/**
+ * Every explicit identity that can represent one LinkedIn person at the DNC
+ * boundary. Provider ids remain opaque/case-sensitive; public profile URLs are
+ * canonicalized to the same stable key used by typed importers. The helper is
+ * source-neutral so enrollment, planning, dispatch, and final provider
+ * boundaries cannot drift onto different subsets of identity fields.
+ */
+export function linkedinPersonDncKeys(input) {
+    const keys = new Set();
+    const providerId = readNonEmptyString(input.leadProviderId);
+    if (providerId)
+        keys.add(providerId);
+    const addProfile = (value) => {
+        const raw = readNonEmptyString(value);
+        if (!raw)
+            return;
+        const normalized = normalizeLinkedinProfileUrl(raw)?.normalized;
+        if (normalized)
+            keys.add(normalized);
+    };
+    addProfile(input.leadProfileUrl);
+    for (const key of LINKEDIN_PERSON_ROW_KEYS)
+        addProfile(input.rowValues?.[key]);
+    return [...keys];
+}
+/**
+ * Extract only explicit company identities from an enrollment row. We never
+ * derive a company-wide block from a person's email domain: one person's opt-out
+ * must not silently suppress their entire employer.
+ */
+export function companyDncIdentitiesFromRowValues(rowValues) {
+    if (!rowValues)
+        return [];
+    const identities = new Map();
+    for (const key of COMPANY_DOMAIN_ROW_KEYS) {
+        const value = normalizeCompanyDncDomain(rowValues[key]);
+        if (!value)
+            continue;
+        const identity = {
+            kind: "domain",
+            value,
+            key: companyDncIdentityKey("domain", value),
+        };
+        identities.set(identity.key, identity);
+    }
+    for (const key of LINKEDIN_COMPANY_ROW_KEYS) {
+        const value = normalizeLinkedinCompanyUrl(rowValues[key]);
+        if (!value)
+            continue;
+        const identity = {
+            kind: "linkedin_company",
+            value,
+            key: companyDncIdentityKey("linkedin_company", value),
+        };
+        identities.set(identity.key, identity);
+    }
+    return [...identities.values()];
+}

package/node_modules/@oxygen/shared/dist/file-import.d.ts

@@ -1,5 +1,6 @@
 import { type Row } from "read-excel-file/node";
 import { type ImportColumnDataType } from "./column-types.js";
+export { MAX_BUFFERED_IMPORT_PARSE_BYTES } from "./import-limits.js";
 export type RowsFileFormat = "json" | "jsonl" | "csv" | "xlsx";
 export type ImportTableColumn = {
     label: string;
@@ -11,7 +12,6 @@ export type NewTableImportRows = {
     rows: Record<string, unknown>[];
     keyBySource: Record<string, string>;
 };
-export declare const MAX_BUFFERED_IMPORT_PARSE_BYTES: number;
 export declare function inferRowsFileFormat(path: string): RowsFileFormat;
 export declare function normalizeRowsFormat(value: string | undefined, fallback: RowsFileFormat): RowsFileFormat;
 export declare function parseRowsFileBuffer(buffer: Buffer, format: RowsFileFormat, options?: {
@@ -30,6 +30,41 @@ export declare function iterateRowsFileStreamBatches(chunks: AsyncIterable<Uint8
     batchSize?: number;
 }): AsyncGenerator<Record<string, unknown>[]>;
 export declare function parseRowsText(text: string, format: Exclude<RowsFileFormat, "xlsx">): Record<string, unknown>[];
+/**
+ * How many leading bytes of a staged upload we read back to derive its shape.
+ *
+ * A staged import lives in object storage, so the only thing standing between a
+ * 100MB CSV and a preview is how much of it we are willing to pull into a
+ * request handler. 2MiB is the same ceiling the copilot tabular preview uses and
+ * comfortably covers a header row plus enough rows to infer column types.
+ */
+export declare const MAX_IMPORT_SAMPLE_BYTES: number;
+export type RowsSample = {
+    rows: Record<string, unknown>[];
+    headers: string[];
+    /** True when a partial trailing record was discarded because the sample was cut short. */
+    droppedPartialRecord: boolean;
+};
+/**
+ * Parse the LEADING SLICE of an import file — the same bytes the worker will
+ * later stream, run through the same state machine.
+ *
+ * `truncated` says the caller handed us a prefix, not a whole file, and it
+ * changes exactly one thing: the residue left in the parser when the bytes run
+ * out is DISCARDED instead of being flushed as a final record (or raised as an
+ * unterminated-quote error). That is the whole subtlety here. The obvious
+ * alternative — cut the slice at the last newline and parse that — is wrong for
+ * real exports: a quoted free-text column routinely contains literal newlines,
+ * so the last `\n` in a 2MiB window is very often INSIDE a quoted field, and
+ * cutting there splits one row into two bogus ones. Only the state machine knows
+ * whether a newline closed a record, so only it may decide where the sample ends.
+ *
+ * With `truncated: false` the sample IS the file and behaviour is identical to
+ * `parseRowsText`, unterminated-quote error included.
+ */
+export declare function parseRowsSampleText(text: string, format: Exclude<RowsFileFormat, "xlsx">, options: {
+    truncated: boolean;
+}): RowsSample;
 export declare function inferImportColumnLabels(rows: Record<string, unknown>[]): string[];
 export declare function normalizeRowsForNewTable(rows: Record<string, unknown>[]): NewTableImportRows;
 export declare function normalizeImportColumnKey(value: string): string;

package/node_modules/@oxygen/shared/dist/file-import.js

@@ -3,7 +3,8 @@ import readXlsxFile from "read-excel-file/node";
 import { inferImportColumnDataType, parseDateValueToIso, } from "./column-types.js";
 import { OxygenError } from "./cli-result.js";
 import { makeUniqueIdentifier, toSnakeIdentifier } from "./identifiers.js";
-export const MAX_BUFFERED_IMPORT_PARSE_BYTES = 10 * 1024 * 1024;
+import { MAX_BUFFERED_IMPORT_PARSE_BYTES } from "./import-limits.js";
+export { MAX_BUFFERED_IMPORT_PARSE_BYTES } from "./import-limits.js";
 export function inferRowsFileFormat(path) {
     const extension = extname(path).toLowerCase();
     if (extension === ".jsonl" || extension === ".ndjson")
@@ -87,6 +88,84 @@ export function parseRowsText(text, format) {
     }
     return parseCsvRows(text);
 }
+/**
+ * How many leading bytes of a staged upload we read back to derive its shape.
+ *
+ * A staged import lives in object storage, so the only thing standing between a
+ * 100MB CSV and a preview is how much of it we are willing to pull into a
+ * request handler. 2MiB is the same ceiling the copilot tabular preview uses and
+ * comfortably covers a header row plus enough rows to infer column types.
+ */
+export const MAX_IMPORT_SAMPLE_BYTES = 2 * 1024 * 1024;
+/**
+ * Parse the LEADING SLICE of an import file — the same bytes the worker will
+ * later stream, run through the same state machine.
+ *
+ * `truncated` says the caller handed us a prefix, not a whole file, and it
+ * changes exactly one thing: the residue left in the parser when the bytes run
+ * out is DISCARDED instead of being flushed as a final record (or raised as an
+ * unterminated-quote error). That is the whole subtlety here. The obvious
+ * alternative — cut the slice at the last newline and parse that — is wrong for
+ * real exports: a quoted free-text column routinely contains literal newlines,
+ * so the last `\n` in a 2MiB window is very often INSIDE a quoted field, and
+ * cutting there splits one row into two bogus ones. Only the state machine knows
+ * whether a newline closed a record, so only it may decide where the sample ends.
+ *
+ * With `truncated: false` the sample IS the file and behaviour is identical to
+ * `parseRowsText`, unterminated-quote error included.
+ */
+export function parseRowsSampleText(text, format, options) {
+    if (format === "csv")
+        return parseCsvSample(text, options.truncated);
+    if (format === "jsonl") {
+        // A truncated JSONL sample ends mid-line; that line is not a document yet.
+        const lines = text.split(/\r?\n/);
+        const complete = options.truncated ? lines.slice(0, -1) : lines;
+        const rows = normalizeRowObjects(complete
+            .map((line, index) => ({ line, lineNumber: index + 1 }))
+            .filter(({ line }) => line.trim())
+            .map(({ line, lineNumber }) => parseJsonImportLine(line, lineNumber)));
+        return {
+            rows,
+            headers: inferImportColumnLabels(rows),
+            droppedPartialRecord: options.truncated && lines.length > complete.length,
+        };
+    }
+    // A JSON array has no record boundary to resume from — half a document is not
+    // a document. Callers must refuse a truncated JSON sample before asking.
+    if (options.truncated) {
+        throw new OxygenError("import_sample_unsupported_format", "A JSON array cannot be previewed from a partial file; it must be parsed whole.", { details: { format }, exitCode: 1 });
+    }
+    const rows = normalizeRowObjects(parseJsonArray(text));
+    return { rows, headers: inferImportColumnLabels(rows), droppedPartialRecord: false };
+}
+function parseCsvSample(text, truncated) {
+    const state = {
+        header: null,
+        batch: [],
+        record: [],
+        field: "",
+        inQuotes: false,
+    };
+    for (let index = 0; index < text.length; index += 1) {
+        const result = applyCsvCharacter(state, text.charAt(index), text.charAt(index + 1));
+        if (result.skipNext)
+            index += 1;
+        if (!result.recordComplete)
+            continue;
+        appendCsvRecordToBatch(state, finishCsvRecord(state), Number.POSITIVE_INFINITY);
+    }
+    const hasResidue = state.inQuotes || Boolean(state.field) || state.record.length > 0;
+    if (truncated) {
+        return { rows: state.batch, headers: state.header ?? [], droppedPartialRecord: hasResidue };
+    }
+    if (state.inQuotes)
+        throw unterminatedCsvError();
+    if (state.field || state.record.length > 0) {
+        appendCsvRecordToBatch(state, finishCsvRecord(state), Number.POSITIVE_INFINITY);
+    }
+    return { rows: state.batch, headers: state.header ?? [], droppedPartialRecord: false };
+}
 export function inferImportColumnLabels(rows) {
     const labels = [];
     const seen = new Set();

package/node_modules/@oxygen/shared/dist/image-sniff.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Identify an image by its BYTES, never by what the uploader claimed.
+ *
+ * These files are served back from our own domain to a third party that fetches
+ * them unauthenticated, so `Content-Type` cannot come from client input: an
+ * attacker who can choose the type of a file served from oxygen-agent.com — the
+ * origin holding the session cookie — can serve HTML from it. Sniffing is the
+ * whole defence, so it runs both when the file is stored and again when it is
+ * served.
+ */
+export type SniffedImageType = "image/png" | "image/jpeg" | "image/webp";
+/**
+ * SVG is deliberately absent and must stay absent.
+ *
+ * An SVG is a document, not a raster image: it can carry <script>, and a viewer
+ * who navigates directly to it runs that script on our origin. That is stored
+ * XSS against every signed-in user. (The directory-listing logo route can accept
+ * SVG precisely because Vercel Blob serves it from a foreign origin, where the
+ * same file is inert against us.) GIF is merely unnecessary rather than
+ * dangerous; adding it would be two more magic numbers here.
+ */
+export declare function sniffImageContentType(bytes: Uint8Array): SniffedImageType | null;
+export declare function imageExtensionFor(type: SniffedImageType): "png" | "jpg" | "webp";
+/** The filenames the public serve route will answer to. Nothing else is addressable. */
+export declare const INBOX_AVATAR_FILE_NAMES: readonly ["avatar.png", "avatar.jpg", "avatar.webp"];
+export type InboxAvatarFileName = (typeof INBOX_AVATAR_FILE_NAMES)[number];
+export declare function inboxAvatarFileNameFor(type: SniffedImageType): InboxAvatarFileName;
+export declare function contentTypeForInboxAvatarFileName(name: string): SniffedImageType | null;
+/**
+ * How many leading bytes are enough to identify any supported format. Every
+ * magic number above lives in the first 12.
+ */
+export declare const IMAGE_SNIFF_BYTES = 32;
+/**
+ * The upload ceiling. Larger than the 2MB used for directory logos because this
+ * is a photo of a person, and phone cameras routinely produce 4–8MB files; a
+ * cap that rejects "the photo I just took" is a cap that gets worked around.
+ */
+export declare const MAX_INBOX_AVATAR_BYTES: number;

package/node_modules/@oxygen/shared/dist/image-sniff.js

@@ -0,0 +1,75 @@
+/**
+ * Identify an image by its BYTES, never by what the uploader claimed.
+ *
+ * These files are served back from our own domain to a third party that fetches
+ * them unauthenticated, so `Content-Type` cannot come from client input: an
+ * attacker who can choose the type of a file served from oxygen-agent.com — the
+ * origin holding the session cookie — can serve HTML from it. Sniffing is the
+ * whole defence, so it runs both when the file is stored and again when it is
+ * served.
+ */
+const PNG_MAGIC = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+const JPEG_MAGIC = [0xff, 0xd8, 0xff];
+/**
+ * SVG is deliberately absent and must stay absent.
+ *
+ * An SVG is a document, not a raster image: it can carry <script>, and a viewer
+ * who navigates directly to it runs that script on our origin. That is stored
+ * XSS against every signed-in user. (The directory-listing logo route can accept
+ * SVG precisely because Vercel Blob serves it from a foreign origin, where the
+ * same file is inert against us.) GIF is merely unnecessary rather than
+ * dangerous; adding it would be two more magic numbers here.
+ */
+export function sniffImageContentType(bytes) {
+    if (startsWith(bytes, PNG_MAGIC))
+        return "image/png";
+    if (startsWith(bytes, JPEG_MAGIC))
+        return "image/jpeg";
+    // WebP is a RIFF container: "RIFF" .... "WEBP"
+    if (bytes.byteLength >= 12
+        && startsWith(bytes, [0x52, 0x49, 0x46, 0x46])
+        && bytes[8] === 0x57
+        && bytes[9] === 0x45
+        && bytes[10] === 0x42
+        && bytes[11] === 0x50) {
+        return "image/webp";
+    }
+    return null;
+}
+export function imageExtensionFor(type) {
+    if (type === "image/png")
+        return "png";
+    if (type === "image/jpeg")
+        return "jpg";
+    return "webp";
+}
+/** The filenames the public serve route will answer to. Nothing else is addressable. */
+export const INBOX_AVATAR_FILE_NAMES = ["avatar.png", "avatar.jpg", "avatar.webp"];
+export function inboxAvatarFileNameFor(type) {
+    return `avatar.${imageExtensionFor(type)}`;
+}
+export function contentTypeForInboxAvatarFileName(name) {
+    if (name === "avatar.png")
+        return "image/png";
+    if (name === "avatar.jpg")
+        return "image/jpeg";
+    if (name === "avatar.webp")
+        return "image/webp";
+    return null;
+}
+/**
+ * How many leading bytes are enough to identify any supported format. Every
+ * magic number above lives in the first 12.
+ */
+export const IMAGE_SNIFF_BYTES = 32;
+/**
+ * The upload ceiling. Larger than the 2MB used for directory logos because this
+ * is a photo of a person, and phone cameras routinely produce 4–8MB files; a
+ * cap that rejects "the photo I just took" is a cap that gets worked around.
+ */
+export const MAX_INBOX_AVATAR_BYTES = 8 * 1024 * 1024;
+function startsWith(bytes, magic) {
+    if (bytes.byteLength < magic.length)
+        return false;
+    return magic.every((value, index) => bytes[index] === value);
+}

package/node_modules/@oxygen/shared/dist/import-limits.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Import size ceilings, in a module the BROWSER can import.
+ *
+ * They would naturally live next to the parser (`file-import.ts`) and the plan
+ * matrix (`plan-limits.ts`), but neither is client-safe: file-import pulls in
+ * `node:path` and the XLSX reader at module scope, and plan-limits is reached
+ * through the shared barrel. The import modal has to know these numbers to
+ * refuse an oversize file BEFORE uploading it — which is the whole point, since
+ * the failure it replaces was an upload that died with nothing to say. So the
+ * constants live here alone, and both of those modules re-export them, keeping
+ * one definition rather than a copy that drifts.
+ */
+/**
+ * Formats that must be held in memory to parse at all — a JSON array has no
+ * record boundary to stream from, and XLSX is a zip container. CSV and JSONL
+ * stream, so only these two are capped this low.
+ */
+export declare const MAX_BUFFERED_IMPORT_PARSE_BYTES: number;
+/**
+ * The platform's request-body ceiling — infrastructure, not a plan limit.
+ *
+ * Anything sent through a serverless function is cut off here before any handler
+ * runs, which is why a large import uploads straight to object storage instead.
+ * Kept slightly under the real ~4.5MB so a body plus its multipart framing fits.
+ */
+export declare const VERCEL_REQUEST_BODY_LIMIT_BYTES: number;
+/** True for the formats that cannot stream and so carry the buffered ceiling. */
+export declare function isBufferedOnlyImportFormat(format: string): boolean;

package/node_modules/@oxygen/shared/dist/import-limits.js

@@ -0,0 +1,30 @@
+/**
+ * Import size ceilings, in a module the BROWSER can import.
+ *
+ * They would naturally live next to the parser (`file-import.ts`) and the plan
+ * matrix (`plan-limits.ts`), but neither is client-safe: file-import pulls in
+ * `node:path` and the XLSX reader at module scope, and plan-limits is reached
+ * through the shared barrel. The import modal has to know these numbers to
+ * refuse an oversize file BEFORE uploading it — which is the whole point, since
+ * the failure it replaces was an upload that died with nothing to say. So the
+ * constants live here alone, and both of those modules re-export them, keeping
+ * one definition rather than a copy that drifts.
+ */
+/**
+ * Formats that must be held in memory to parse at all — a JSON array has no
+ * record boundary to stream from, and XLSX is a zip container. CSV and JSONL
+ * stream, so only these two are capped this low.
+ */
+export const MAX_BUFFERED_IMPORT_PARSE_BYTES = 10 * 1024 * 1024;
+/**
+ * The platform's request-body ceiling — infrastructure, not a plan limit.
+ *
+ * Anything sent through a serverless function is cut off here before any handler
+ * runs, which is why a large import uploads straight to object storage instead.
+ * Kept slightly under the real ~4.5MB so a body plus its multipart framing fits.
+ */
+export const VERCEL_REQUEST_BODY_LIMIT_BYTES = 4 * 1024 * 1024;
+/** True for the formats that cannot stream and so carry the buffered ceiling. */
+export function isBufferedOnlyImportFormat(format) {
+    return format === "json" || format === "xlsx";
+}

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

@@ -35,6 +35,7 @@ export * from "./linkedin-post-url.js";
 export * from "./linkedin-quota-denial.js";
 export * from "./linkedin-url.js";
 export * from "./linkedin-sequences.js";
+export * from "./member-columns.js";
 export * from "./microsoft-consent-url.js";
 export * from "./networks.js";
 export * from "./recipes.js";
@@ -46,6 +47,7 @@ export * from "./call-outcomes.js";
 export * from "./dial-guardrail-overrides.js";
 export * from "./sequences.js";
 export * from "./suppression-entries.js";
+export * from "./dnc-identities.js";
 export * from "./table-limits.js";
 export * from "./log.js";
 export * from "./axiom-field-budget.js";

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

@@ -35,6 +35,7 @@ export * from "./linkedin-post-url.js";
 export * from "./linkedin-quota-denial.js";
 export * from "./linkedin-url.js";
 export * from "./linkedin-sequences.js";
+export * from "./member-columns.js";
 export * from "./microsoft-consent-url.js";
 export * from "./networks.js";
 export * from "./recipes.js";
@@ -46,6 +47,7 @@ export * from "./call-outcomes.js";
 export * from "./dial-guardrail-overrides.js";
 export * from "./sequences.js";
 export * from "./suppression-entries.js";
+export * from "./dnc-identities.js";
 export * from "./table-limits.js";
 export * from "./log.js";
 export * from "./axiom-field-budget.js";