@oxygen-agent/cli 1.45.4 → 1.50.37

package/dist/local-custom-http-column.d.ts

@@ -6,4 +6,3 @@ type LocalColumnRunOptions = {
 };
 export declare function runLocalCustomHttpColumn(table: string, columnKeyOrId: string, options: LocalColumnRunOptions): Promise<Record<string, unknown>>;
 export {};
-//# sourceMappingURL=local-custom-http-column.d.ts.map

package/dist/local-custom-http-column.js

@@ -387,7 +387,7 @@ async function readLocalHttpResponseBody(response) {
     if (!text)
         return null;
     const contentType = response.headers.get("content-type") ?? "";
-    const looksJson = contentType.toLowerCase().includes("json") || /^[\s\n\r]*[\[{]/.test(text);
+    const looksJson = contentType.toLowerCase().includes("json") || /^[\s\n\r]*[\[{]/.test(text); // skipcq: JS-0097
     if (!looksJson)
         return text;
     try {
@@ -568,4 +568,3 @@ function isNonEmptyLocalValue(value) {
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-//# sourceMappingURL=local-custom-http-column.js.map

package/dist/session.d.ts

@@ -54,4 +54,3 @@ export declare function addSessionOutput(input: {
 export declare function getSessionUsage(input: {
     sessionId?: string | null;
 }): Record<string, unknown>;
-//# sourceMappingURL=session.d.ts.map

package/dist/session.js

@@ -191,4 +191,3 @@ function isSession(value) {
         && Array.isArray(record.statuses)
         && Array.isArray(record.outputs);
 }
-//# sourceMappingURL=session.js.map

package/dist/update.d.ts

@@ -0,0 +1,31 @@
+import { spawnSync } from "node:child_process";
+type SpawnResult = ReturnType<typeof spawnSync>;
+type SpawnSyncLike = (command: string, args: string[], options: {
+    encoding: BufferEncoding;
+    env: NodeJS.ProcessEnv;
+    stdio: "inherit" | ["ignore", "pipe", "pipe"];
+    windowsHide: boolean;
+    windowsVerbatimArguments?: boolean;
+}) => SpawnResult;
+export type UpdateOptions = {
+    json?: boolean;
+    package?: string;
+    dryRun?: boolean;
+};
+export type UpdateResult = {
+    current_version: string;
+    package: string;
+    command: string;
+    dry_run: boolean;
+    updated: boolean;
+};
+export declare function updateCli(options: UpdateOptions, runtime?: {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    modulePath?: string;
+    spawnSync?: SpawnSyncLike;
+}): UpdateResult;
+export declare function detectCliInstallPrefix(modulePath?: string): string | null;
+export declare function detectCliInstallPrefixFromPath(modulePath: string): string | null;
+export declare function resolveNpmExecutables(platform?: NodeJS.Platform): string[];
+export {};

package/dist/update.js

@@ -0,0 +1,116 @@
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { OXYGEN_VERSION, OxygenError } from "@oxygen/shared";
+const DEFAULT_CLI_PACKAGE_SPEC = "@oxygen-agent/cli@latest";
+export function updateCli(options, runtime = {}) {
+    const env = runtime.env ?? process.env;
+    const platform = runtime.platform ?? process.platform;
+    const spawn = runtime.spawnSync ?? spawnSync;
+    const packageSpec = readOption(options.package) ?? DEFAULT_CLI_PACKAGE_SPEC;
+    const prefix = detectCliInstallPrefix(runtime.modulePath);
+    const args = prefix
+        ? ["install", "-g", "--prefix", prefix, packageSpec]
+        : ["install", "-g", packageSpec];
+    // The command string is for human display (printed in dry-run / success
+    // output). Quote args that contain shell-significant characters so a
+    // copy-paste of the line works on install prefixes with spaces.
+    const command = ["npm", ...args].map(quoteForDisplay).join(" ");
+    if (options.dryRun) {
+        return {
+            current_version: OXYGEN_VERSION,
+            package: packageSpec,
+            command,
+            dry_run: true,
+            updated: false,
+        };
+    }
+    const attemptedExecutables = [];
+    let lastResult = null;
+    for (const invocation of resolveNpmInvocations(args, platform, env)) {
+        attemptedExecutables.push(invocation.label);
+        const result = spawn(invocation.executable, invocation.args, {
+            encoding: "utf8",
+            env,
+            stdio: options.json ? ["ignore", "pipe", "pipe"] : "inherit",
+            windowsHide: true,
+            // We pre-quote args for `cmd /d /s /c`; Node must not re-escape them
+            // or the install prefix path ends up with literal `"` characters
+            // baked in (see scripts/ci/cli-package-smoke.mjs for the same fix).
+            ...(platform === "win32" ? { windowsVerbatimArguments: true } : {}),
+        });
+        lastResult = result;
+        if (result.error && isMissingExecutableError(result.error))
+            continue;
+        if (!result.error && result.status === 0) {
+            return {
+                current_version: OXYGEN_VERSION,
+                package: packageSpec,
+                command,
+                dry_run: false,
+                updated: true,
+            };
+        }
+        break;
+    }
+    const result = lastResult;
+    throw new OxygenError("cli_update_failed", "Unable to update the Oxygen CLI.", {
+        details: {
+            command,
+            package: packageSpec,
+            exit_code: result?.status ?? null,
+            reason: result?.error instanceof Error ? result.error.message : null,
+            stderr: typeof result?.stderr === "string" && result.stderr.trim() ? result.stderr.trim().slice(0, 4000) : null,
+            attempted_executables: attemptedExecutables,
+        },
+        exitCode: 1,
+    });
+}
+export function detectCliInstallPrefix(modulePath = fileURLToPath(import.meta.url)) {
+    return detectCliInstallPrefixFromPath(modulePath);
+}
+export function detectCliInstallPrefixFromPath(modulePath) {
+    const normalizedPath = modulePath.replace(/\\/g, "/");
+    const markers = [
+        "/node_modules/@oxygen-agent/cli/dist/",
+        "/node_modules/@oxygen/cli/dist/",
+    ];
+    for (const marker of markers) {
+        const markerIndex = normalizedPath.lastIndexOf(marker);
+        if (markerIndex === -1)
+            continue;
+        const packageParent = normalizedPath.slice(0, markerIndex);
+        if (packageParent.endsWith("/lib"))
+            return packageParent.slice(0, -"/lib".length);
+        return packageParent;
+    }
+    return null;
+}
+export function resolveNpmExecutables(platform = process.platform) {
+    return platform === "win32" ? ["cmd.exe"] : ["npm"];
+}
+function readOption(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function isMissingExecutableError(error) {
+    return error.code === "ENOENT";
+}
+function resolveNpmInvocations(args, platform, env) {
+    if (platform !== "win32")
+        return [{ executable: "npm", args, label: "npm" }];
+    const shell = env.ComSpec?.trim() || "cmd.exe";
+    return [{
+            executable: shell,
+            args: ["/d", "/s", "/c", ["npm", ...args].map(quoteWindowsCmdArg).join(" ")],
+            label: shell,
+        }];
+}
+function quoteWindowsCmdArg(value) {
+    if (/^[A-Za-z0-9_@+=:,./\\-]+$/.test(value))
+        return value;
+    return `"${value.replace(/(["^&|<>()%])/g, "^$1")}"`;
+}
+function quoteForDisplay(value) {
+    if (/^[A-Za-z0-9_@+=:,./-]+$/.test(value))
+        return value;
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}

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

@@ -133,4 +133,3 @@ export type DefineDurableRecipeInput = DefineRecipeInput & {
 };
 export declare function defineRecipe(input: DefineRecipeInput): RecipeDefinition;
 export declare function isRecipeDefinition(value: unknown): value is RecipeDefinition;
-//# sourceMappingURL=index.d.ts.map

package/node_modules/@oxygen/recipe-sdk/dist/index.js

@@ -40,4 +40,3 @@ export function isRecipeDefinition(value) {
         && typeof value === "object"
         && value.__oxygen_recipe === true;
 }
-//# sourceMappingURL=index.js.map

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

@@ -108,7 +108,8 @@ export declare const ACTIVE_SUBSCRIPTION_STATUSES: readonly ["active", "trialing
 export type ActiveSubscriptionStatus = (typeof ACTIVE_SUBSCRIPTION_STATUSES)[number];
 export type ResolvedPricingPlan = PricingPlanDefinition;
 export declare function resolveBasePricingPlan(tier: string | null | undefined): ResolvedPricingPlan | null;
-export declare function applyPricingPlanMetadataOverrides(plan: PricingPlanDefinition, metadata: PricingPlanMetadata): PricingPlanDefinition;
+export declare function applyPricingPlanMetadataOverrides(// skipcq: JS-R1005
+plan: PricingPlanDefinition, metadata: PricingPlanMetadata): PricingPlanDefinition;
 export declare function isSelfServePlanTier(value: string): value is SelfServePlanTier;
 export declare function isBillingCurrency(value: string): value is BillingCurrency;
 export declare function normalizeBillingCurrency(value: string | null | undefined): BillingCurrency;
@@ -121,4 +122,3 @@ export declare function evaluateWeeklyQuota(usedCredits: number, requestedCredit
     projectedRemainingCredits: number;
     exceedsLimit: boolean;
 };
-//# sourceMappingURL=billing.d.ts.map

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

@@ -208,7 +208,8 @@ export function resolveBasePricingPlan(tier) {
     const legacy = LEGACY_PRICING_PLAN_OVERRIDES[tier];
     return legacy ?? null;
 }
-export function applyPricingPlanMetadataOverrides(plan, metadata) {
+export function applyPricingPlanMetadataOverrides(// skipcq: JS-R1005
+plan, metadata) {
     const record = readRecord(metadata);
     if (!record)
         return plan;
@@ -293,4 +294,3 @@ export function evaluateWeeklyQuota(usedCredits, requestedCredits, weeklyCredits
         exceedsLimit: projectedCredits > weeklyCreditsLimit,
     };
 }
-//# sourceMappingURL=billing.js.map

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

@@ -0,0 +1,60 @@
+/**
+ * Shared cell display formatter for CLI, MCP widgets, and the web app.
+ *
+ * One source of truth for how a stored cell value should look to a human.
+ * Storage stays untouched — this only decides what to render.
+ *
+ * Three responsibilities:
+ *  1. Format known-typed values consistently (numeric → 1,154; timestamp → ISO/short).
+ *  2. Rescue numeric-looking values that landed in a `text` column. Headcount
+ *     and similar fields routinely arrive as text from CSV imports, AI columns,
+ *     and provider adapters, so a `text` column whose values parse cleanly as
+ *     numbers still gets thousands grouping at display time.
+ *  3. Refuse to "rescue" things that aren't actually numbers (IP addresses,
+ *     version strings, phone numbers, URLs), via {@link looksLikeNumericText}.
+ */
+/** Surfaces have different escaping/length budgets, but the canonical string is shared. */
+export type CellFormatSurface = "cli" | "mcp" | "web";
+export type CellColumnLike = {
+    dataType?: string | null;
+    data_type?: string | null;
+    kind?: string | null;
+    label?: string | null;
+    key?: string | null;
+    semanticType?: string | null;
+    semantic_type?: string | null;
+};
+export type CellFormatOptions = {
+    surface: CellFormatSurface;
+    locale?: string;
+    /** When the value is rescued from a text column, callers can show a hint. */
+    onRescued?: (parsed: number) => void;
+};
+/**
+ * Canonical display string for a single cell.
+ *
+ * Returns `""` for null/undefined/empty so callers can treat the absence of
+ * a value as the absence of a string. Surface-specific concerns (HTML
+ * escaping, ellipsis budgets) belong outside this function.
+ */
+export declare function formatCellForDisplay(value: unknown, column: CellColumnLike | null | undefined, options: CellFormatOptions): string;
+/**
+ * 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.
+ * Returns `null` when the string is clearly *not* a single number — IP
+ * addresses, version strings, phone numbers, anything alphabetic.
+ */
+export declare function rescueNumericText(raw: string): number | null;
+/**
+ * True when a string is unambiguously numeric (integer, decimal, grouped, or
+ * a mangled dotted form we can recover). Exported for callers that want to
+ * highlight rescue cases without re-running the formatter.
+ */
+export declare function looksLikeNumericText(value: string): boolean;
+/**
+ * Decide whether the same value-level + column-level guards used inside
+ * `formatCellForDisplay`'s text path should rescue this string. Exposed so
+ * non-formatter callers (web grid, etc.) can stay in lockstep without
+ * duplicating the heuristic.
+ */
+export declare function tryRescueTextCell(value: string, column: CellColumnLike | null | undefined): number | null;

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

@@ -0,0 +1,278 @@
+/**
+ * Shared cell display formatter for CLI, MCP widgets, and the web app.
+ *
+ * One source of truth for how a stored cell value should look to a human.
+ * Storage stays untouched — this only decides what to render.
+ *
+ * Three responsibilities:
+ *  1. Format known-typed values consistently (numeric → 1,154; timestamp → ISO/short).
+ *  2. Rescue numeric-looking values that landed in a `text` column. Headcount
+ *     and similar fields routinely arrive as text from CSV imports, AI columns,
+ *     and provider adapters, so a `text` column whose values parse cleanly as
+ *     numbers still gets thousands grouping at display time.
+ *  3. Refuse to "rescue" things that aren't actually numbers (IP addresses,
+ *     version strings, phone numbers, URLs), via {@link looksLikeNumericText}.
+ */
+const DEFAULT_LOCALE = "en-US";
+const INTEGER_RE = /^-?\d{1,15}$/;
+const DECIMAL_RE = /^-?\d{1,15}(?:\.\d{1,9})?$/;
+const GROUPED_RE = /^-?\d{1,3}(?:,\d{3})+(?:\.\d+)?$/;
+// Matches strings that contain only digits and dots with at least two dots
+// (e.g. "0.0.1.154", "192.168.1.1"). Used to *detect*, not classify; the
+// numeric-rescue path then decides whether the parts can be safely joined.
+const DOTTED_NUMERIC_RE = /^[+-]?\d+(?:\.\d+){2,}$/;
+const ENRICHMENT_VALUE_KEYS = ["value", "text", "result"];
+// Column kinds whose cell shape is a wrapper object emitted by an enrichment,
+// tool, AI, action, or formula run — for these we unwrap the carried value.
+// Manual/source columns can also legitimately hold `{value: …, source: …}`
+// JSON data the user typed themselves; we leave those untouched.
+const WRAPPER_COLUMN_KINDS = new Set([
+    "enrichment",
+    "tool",
+    "tool_enrichment",
+    "ai",
+    "action",
+    "formula",
+    "relation",
+]);
+// Digit-only strings of this length or longer are far more likely to be
+// identifiers (US phone = 10, SSN/EIN/DUNS = 9, account numbers) than
+// headcount/revenue/etc. Headcount and similar fit comfortably under this.
+const IDENTIFIER_DIGIT_LENGTH = 10;
+// Column hints that strongly suggest the column holds identifiers (where
+// applying thousands grouping or stripping leading zeros would corrupt the
+// displayed value). Matched against `label`, `key`, and `semantic*` fields.
+// We use explicit non-alphanumeric boundaries rather than `\b` because `_` is
+// a JS word character, so `\bphone\b` would not match a `phone_number` key.
+const IDENTIFIER_COLUMN_RE = /(?:^|[^a-z0-9])(phone|mobile|tel(?:ephone)?|fax|zip|postal|postcode|ssn|ein|tin|vat|gst|iban|swift|duns|sku|upc|ean|isbn|imei|customer[_ -]?(?:no|number|id)|account[_ -]?(?:no|number|id))(?:$|[^a-z0-9])/i;
+/**
+ * Canonical display string for a single cell.
+ *
+ * Returns `""` for null/undefined/empty so callers can treat the absence of
+ * a value as the absence of a string. Surface-specific concerns (HTML
+ * escaping, ellipsis budgets) belong outside this function.
+ */
+export function formatCellForDisplay(value, column, options) {
+    if (value === null || value === undefined || value === "")
+        return "";
+    const dataType = readDataType(column);
+    const locale = options.locale ?? DEFAULT_LOCALE;
+    if (dataType === "boolean")
+        return formatBoolean(value, options.surface);
+    if (dataType === "timestamptz")
+        return formatTimestamp(value, options.surface);
+    if (dataType === "numeric")
+        return formatNumeric(value, locale, options.surface);
+    if (isEnrichmentPayload(value) && columnHasWrapperKind(column)) {
+        const wrapped = readEnrichmentValue(value);
+        if (wrapped !== undefined) {
+            return formatCellForDisplay(wrapped, column, options);
+        }
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? formatNumberValue(value, locale) : String(value);
+    }
+    if (typeof value === "string") {
+        const rescue = rescueNumericText(value);
+        if (rescue !== null
+            && shouldRescueColumn(column)
+            && !looksLikeBareIdentifierDigits(value.trim())) {
+            options.onRescued?.(rescue);
+            return formatNumberValue(rescue, locale);
+        }
+        return value;
+    }
+    if (typeof value === "object") {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    return String(value);
+}
+/**
+ * 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.
+ * Returns `null` when the string is clearly *not* a single number — IP
+ * addresses, version strings, phone numbers, anything alphabetic.
+ */
+export function rescueNumericText(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    if (INTEGER_RE.test(trimmed)) {
+        const n = Number(trimmed);
+        return Number.isFinite(n) ? n : null;
+    }
+    if (DECIMAL_RE.test(trimmed)) {
+        const n = Number(trimmed);
+        return Number.isFinite(n) ? n : null;
+    }
+    if (GROUPED_RE.test(trimmed)) {
+        const n = Number(trimmed.replace(/,/g, ""));
+        return Number.isFinite(n) ? n : null;
+    }
+    if (DOTTED_NUMERIC_RE.test(trimmed)) {
+        return decodeDottedNumeric(trimmed);
+    }
+    return null;
+}
+/**
+ * True when a digit-only string is shaped like an identifier — phone number,
+ * ZIP code with a preserved leading zero, SSN/EIN/DUNS, account or customer
+ * number. We refuse to rescue these even in numeric-looking text columns,
+ * because thousands-grouping (4155550123 → "4,155,550,123") or leading-zero
+ * stripping ("02101" → "2101") corrupts the displayed value.
+ */
+function looksLikeBareIdentifierDigits(trimmed) {
+    if (!/^\d+$/.test(trimmed))
+        return false;
+    if (trimmed.startsWith("0"))
+        return true;
+    return trimmed.length >= IDENTIFIER_DIGIT_LENGTH;
+}
+/**
+ * Decide whether a dotted-numeric string like `0.0.1.154` is a mangled integer
+ * (return 1154) or a real address/version (return null).
+ *
+ * Signature of a mangled number: ≥2 leading parts that are literally "0".
+ * That excludes real IPv4 ("192.168.1.1"), semver ("1.2.3"), and partial IPs
+ * ("10.0.0.1"), all of which have at most one leading zero group.
+ *
+ * Real headcount/revenue/employee values almost never start with multiple
+ * leading zeros — so this guard is conservative on the "don't break real IPs"
+ * side, while still recovering the screenshot's `0.0.1.154` shape.
+ */
+function decodeDottedNumeric(raw) {
+    const sign = raw.startsWith("-") ? -1 : 1;
+    const body = raw.replace(/^[+-]/, "");
+    const parts = body.split(".");
+    if (parts.length < 3)
+        return null;
+    let leadingZeros = 0;
+    for (const part of parts) {
+        if (part === "0")
+            leadingZeros += 1;
+        else
+            break;
+    }
+    if (leadingZeros < 2)
+        return null;
+    const concatenated = parts.join("");
+    if (!/^\d+$/.test(concatenated))
+        return null;
+    const normalized = concatenated.replace(/^0+(?=\d)/, "");
+    const n = Number(normalized || "0");
+    return Number.isFinite(n) ? sign * n : null;
+}
+/**
+ * True when a string is unambiguously numeric (integer, decimal, grouped, or
+ * a mangled dotted form we can recover). Exported for callers that want to
+ * highlight rescue cases without re-running the formatter.
+ */
+export function looksLikeNumericText(value) {
+    return rescueNumericText(value) !== null;
+}
+function readDataType(column) {
+    const raw = column?.dataType ?? column?.data_type ?? null;
+    if (!raw)
+        return null;
+    if (raw === "text" || raw === "numeric" || raw === "boolean" || raw === "timestamptz") {
+        return raw;
+    }
+    return null;
+}
+/**
+ * Rescue only applies to columns that are reasonable to interpret numerically.
+ * Allowlist `text` and `numeric` explicitly — JSONB / unknown data types fall
+ * through (a stored string like `"123456789"` in a payload column shouldn't
+ * be silently regrouped). Also skip identifier-shaped columns (phone, ZIP,
+ * DUNS, etc.) where formatting would corrupt the displayed value, and skip
+ * when the column has no metadata at all.
+ */
+function shouldRescueColumn(column) {
+    if (!column)
+        return false;
+    const dataType = readDataType(column);
+    if (dataType !== "text" && dataType !== "numeric")
+        return false;
+    if (columnLooksLikeIdentifier(column))
+        return false;
+    return true;
+}
+/**
+ * Decide whether the same value-level + column-level guards used inside
+ * `formatCellForDisplay`'s text path should rescue this string. Exposed so
+ * non-formatter callers (web grid, etc.) can stay in lockstep without
+ * duplicating the heuristic.
+ */
+export function tryRescueTextCell(value, column) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    if (!shouldRescueColumn(column))
+        return null;
+    if (looksLikeBareIdentifierDigits(trimmed))
+        return null;
+    return rescueNumericText(trimmed);
+}
+function columnHasWrapperKind(column) {
+    const kind = column?.kind;
+    return typeof kind === "string" && WRAPPER_COLUMN_KINDS.has(kind);
+}
+function columnLooksLikeIdentifier(column) {
+    const hints = [column.label, column.key, column.semanticType, column.semantic_type];
+    for (const hint of hints) {
+        if (typeof hint === "string" && IDENTIFIER_COLUMN_RE.test(hint))
+            return true;
+    }
+    return false;
+}
+function formatNumberValue(value, locale) {
+    // `Intl.NumberFormat` defaults to `maximumFractionDigits: 3` which silently
+    // truncates real precision on financial / scientific values. Lift the cap
+    // so cells render exactly the digits the user stored.
+    return new Intl.NumberFormat(locale, { maximumFractionDigits: 20 }).format(value);
+}
+function formatNumeric(value, locale, _surface) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return formatNumberValue(value, locale);
+    }
+    if (typeof value === "string") {
+        const rescue = rescueNumericText(value);
+        if (rescue !== null)
+            return formatNumberValue(rescue, locale);
+        return value;
+    }
+    return String(value);
+}
+function formatBoolean(value, surface) {
+    const truthy = value === true || value === "true" || value === 1 || value === "1";
+    if (surface === "cli")
+        return truthy ? "true" : "false";
+    return truthy ? "Yes" : "No";
+}
+function formatTimestamp(value, surface) {
+    if (value instanceof Date) {
+        return surface === "web" ? value.toISOString().slice(0, 10) : value.toISOString();
+    }
+    if (typeof value !== "string")
+        return String(value);
+    const trimmed = value.trim();
+    const date = new Date(trimmed);
+    if (!Number.isFinite(date.getTime()))
+        return trimmed;
+    return surface === "web" ? date.toISOString().slice(0, 10) : date.toISOString();
+}
+function isEnrichmentPayload(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readEnrichmentValue(payload) {
+    for (const key of ENRICHMENT_VALUE_KEYS) {
+        if (key in payload)
+            return payload[key];
+    }
+    return undefined;
+}

package/node_modules/@oxygen/shared/dist/column-types.d.ts

@@ -51,5 +51,5 @@ export type CoercionResult = {
  * Used by column retype: every value must coerce or the retype is rejected so
  * the table is never left half-converted.
  */
-export declare function coerceValueForDataType(value: unknown, dataType: RetypeableDataType): CoercionResult;
-//# sourceMappingURL=column-types.d.ts.map
+export declare function coerceValueForDataType(// skipcq: JS-0045
+value: unknown, dataType: RetypeableDataType): CoercionResult;

package/node_modules/@oxygen/shared/dist/column-types.js

@@ -127,11 +127,12 @@ function isExcelSerialValue(value) {
  * Used by column retype: every value must coerce or the retype is rejected so
  * the table is never left half-converted.
  */
-export function coerceValueForDataType(value, dataType) {
+export function coerceValueForDataType(// skipcq: JS-0045
+value, dataType) {
     if (value === null || value === undefined || value === "") {
         return { ok: true, value: null };
     }
-    switch (dataType) {
+    switch (dataType) { // skipcq: JS-0047
         case "text":
             return { ok: true, value: typeof value === "string" ? value : String(value) };
         case "timestamptz": {
@@ -158,4 +159,3 @@ export function coerceValueForDataType(value, dataType) {
         }
     }
 }
-//# sourceMappingURL=column-types.js.map

package/node_modules/@oxygen/shared/dist/credit-guidance.d.ts

@@ -12,4 +12,3 @@ export declare function buildCreditGuidance(input: {
     headroomMultiplier?: number;
 }): CreditGuidance;
 export declare function recommendedCreditCeiling(estimatedCredits: number | null | undefined, headroomMultiplier?: number): number | null;
-//# sourceMappingURL=credit-guidance.d.ts.map

package/node_modules/@oxygen/shared/dist/credit-guidance.js

@@ -57,4 +57,3 @@ function normalizeCreditValue(value) {
 function roundCreditValue(value) {
     return Math.round(value * 1000) / 1000;
 }
-//# sourceMappingURL=credit-guidance.js.map

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

@@ -19,4 +19,3 @@ export declare function parseRowsText(text: string, format: Exclude<RowsFileForm
 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;
-//# sourceMappingURL=file-import.d.ts.map

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

@@ -92,7 +92,7 @@ export function normalizeRowsForNewTable(rows) {
 export function normalizeImportColumnKey(value) {
     const normalized = value
         .normalize("NFKD")
-        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/[\u0300-\u036f]/g, "") // skipcq: JS-0117
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, "_")
         .replace(/^_+|_+$/g, "")
@@ -229,4 +229,3 @@ function makeUniqueImportKey(label, taken) {
         exitCode: 1,
     });
 }
-//# sourceMappingURL=file-import.js.map

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

@@ -1,5 +1,6 @@
 export { OXYGEN_VERSION } from "./version.js";
 export * from "./billing.js";
+export * from "./cell-format.js";
 export * from "./column-types.js";
 export * from "./credit-guidance.js";
 export * from "./log.js";
@@ -42,4 +43,3 @@ export declare function failure(command: string, error: {
     details?: unknown;
 }, version?: string): CliFailure;
 export declare function toFailure(command: string, error: unknown, version?: string): CliFailure;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,6 +1,7 @@
 import { OXYGEN_VERSION } from "./version.js";
 export { OXYGEN_VERSION } from "./version.js";
 export * from "./billing.js";
+export * from "./cell-format.js";
 export * from "./column-types.js";
 export * from "./credit-guidance.js";
 export * from "./log.js";
@@ -46,4 +47,3 @@ export function toFailure(command, error, version = OXYGEN_VERSION) {
     }
     return failure(command, { code: "unexpected_error", message: "An unexpected error occurred." }, version);
 }
-//# sourceMappingURL=index.js.map

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

@@ -19,4 +19,3 @@ export declare function getLogContext(): LogContext;
 export declare function log(level: LogLevel, msg: string, fields?: Record<string, unknown>): void;
 export declare function errorId(err: unknown): string;
 export declare function errorFields(err: unknown): Record<string, unknown>;
-//# sourceMappingURL=log.d.ts.map