@keystrokehq/snowflake 0.0.16 → 0.0.17

package/dist/pipes/index.d.mts

@@ -1,119 +0,0 @@
-import { SnowflakeClient } from "../client/index.mjs";
-import { d as HydratedRow } from "../statements-DJL0qVNA.mjs";
-import { CatalogResult, ShowScopedOptions, showPipes } from "../catalog/index.mjs";
-
-//#region src/pipes/index.d.ts
-interface PipeRef {
-  readonly database?: string;
-  readonly schema?: string;
-  readonly name: string;
-}
-interface PipeContext {
-  readonly warehouse?: string;
-  readonly role?: string;
-}
-interface CreatePipeOptions extends PipeRef, PipeContext {
-  readonly orReplace?: boolean;
-  readonly ifNotExists?: boolean;
-  readonly autoIngest?: boolean;
-  /** S3 SNS topic ARN (AUTO_INGEST buckets sending SNS notifications). */
-  readonly awsSnsTopic?: string;
-  /** Notification integration for GCS / Azure Event Grid ingest. */
-  readonly integration?: string;
-  /** Notification integration that receives ERRORS (Snowflake error-integration object). */
-  readonly errorIntegration?: string;
-  readonly comment?: string;
-  /** The `COPY INTO ...` body that defines what this pipe loads. */
-  readonly copyStatement: string;
-}
-declare function createPipe(client: SnowflakeClient, options: CreatePipeOptions): Promise<void>;
-interface AlterPipeOptions extends PipeRef, PipeContext {
-  readonly setPipeExecutionPaused?: boolean;
-  readonly comment?: string;
-  readonly refresh?: {
-    readonly prefix?: string;
-    readonly modifiedAfter?: string;
-  };
-  readonly rename?: PipeRef;
-  readonly unset?: readonly string[];
-}
-declare function alterPipe(client: SnowflakeClient, options: AlterPipeOptions): Promise<void>;
-interface DropPipeOptions extends PipeRef, PipeContext {
-  readonly ifExists?: boolean;
-}
-declare function dropPipe(client: SnowflakeClient, options: DropPipeOptions): Promise<void>;
-interface DescribePipeOptions extends PipeRef, PipeContext {}
-declare function describePipe(client: SnowflakeClient, options: DescribePipeOptions): Promise<readonly HydratedRow[]>;
-/** Convenience for `ALTER PIPE name REFRESH ...`. */
-declare function refreshPipe(client: SnowflakeClient, options: PipeRef & PipeContext & {
-  readonly prefix?: string;
-  readonly modifiedAfter?: string;
-}): Promise<void>;
-interface SnowpipeInsertFile {
-  readonly path: string;
-  readonly size?: number | bigint;
-}
-interface InsertFilesOptions extends PipeRef {
-  readonly files: readonly SnowpipeInsertFile[];
-  readonly requestId?: string;
-}
-interface InsertFilesResponse {
-  readonly requestId: string;
-  /** Server-reported ingest batch id (`pipe` field per Snowflake docs). */
-  readonly pipe?: string;
-  readonly responseCode?: string;
-  readonly message?: string;
-  readonly skippedFiles?: readonly {
-    readonly path: string;
-    readonly reason?: string;
-  }[];
-}
-declare function insertFiles(client: SnowflakeClient, options: InsertFilesOptions): Promise<InsertFilesResponse>;
-interface InsertReportOptions extends PipeRef {
-  readonly beginMark?: string;
-  readonly requestId?: string;
-}
-interface InsertReportResponse {
-  readonly pipe?: string;
-  readonly completeResult?: boolean;
-  readonly nextBeginMark?: string;
-  readonly files?: readonly {
-    readonly path: string;
-    readonly stageLocation?: string;
-    readonly fileSize?: number;
-    readonly timeReceived?: string;
-    readonly lastInsertTime?: string;
-    readonly rowsInserted?: number;
-    readonly rowsParsed?: number;
-    readonly errorsSeen?: number;
-    readonly errorLimit?: number;
-    readonly firstError?: string;
-    readonly status?: string;
-  }[];
-}
-declare function insertReport(client: SnowflakeClient, options: InsertReportOptions): Promise<InsertReportResponse>;
-interface LoadHistoryScanOptions extends PipeRef {
-  readonly startTimeInclusive: string;
-  readonly endTimeExclusive: string;
-  readonly requestId?: string;
-}
-interface LoadHistoryScanResponse {
-  readonly pipe?: string;
-  readonly completeResult?: boolean;
-  readonly files?: readonly {
-    readonly path: string;
-    readonly stageLocation?: string;
-    readonly fileSize?: number;
-    readonly timeReceived?: string;
-    readonly lastInsertTime?: string;
-    readonly rowsInserted?: number;
-    readonly rowsParsed?: number;
-    readonly errorsSeen?: number;
-    readonly errorLimit?: number;
-    readonly firstError?: string;
-    readonly status?: string;
-  }[];
-}
-declare function loadHistoryScan(client: SnowflakeClient, options: LoadHistoryScanOptions): Promise<LoadHistoryScanResponse>;
-//#endregion
-export { AlterPipeOptions, type CatalogResult, CreatePipeOptions, DescribePipeOptions, DropPipeOptions, InsertFilesOptions, InsertFilesResponse, InsertReportOptions, InsertReportResponse, LoadHistoryScanOptions, LoadHistoryScanResponse, PipeContext, PipeRef, type ShowScopedOptions, SnowpipeInsertFile, alterPipe, createPipe, describePipe, dropPipe, insertFiles, insertReport, loadHistoryScan, refreshPipe, showPipes };

package/dist/pipes/index.mjs

@@ -1,106 +0,0 @@
-import { executeSql } from "../sql/index.mjs";
-import { a as quoteLiteral, i as quoteIdentifier, t as buildFqn } from "../sql-safety-BZpAPsq6.mjs";
-import { showPipes } from "../catalog/index.mjs";
-
-//#region src/pipes/index.ts
-function pipeFqn(ref) {
-	return buildFqn(ref.database, ref.schema, ref.name);
-}
-function pipeRestPath(ref, required) {
-	if (required && (!ref.database || !ref.schema)) throw new Error("Snowpipe REST requires fully-qualified database.schema.pipe (provide `database` and `schema`)");
-	return [
-		ref.database,
-		ref.schema,
-		ref.name
-	].filter((segment) => segment !== void 0 && segment.length > 0).join(".");
-}
-async function createPipe(client, options) {
-	const prefix = `CREATE${options.orReplace ? " OR REPLACE" : ""} PIPE${options.ifNotExists ? " IF NOT EXISTS" : ""}`;
-	const auto = options.autoIngest ? " AUTO_INGEST = TRUE" : "";
-	const sns = options.awsSnsTopic ? ` AWS_SNS_TOPIC = ${quoteLiteral(options.awsSnsTopic)}` : "";
-	const integration = options.integration ? ` INTEGRATION = ${quoteLiteral(options.integration)}` : "";
-	const errorIntegration = options.errorIntegration ? ` ERROR_INTEGRATION = ${quoteIdentifier(options.errorIntegration)}` : "";
-	const comment = options.comment ? ` COMMENT = ${quoteLiteral(options.comment)}` : "";
-	await executeSql(client, {
-		statement: `${prefix} ${pipeFqn(options)}${auto}${sns}${integration}${errorIntegration}${comment} AS ${options.copyStatement}`,
-		warehouse: options.warehouse,
-		role: options.role
-	});
-}
-async function alterPipe(client, options) {
-	let tail;
-	if (options.rename) tail = `RENAME TO ${pipeFqn(options.rename)}`;
-	else if (options.refresh) tail = `REFRESH${options.refresh.prefix ? ` PREFIX = ${quoteLiteral(options.refresh.prefix)}` : ""}${options.refresh.modifiedAfter ? ` MODIFIED_AFTER = ${quoteLiteral(options.refresh.modifiedAfter)}` : ""}`;
-	else if (options.setPipeExecutionPaused !== void 0) tail = `SET PIPE_EXECUTION_PAUSED = ${options.setPipeExecutionPaused ? "TRUE" : "FALSE"}`;
-	else if (options.comment !== void 0) tail = `SET COMMENT = ${quoteLiteral(options.comment)}`;
-	else if (options.unset && options.unset.length > 0) tail = `UNSET ${options.unset.map((k) => k.toUpperCase()).join(", ")}`;
-	else throw new Error("alterPipe requires one of: rename / refresh / setPipeExecutionPaused / comment / unset");
-	await executeSql(client, {
-		statement: `ALTER PIPE ${pipeFqn(options)} ${tail}`,
-		warehouse: options.warehouse,
-		role: options.role
-	});
-}
-async function dropPipe(client, options) {
-	await executeSql(client, {
-		statement: `DROP PIPE${options.ifExists ? " IF EXISTS" : ""} ${pipeFqn(options)}`,
-		warehouse: options.warehouse,
-		role: options.role
-	});
-}
-async function describePipe(client, options) {
-	return (await executeSql(client, {
-		statement: `DESCRIBE PIPE ${pipeFqn(options)}`,
-		warehouse: options.warehouse,
-		role: options.role
-	})).rows;
-}
-/** Convenience for `ALTER PIPE name REFRESH ...`. */
-async function refreshPipe(client, options) {
-	await alterPipe(client, {
-		...options,
-		refresh: {
-			prefix: options.prefix,
-			modifiedAfter: options.modifiedAfter
-		}
-	});
-}
-async function insertFiles(client, options) {
-	if (options.files.length === 0) throw new Error("insertFiles requires at least one file");
-	const path = `/v1/data/pipes/${pipeRestPath(options, true)}/insertFiles`;
-	const body = { files: options.files.map((f) => ({
-		path: f.path,
-		...f.size !== void 0 ? { size: typeof f.size === "bigint" ? Number(f.size) : f.size } : {}
-	})) };
-	return client.request(path, {
-		method: "POST",
-		body,
-		requestId: options.requestId,
-		query: options.requestId ? { requestId: options.requestId } : void 0
-	});
-}
-async function insertReport(client, options) {
-	const path = `/v1/data/pipes/${pipeRestPath(options, true)}/insertReport`;
-	const query = {};
-	if (options.beginMark) query.beginMark = options.beginMark;
-	if (options.requestId) query.requestId = options.requestId;
-	return client.request(path, {
-		method: "GET",
-		query
-	});
-}
-async function loadHistoryScan(client, options) {
-	const path = `/v1/data/pipes/${pipeRestPath(options, true)}/loadHistoryScan`;
-	const query = {
-		startTimeInclusive: options.startTimeInclusive,
-		endTimeExclusive: options.endTimeExclusive
-	};
-	if (options.requestId) query.requestId = options.requestId;
-	return client.request(path, {
-		method: "GET",
-		query
-	});
-}
-
-//#endregion
-export { alterPipe, createPipe, describePipe, dropPipe, insertFiles, insertReport, loadHistoryScan, refreshPipe, showPipes };

package/dist/procedures/index.d.mts

@@ -1,61 +0,0 @@
-import { SnowflakeClient } from "../client/index.mjs";
-import { d as HydratedRow, v as SqlBinding } from "../statements-DJL0qVNA.mjs";
-import { ExecuteSqlResult } from "../sql/index.mjs";
-import { t as OptionMap } from "../sql-options-2k5xQ-oS.mjs";
-import { CatalogResult, ShowScopedOptions, showProcedures } from "../catalog/index.mjs";
-import { RowValue } from "../rows/index.mjs";
-
-//#region src/procedures/index.d.ts
-interface ProcedureRef {
-  readonly database?: string;
-  readonly schema?: string;
-  readonly name: string;
-}
-interface ProcedureContext {
-  readonly warehouse?: string;
-  readonly role?: string;
-}
-interface ProcedureArgument {
-  readonly name: string;
-  readonly type: string;
-  readonly defaultExpression?: string;
-}
-type ProcedureLanguage = 'SQL' | 'JAVASCRIPT' | 'PYTHON' | 'JAVA' | 'SCALA';
-type ExecuteAs = 'CALLER' | 'OWNER';
-interface CreateProcedureOptions extends ProcedureRef, ProcedureContext {
-  readonly orReplace?: boolean;
-  readonly ifNotExists?: boolean;
-  readonly secure?: boolean;
-  readonly arguments?: readonly ProcedureArgument[];
-  readonly returns: string;
-  readonly language?: ProcedureLanguage;
-  readonly executeAs?: ExecuteAs;
-  /** Additional keywords: `STRICT`, `IMMUTABLE`, `VOLATILE`, etc. */
-  readonly modifiers?: readonly string[];
-  /** Language-specific options: `RUNTIME_VERSION`, `PACKAGES`, `HANDLER`, `IMPORTS`. */
-  readonly options?: OptionMap;
-  readonly comment?: string;
-  readonly as: string;
-  readonly dollarQuotedBody?: boolean;
-}
-declare function createProcedure(client: SnowflakeClient, options: CreateProcedureOptions): Promise<void>;
-interface DropProcedureOptions extends ProcedureRef, ProcedureContext {
-  readonly ifExists?: boolean;
-  readonly arguments?: readonly ProcedureArgument[];
-}
-declare function dropProcedure(client: SnowflakeClient, options: DropProcedureOptions): Promise<void>;
-interface DescribeProcedureOptions extends ProcedureRef, ProcedureContext {
-  readonly arguments?: readonly ProcedureArgument[];
-}
-declare function describeProcedure(client: SnowflakeClient, options: DescribeProcedureOptions): Promise<readonly HydratedRow[]>;
-interface CallProcedureOptions extends ProcedureRef, ProcedureContext {
-  /** Positional arguments — every value flows through SQL API bindings (`?` placeholders). */
-  readonly arguments?: readonly RowValue[];
-  /** Pre-built bindings map (takes precedence over `arguments`). */
-  readonly bindings?: Readonly<Record<string, SqlBinding>>;
-  /** Raw SQL expression list when you need to pass a named function, subquery, or bind-unfriendly value. */
-  readonly rawArguments?: readonly string[];
-}
-declare function callProcedure(client: SnowflakeClient, options: CallProcedureOptions): Promise<ExecuteSqlResult<HydratedRow | readonly unknown[]>>;
-//#endregion
-export { CallProcedureOptions, type CatalogResult, CreateProcedureOptions, DescribeProcedureOptions, DropProcedureOptions, ExecuteAs, ProcedureArgument, ProcedureContext, ProcedureLanguage, ProcedureRef, type ShowScopedOptions, callProcedure, createProcedure, describeProcedure, dropProcedure, showProcedures };

package/dist/procedures/index.mjs

@@ -1,79 +0,0 @@
-import { executeSql } from "../sql/index.mjs";
-import { a as quoteLiteral, t as buildFqn } from "../sql-safety-BZpAPsq6.mjs";
-import { BindingBuilder } from "../rows/index.mjs";
-import { t as formatOptions } from "../sql-options-D6GEa21F.mjs";
-import { showProcedures } from "../catalog/index.mjs";
-
-//#region src/procedures/index.ts
-function renderArguments(args) {
-	if (!args || args.length === 0) return "()";
-	return `(${args.map((a) => {
-		const suffix = a.defaultExpression ? ` DEFAULT ${a.defaultExpression}` : "";
-		return `${a.name} ${a.type.toUpperCase()}${suffix}`;
-	}).join(", ")})`;
-}
-function renderArgumentTypes(args) {
-	if (!args || args.length === 0) return "()";
-	return `(${args.map((a) => a.type.toUpperCase()).join(", ")})`;
-}
-function renderBody(body, forceDollarQuoted, language) {
-	if (forceDollarQuoted ?? (language !== void 0 && language !== "SQL")) {
-		if (body.includes("$$")) throw new Error("Procedure body contains \"$$\"; cannot safely dollar-quote.");
-		return `$$${body}$$`;
-	}
-	return body;
-}
-async function createProcedure(client, options) {
-	const prefix = `CREATE${options.orReplace ? " OR REPLACE" : ""}${options.secure ? " SECURE" : ""} PROCEDURE${options.ifNotExists ? " IF NOT EXISTS" : ""}`;
-	const args = renderArguments(options.arguments);
-	const language = options.language ? ` LANGUAGE ${options.language}` : "";
-	const executeAs = options.executeAs ? ` EXECUTE AS ${options.executeAs}` : "";
-	const modifiers = options.modifiers && options.modifiers.length > 0 ? ` ${options.modifiers.map((m) => m.toUpperCase()).join(" ")}` : "";
-	const body = options.options && Object.keys(options.options).length > 0 ? ` ${formatOptions(options.options)}` : "";
-	const comment = options.comment ? ` COMMENT = ${quoteLiteral(options.comment)}` : "";
-	const rendered = renderBody(options.as, options.dollarQuotedBody, options.language);
-	await executeSql(client, {
-		statement: `${prefix} ${buildFqn(options.database, options.schema, options.name)}${args} RETURNS ${options.returns}${language}${executeAs}${modifiers}${body}${comment} AS ${rendered}`,
-		warehouse: options.warehouse,
-		role: options.role
-	});
-}
-async function dropProcedure(client, options) {
-	const fqn = buildFqn(options.database, options.schema, options.name);
-	await executeSql(client, {
-		statement: `DROP PROCEDURE${options.ifExists ? " IF EXISTS" : ""} ${fqn}${renderArgumentTypes(options.arguments)}`,
-		warehouse: options.warehouse,
-		role: options.role
-	});
-}
-async function describeProcedure(client, options) {
-	return (await executeSql(client, {
-		statement: `DESCRIBE PROCEDURE ${buildFqn(options.database, options.schema, options.name)}${renderArgumentTypes(options.arguments)}`,
-		warehouse: options.warehouse,
-		role: options.role
-	})).rows;
-}
-async function callProcedure(client, options) {
-	const fqn = buildFqn(options.database, options.schema, options.name);
-	if (options.rawArguments) return executeSql(client, {
-		statement: `CALL ${fqn}(${options.rawArguments.join(", ")})`,
-		warehouse: options.warehouse,
-		role: options.role,
-		bindings: options.bindings
-	});
-	const builder = new BindingBuilder();
-	const placeholders = (options.arguments ?? []).map((a) => builder.add(a));
-	const bindings = options.bindings ? {
-		...builder.toRecord(),
-		...options.bindings
-	} : builder.size() > 0 ? builder.toRecord() : void 0;
-	return executeSql(client, {
-		statement: `CALL ${fqn}(${placeholders.join(", ")})`,
-		warehouse: options.warehouse,
-		role: options.role,
-		bindings
-	});
-}
-
-//#endregion
-export { callProcedure, createProcedure, describeProcedure, dropProcedure, showProcedures };

package/dist/results/index.d.mts

@@ -1,16 +0,0 @@
-import { d as HydratedRow, m as ColumnMeta } from "../statements-DJL0qVNA.mjs";
-//#region src/results/index.d.ts
-/**
- * Hydrate a single positional row into an object keyed by column name.
- * Values are coerced per Snowflake type; unknown / unrepresentable values
- * are passed through verbatim.
- */
-declare function hydrateRow(row: readonly unknown[], columns: readonly ColumnMeta[]): HydratedRow;
-declare function hydrateRows(rows: readonly (readonly unknown[])[], columns: readonly ColumnMeta[]): HydratedRow[];
-/**
- * Coerce a single raw value (already in whatever shape Snowflake sent it
- * over the wire) into the nearest safe JS primitive / object.
- */
-declare function hydrateValue(raw: unknown, column: ColumnMeta): unknown;
-//#endregion
-export { hydrateRow, hydrateRows, hydrateValue };

package/dist/results/index.mjs

@@ -1,64 +0,0 @@
-//#region src/results/index.ts
-const MAX_SAFE_INT_AS_STRING = String(Number.MAX_SAFE_INTEGER);
-const MIN_SAFE_INT_AS_STRING = String(Number.MIN_SAFE_INTEGER);
-/**
-* Hydrate a single positional row into an object keyed by column name.
-* Values are coerced per Snowflake type; unknown / unrepresentable values
-* are passed through verbatim.
-*/
-function hydrateRow(row, columns) {
-	const hydrated = {};
-	for (let i = 0; i < columns.length; i += 1) {
-		const column = columns[i];
-		if (!column) continue;
-		hydrated[column.name] = hydrateValue(row[i], column);
-	}
-	return hydrated;
-}
-function hydrateRows(rows, columns) {
-	const hydrated = [];
-	for (const row of rows) hydrated.push(hydrateRow(row, columns));
-	return hydrated;
-}
-/**
-* Coerce a single raw value (already in whatever shape Snowflake sent it
-* over the wire) into the nearest safe JS primitive / object.
-*/
-function hydrateValue(raw, column) {
-	if (raw === null || raw === void 0) return null;
-	const type = column.type.toUpperCase();
-	if (typeof raw === "string") return coerceString(raw, type, column);
-	return raw;
-}
-function coerceString(raw, type, column) {
-	if (type === "BOOLEAN") return raw === "true" || raw === "1";
-	if (type === "FIXED") return coerceFixed(raw, column);
-	if (type === "REAL") {
-		const parsed = Number(raw);
-		return Number.isFinite(parsed) ? parsed : raw;
-	}
-	if (type === "BINARY") return raw;
-	if (type === "DATE" || type === "TIME" || type.startsWith("TIMESTAMP")) return raw;
-	if (type === "OBJECT" || type === "ARRAY" || type === "VARIANT") try {
-		return JSON.parse(raw);
-	} catch {
-		return raw;
-	}
-	return raw;
-}
-function coerceFixed(raw, column) {
-	if ((column.scale ?? 0) > 0) {
-		const parsed = Number(raw);
-		return Number.isFinite(parsed) ? parsed : raw;
-	}
-	if (isSafeInteger(raw)) return Number(raw);
-	return raw;
-}
-function isSafeInteger(value) {
-	if (!/^-?\d+$/u.test(value)) return false;
-	if (value.startsWith("-")) return value.length < MIN_SAFE_INT_AS_STRING.length || value.length === MIN_SAFE_INT_AS_STRING.length && value <= MIN_SAFE_INT_AS_STRING;
-	return value.length < MAX_SAFE_INT_AS_STRING.length || value.length === MAX_SAFE_INT_AS_STRING.length && value <= MAX_SAFE_INT_AS_STRING;
-}
-
-//#endregion
-export { hydrateRow, hydrateRows, hydrateValue };

package/dist/retry-B4-9MZIp.mjs

@@ -1,164 +0,0 @@
-//#region src/jwt.ts
-/**
-* Snowflake JWT signing + public-key fingerprint (RS256, key-pair auth).
-*
-* Isolate-safe — built on `globalThis.crypto.subtle`, no Node `crypto`
-* imports, no native SDKs. Works in Cloudflare Workers, Node 19+,
-* and any modern V8/JSC isolate.
-*
-* Reference: https://docs.snowflake.com/en/user-guide/key-pair-auth
-*/
-const DEFAULT_JWT_LIFETIME_SECONDS = 3300;
-async function createSnowflakeJwt(input) {
-	const now = Math.floor((input.now?.() ?? Date.now()) / 1e3);
-	const exp = now + (input.lifetimeSeconds ?? DEFAULT_JWT_LIFETIME_SECONDS);
-	const account = normalizeAccountForJwt(input.account).toUpperCase();
-	const user = input.user.toUpperCase();
-	const privateKey = await importRsaPrivateKey(input.privateKeyPem);
-	const fingerprint = input.publicKeyFingerprint ?? await derivePublicKeyFingerprint(privateKey);
-	const issuer = `${account}.${user}.${fingerprint}`;
-	const subject = `${account}.${user}`;
-	const header = {
-		alg: "RS256",
-		typ: "JWT"
-	};
-	const payload = {
-		iss: issuer,
-		sub: subject,
-		iat: now,
-		exp
-	};
-	const signingInput = `${base64UrlEncode(JSON.stringify(header))}.${base64UrlEncode(JSON.stringify(payload))}`;
-	const signature = await crypto.subtle.sign({ name: "RSASSA-PKCS1-v1_5" }, privateKey, new TextEncoder().encode(signingInput));
-	return {
-		token: `${signingInput}.${base64UrlEncode(new Uint8Array(signature))}`,
-		expiresAt: exp,
-		fingerprint,
-		issuer,
-		subject
-	};
-}
-/**
-* Compute `SHA256:<base64>` fingerprint over the DER-encoded SPKI public key
-* derived from the PKCS#8 private key. Matches Snowflake's
-* `RSA_PUBLIC_KEY_FP` value shown by `DESC USER`.
-*/
-async function derivePublicKeyFingerprint(privateKey) {
-	const publicKey = await extractPublicKey(privateKey);
-	const spkiDer = await crypto.subtle.exportKey("spki", publicKey);
-	const digest = await crypto.subtle.digest("SHA-256", spkiDer);
-	return `SHA256:${base64Encode(new Uint8Array(digest))}`;
-}
-async function extractPublicKey(privateKey) {
-	const jwk = await crypto.subtle.exportKey("jwk", privateKey);
-	const publicJwk = {
-		kty: jwk.kty,
-		n: jwk.n,
-		e: jwk.e,
-		alg: jwk.alg,
-		ext: true
-	};
-	return crypto.subtle.importKey("jwk", publicJwk, {
-		name: "RSASSA-PKCS1-v1_5",
-		hash: "SHA-256"
-	}, true, ["verify"]);
-}
-async function importRsaPrivateKey(pem) {
-	const armor = peekPemArmor(pem);
-	if (!armor) throw new TypeError("SNOWFLAKE_PRIVATE_KEY is not a PEM-encoded key.");
-	if (armor.type !== "PRIVATE KEY") throw new TypeError(`Unsupported PEM type "${armor.type}". Expected PKCS#8 PEM ("-----BEGIN PRIVATE KEY-----"). Convert PKCS#1 keys with \`openssl pkcs8 -topk8 -nocrypt\`.`);
-	return crypto.subtle.importKey("pkcs8", toArrayBuffer(base64Decode(armor.body)), {
-		name: "RSASSA-PKCS1-v1_5",
-		hash: "SHA-256"
-	}, true, ["sign"]);
-}
-function toArrayBuffer(view) {
-	const copy = new Uint8Array(view.byteLength);
-	copy.set(view);
-	return copy.buffer;
-}
-function peekPemArmor(pem) {
-	const match = pem.match(/-----BEGIN ([A-Z ]+)-----([\s\S]*?)-----END \1-----/u);
-	if (!match) return void 0;
-	const type = match[1]?.trim();
-	const body = match[2]?.replace(/\s+/gu, "");
-	if (!type || !body) return void 0;
-	return {
-		type,
-		body
-	};
-}
-/**
-* Account identifiers accepted by Snowflake take one of these shapes:
-*   - `orgname-accountname` (preferred)
-*   - `account_locator.region`
-*   - `account_locator.region.aws`
-*   - `account_locator` (legacy single-region)
-*
-* The JWT `iss`/`sub` require just the account segment (everything before the
-* first dot for locator-form identifiers) — the org-account hyphen form is
-* passed through as-is.
-*/
-function normalizeAccountForJwt(account) {
-	const trimmed = account.trim();
-	const firstDot = trimmed.indexOf(".");
-	return firstDot === -1 ? trimmed : trimmed.slice(0, firstDot);
-}
-function base64UrlEncode(input) {
-	return base64Encode(typeof input === "string" ? new TextEncoder().encode(input) : input).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
-}
-function base64Encode(bytes) {
-	let binary = "";
-	for (let i = 0; i < bytes.byteLength; i += 1) binary += String.fromCharCode(bytes[i] ?? 0);
-	if (typeof btoa === "function") return btoa(binary);
-	/* c8 ignore next */
-	return Buffer.from(bytes).toString("base64");
-}
-function base64Decode(input) {
-	if (typeof atob === "function") {
-		const binary = atob(input);
-		const bytes = new Uint8Array(binary.length);
-		for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
-		return bytes;
-	}
-	/* c8 ignore next */
-	return new Uint8Array(Buffer.from(input, "base64"));
-}
-
-//#endregion
-//#region src/retry.ts
-const DEFAULT_RETRY_POLICY = {
-	maxRetries: 4,
-	baseDelayMs: 500,
-	maxDelayMs: 2e4,
-	jitterMs: 250
-};
-const RETRYABLE_KINDS = new Set([
-	"rate_limit",
-	"server_error",
-	"timeout",
-	"network"
-]);
-function shouldRetry(kind, attempt, policy = DEFAULT_RETRY_POLICY) {
-	if (attempt >= policy.maxRetries) return false;
-	return RETRYABLE_KINDS.has(kind);
-}
-/**
-* Compute the delay (ms) before the next retry. If the server provided a
-* `Retry-After` header we respect it (clamped to `maxDelayMs`). Otherwise we
-* use `baseDelayMs * 2^attempt` with additive jitter, capped at `maxDelayMs`.
-*/
-function computeBackoffMs({ attempt, retryAfterMs, policy = DEFAULT_RETRY_POLICY, random = Math.random }) {
-	if (retryAfterMs !== void 0 && retryAfterMs >= 0) return Math.min(retryAfterMs, policy.maxDelayMs);
-	const exponent = Math.max(0, attempt - 1);
-	const base = policy.baseDelayMs * 2 ** exponent;
-	const jitter = policy.jitterMs > 0 ? random() * policy.jitterMs : 0;
-	return Math.min(policy.maxDelayMs, Math.floor(base + jitter));
-}
-async function defaultSleep(ms) {
-	if (ms <= 0) return;
-	await new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-//#endregion
-export { createSnowflakeJwt as a, shouldRetry as i, computeBackoffMs as n, defaultSleep as r, DEFAULT_RETRY_POLICY as t };

package/dist/retry-w7cTp1QL.d.mts

@@ -1,10 +0,0 @@
-//#region src/retry.d.ts
-interface RetryPolicy {
-  readonly maxRetries: number;
-  readonly baseDelayMs: number;
-  readonly maxDelayMs: number;
-  /** Adds up to `jitterMs` random ms on top of each backoff. */
-  readonly jitterMs: number;
-}
-//#endregion
-export { RetryPolicy as t };