@coreframe/scripts 0.1.0 → 0.1.2

package/dist/deploy/migrations.js

@@ -1,203 +1,4 @@
-import { access, readFile, readdir } from "node:fs/promises";
-import { basename, join, relative, resolve } from "node:path";
-import { HELD_MIGRATIONS_FOLDER, MIGRATIONS_FOLDER } from "../db/config.js";
-const staticBlockedPatterns = [
-    {
-        code: "drop-schema-object",
-        pattern: /\bdrop\s+(?:table|view|materialized\s+view|index|sequence|type|schema|function|trigger|policy)\b/giu,
-        reason: "drops schema that the currently deployed app may still depend on",
-    },
-    {
-        code: "drop-column",
-        pattern: /\balter\s+table\b[^;]*?\bdrop\s+column\b/giu,
-        reason: "removes a column that the currently deployed app may still read or write",
-    },
-    {
-        code: "drop-constraint",
-        pattern: /\balter\s+table\b[^;]*?\bdrop\s+constraint\b/giu,
-        reason: "removes a constraint outside the staged contract phase",
-    },
-    {
-        code: "truncate",
-        pattern: /\btruncate\b/giu,
-        reason: "removes data outside the deploy-safe migration path",
-    },
-    {
-        code: "rename-table-or-column",
-        pattern: /\balter\s+table\b[^;]*?\brename(?:\s+column)?\b/giu,
-        reason: "renames schema in a way old and new app versions cannot both address",
-    },
-    {
-        code: "rewrite-column-type",
-        pattern: /\balter\s+table\b[^;]*?\balter\s+column\b[^;]*?\btype\b/giu,
-        reason: "rewrites a column type outside a staged expand/contract rollout",
-    },
-    {
-        code: "set-not-null",
-        pattern: /\balter\s+table\b[^;]*?\balter\s+column\b[^;]*?\bset\s+not\s+null\b/giu,
-        reason: "enforces NOT NULL before a separate backfill and verification step",
-    },
-    {
-        code: "set-default",
-        pattern: /\balter\s+table\b[^;]*?\balter\s+column\b[^;]*?\bset\s+default\b/giu,
-        reason: "changes default write behavior while old app code may still be running",
-    },
-    {
-        code: "broad-update",
-        pattern: /\bupdate\b/giu,
-        reason: "changes data outside a separately reviewed backfill or held migration",
-    },
-    {
-        code: "broad-delete",
-        pattern: /\bdelete\s+from\b/giu,
-        reason: "removes data outside a held migration",
-    },
-];
-export async function collectDeployMigrationFiles(cwd = process.cwd()) {
-    return collectDrizzleMigrationFiles(resolve(cwd, MIGRATIONS_FOLDER), cwd);
-}
-export async function collectHeldMigrationFiles(cwd = process.cwd()) {
-    return collectFlatSqlFiles(resolve(cwd, HELD_MIGRATIONS_FOLDER), cwd);
-}
-export async function scanDeployMigrationFiles(migrations) {
-    const results = await Promise.all(migrations.map(async (migration) => {
-        const sql = await readFile(migration.path, "utf8");
-        return {
-            migration,
-            risks: scanMigrationSql(sql),
-        };
-    }));
-    return results.filter((result) => result.risks.length > 0);
-}
-export function scanMigrationSql(sql) {
-    const maskedSql = maskSql(sql);
-    const createdTables = collectCreatedTables(maskedSql);
-    const risks = [];
-    for (const blocked of staticBlockedPatterns) {
-        for (const match of maskedSql.matchAll(blocked.pattern)) {
-            risks.push(riskForMatch(sql, match, blocked.code, blocked.reason));
-        }
-    }
-    for (const match of maskedSql.matchAll(/\balter\s+table\s+(?:if\s+exists\s+|only\s+)?(?<table>(?:"[^"]+"|\w+)(?:\s*\.\s*(?:"[^"]+"|\w+))?)\s+add\s+column\b[^;]*?\bnot\s+null\b/giu)) {
-        if (!createdTables.has(normalizeIdentifier(match.groups?.table))) {
-            risks.push(riskForMatch(sql, match, "add-not-null-column", "adds a required column to an existing table before a separate compatibility rollout"));
-        }
-    }
-    for (const match of maskedSql.matchAll(/\balter\s+table\s+(?:if\s+exists\s+|only\s+)?(?<table>(?:"[^"]+"|\w+)(?:\s*\.\s*(?:"[^"]+"|\w+))?)\s+add\s+constraint\b[^;]*?\b(?:foreign\s+key|unique|primary\s+key|check)\b/giu)) {
-        if (!createdTables.has(normalizeIdentifier(match.groups?.table))) {
-            risks.push(riskForMatch(sql, match, "add-constraint", "enforces a constraint on an existing table before a separate validation step"));
-        }
-    }
-    for (const match of maskedSql.matchAll(/\bcreate\s+unique\s+index(?:\s+concurrently)?(?:\s+if\s+not\s+exists)?\s+(?:"[^"]+"|\w+)\s+on\s+(?<table>(?:"[^"]+"|\w+)(?:\s*\.\s*(?:"[^"]+"|\w+))?)/giu)) {
-        if (!createdTables.has(normalizeIdentifier(match.groups?.table))) {
-            risks.push(riskForMatch(sql, match, "create-unique-index", "adds uniqueness to existing data before a separate dedupe and validation step"));
-        }
-    }
-    return risks.sort((left, right) => left.line - right.line || left.code.localeCompare(right.code));
-}
-export function formatMigrationScanFailures(results) {
-    return results
-        .flatMap((result) => result.risks.map((risk) => `${result.migration.relativePath}:${risk.line} ${risk.code}: ${risk.reason} (${risk.match.trim()})`))
-        .join("\n");
-}
-export function formatMigrationList(migrations) {
-    if (migrations.length === 0) {
-        return "No migration files found.";
-    }
-    return migrations.map((migration) => `- ${migration.relativePath}`).join("\n");
-}
-function collectCreatedTables(sql) {
-    const tables = new Set();
-    for (const match of sql.matchAll(/\bcreate\s+(?:temporary\s+|temp\s+)?table\s+(?:if\s+not\s+exists\s+)?(?<table>(?:"[^"]+"|\w+)(?:\s*\.\s*(?:"[^"]+"|\w+))?)/giu)) {
-        tables.add(normalizeIdentifier(match.groups?.table));
-    }
-    return tables;
-}
-async function collectDrizzleMigrationFiles(migrationsPath, cwd) {
-    const entries = await readDirectoryOrEmpty(migrationsPath);
-    const migrations = [];
-    for (const entry of entries) {
-        const entryPath = join(migrationsPath, entry.name);
-        if (entry.isDirectory()) {
-            const migrationPath = join(entryPath, "migration.sql");
-            if (await fileExists(migrationPath)) {
-                migrations.push(migrationFileFromPath(migrationPath, cwd, entry.name));
-            }
-            continue;
-        }
-        if (entry.isFile() && entry.name.endsWith(".sql")) {
-            migrations.push(migrationFileFromPath(entryPath, cwd, entry.name.replace(/\.sql$/u, "")));
-        }
-    }
-    return migrations.sort((left, right) => left.id.localeCompare(right.id));
-}
-async function collectFlatSqlFiles(directory, cwd) {
-    const entries = await readDirectoryOrEmpty(directory);
-    const migrations = entries
-        .filter((entry) => entry.isFile() && entry.name.endsWith(".sql"))
-        .map((entry) => migrationFileFromPath(join(directory, entry.name), cwd, entry.name.replace(/\.sql$/u, "")));
-    return migrations.sort((left, right) => left.id.localeCompare(right.id));
-}
-async function readDirectoryOrEmpty(directory) {
-    try {
-        return await readdir(directory, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-            return [];
-        }
-        throw error;
-    }
-}
-async function fileExists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-            return false;
-        }
-        throw error;
-    }
-}
-function migrationFileFromPath(path, cwd, id = basename(path, ".sql")) {
-    return {
-        id,
-        path,
-        relativePath: relative(cwd, path),
-    };
-}
-function maskSql(sql) {
-    return sql
-        .replace(/--[^\n\r]*/gu, blank)
-        .replace(/\/\*[\s\S]*?\*\//gu, blank)
-        .replace(/\$([A-Za-z_][A-Za-z0-9_]*)?\$[\s\S]*?\$\1\$/gu, blank)
-        .replace(/'(?:''|[^'])*'/gu, blank);
-}
-function blank(match) {
-    return match.replace(/[^\n\r]/gu, " ");
-}
-function normalizeIdentifier(identifier) {
-    return ((identifier ?? "")
-        .split(".")
-        .map((part) => part.trim().replace(/^"|"$/gu, "").toLowerCase())
-        .at(-1) ?? "");
-}
-function riskForMatch(sql, match, code, reason) {
-    return {
-        code,
-        line: lineForIndex(sql, match.index ?? 0),
-        match: sql.slice(match.index ?? 0, (match.index ?? 0) + match[0].length),
-        reason,
-    };
-}
-function lineForIndex(value, index) {
-    let line = 1;
-    for (let offset = 0; offset < index; offset += 1) {
-        if (value[offset] === "\n") {
-            line += 1;
-        }
-    }
-    return line;
-}
+import{HELD_MIGRATIONS_FOLDER as e,MIGRATIONS_FOLDER as t}from"../db/config.js";import{access as n,readFile as r,readdir as i}from"node:fs/promises";import{basename as a,join as o,relative as s,resolve as c}from"node:path";const l=[{code:`drop-schema-object`,pattern:/\bdrop\s+(?:table|view|materialized\s+view|index|sequence|type|schema|function|trigger|policy)\b/giu,reason:`drops schema that the currently deployed app may still depend on`},{code:`drop-column`,pattern:/\balter\s+table\b[^;]*?\bdrop\s+column\b/giu,reason:`removes a column that the currently deployed app may still read or write`},{code:`drop-constraint`,pattern:/\balter\s+table\b[^;]*?\bdrop\s+constraint\b/giu,reason:`removes a constraint outside the staged contract phase`},{code:`truncate`,pattern:/\btruncate\b/giu,reason:`removes data outside the deploy-safe migration path`},{code:`rename-table-or-column`,pattern:/\balter\s+table\b[^;]*?\brename(?:\s+column)?\b/giu,reason:`renames schema in a way old and new app versions cannot both address`},{code:`rewrite-column-type`,pattern:/\balter\s+table\b[^;]*?\balter\s+column\b[^;]*?\btype\b/giu,reason:`rewrites a column type outside a staged expand/contract rollout`},{code:`set-not-null`,pattern:/\balter\s+table\b[^;]*?\balter\s+column\b[^;]*?\bset\s+not\s+null\b/giu,reason:`enforces NOT NULL before a separate backfill and verification step`},{code:`set-default`,pattern:/\balter\s+table\b[^;]*?\balter\s+column\b[^;]*?\bset\s+default\b/giu,reason:`changes default write behavior while old app code may still be running`},{code:`broad-update`,pattern:/\bupdate\b/giu,reason:`changes data outside a separately reviewed backfill or held migration`},{code:`broad-delete`,pattern:/\bdelete\s+from\b/giu,reason:`removes data outside a held migration`}];async function u(e=process.cwd()){return _(c(e,t),e)}async function d(t=process.cwd()){return v(c(t,e),t)}async function f(e){return(await Promise.all(e.map(async e=>({migration:e,risks:p(await r(e.path,`utf8`))})))).filter(e=>e.risks.length>0)}function p(e){let t=S(e),n=g(t),r=[];for(let n of l)for(let i of t.matchAll(n.pattern))r.push(T(e,i,n.code,n.reason));for(let i of t.matchAll(/\balter\s+table\s+(?:if\s+exists\s+|only\s+)?(?<table>(?:"[^"]+"|\w+)(?:\s*\.\s*(?:"[^"]+"|\w+))?)\s+add\s+column\b[^;]*?\bnot\s+null\b/giu))n.has(w(i.groups?.table))||r.push(T(e,i,`add-not-null-column`,`adds a required column to an existing table before a separate compatibility rollout`));for(let i of t.matchAll(/\balter\s+table\s+(?:if\s+exists\s+|only\s+)?(?<table>(?:"[^"]+"|\w+)(?:\s*\.\s*(?:"[^"]+"|\w+))?)\s+add\s+constraint\b[^;]*?\b(?:foreign\s+key|unique|primary\s+key|check)\b/giu))n.has(w(i.groups?.table))||r.push(T(e,i,`add-constraint`,`enforces a constraint on an existing table before a separate validation step`));for(let i of t.matchAll(/\bcreate\s+unique\s+index(?:\s+concurrently)?(?:\s+if\s+not\s+exists)?\s+(?:"[^"]+"|\w+)\s+on\s+(?<table>(?:"[^"]+"|\w+)(?:\s*\.\s*(?:"[^"]+"|\w+))?)/giu))n.has(w(i.groups?.table))||r.push(T(e,i,`create-unique-index`,`adds uniqueness to existing data before a separate dedupe and validation step`));return r.sort((e,t)=>e.line-t.line||e.code.localeCompare(t.code))}function m(e){return e.flatMap(e=>e.risks.map(t=>`${e.migration.relativePath}:${t.line} ${t.code}: ${t.reason} (${t.match.trim()})`)).join(`
+`)}function h(e){return e.length===0?`No migration files found.`:e.map(e=>`- ${e.relativePath}`).join(`
+`)}function g(e){let t=new Set;for(let n of e.matchAll(/\bcreate\s+(?:temporary\s+|temp\s+)?table\s+(?:if\s+not\s+exists\s+)?(?<table>(?:"[^"]+"|\w+)(?:\s*\.\s*(?:"[^"]+"|\w+))?)/giu))t.add(w(n.groups?.table));return t}async function _(e,t){let n=await y(e),r=[];for(let i of n){let n=o(e,i.name);if(i.isDirectory()){let e=o(n,`migration.sql`);await b(e)&&r.push(x(e,t,i.name));continue}i.isFile()&&i.name.endsWith(`.sql`)&&r.push(x(n,t,i.name.replace(/\.sql$/u,``)))}return r.sort((e,t)=>e.id.localeCompare(t.id))}async function v(e,t){return(await y(e)).filter(e=>e.isFile()&&e.name.endsWith(`.sql`)).map(n=>x(o(e,n.name),t,n.name.replace(/\.sql$/u,``))).sort((e,t)=>e.id.localeCompare(t.id))}async function y(e){try{return await i(e,{withFileTypes:!0})}catch(e){if(e instanceof Error&&`code`in e&&e.code===`ENOENT`)return[];throw e}}async function b(e){try{return await n(e),!0}catch(e){if(e instanceof Error&&`code`in e&&e.code===`ENOENT`)return!1;throw e}}function x(e,t,n=a(e,`.sql`)){return{id:n,path:e,relativePath:s(t,e)}}function S(e){return e.replace(/--[^\n\r]*/gu,C).replace(/\/\*[\s\S]*?\*\//gu,C).replace(/\$([A-Za-z_][A-Za-z0-9_]*)?\$[\s\S]*?\$\1\$/gu,C).replace(/'(?:''|[^'])*'/gu,C)}function C(e){return e.replace(/[^\n\r]/gu,` `)}function w(e){return(e??``).split(`.`).map(e=>e.trim().replace(/^"|"$/gu,``).toLowerCase()).at(-1)??``}function T(e,t,n,r){return{code:n,line:E(e,t.index??0),match:e.slice(t.index??0,(t.index??0)+t[0].length),reason:r}}function E(e,t){let n=1;for(let r=0;r<t;r+=1)e[r]===`
+`&&(n+=1);return n}export{u as collectDeployMigrationFiles,d as collectHeldMigrationFiles,h as formatMigrationList,m as formatMigrationScanFailures,f as scanDeployMigrationFiles,p as scanMigrationSql};

package/dist/deploy/pending-migrations.d.ts

@@ -1,5 +1,9 @@
-import type { CoreframeDatabaseClient, CoreframeDatabaseDialect } from "../db/client.ts";
-import type { MigrationFile } from "./migrations.ts";
-export declare function filterPendingMigrations(migrations: MigrationFile[], appliedNames: Iterable<string>): MigrationFile[];
-export declare function readAppliedMigrationNames(database: CoreframeDatabaseClient): Promise<Set<string>>;
-export declare function appliedMigrationsQuery(dialect: CoreframeDatabaseDialect): "select name from drizzle.__drizzle_migrations where name is not null" | "select name from __drizzle_migrations where name is not null";
+import { DatabaseClient, DatabaseDialect } from "../db/client.js";
+import { MigrationFile } from "./migrations.js";
+
+//#region deploy/pending-migrations.d.ts
+declare function filterPendingMigrations(migrations: MigrationFile[], appliedNames: Iterable<string>): MigrationFile[];
+declare function readAppliedMigrationNames(database: DatabaseClient): Promise<Set<string>>;
+declare function appliedMigrationsQuery(dialect: DatabaseDialect): "select name from drizzle.__drizzle_migrations where name is not null" | "select name from __drizzle_migrations where name is not null";
+//#endregion
+export { appliedMigrationsQuery, filterPendingMigrations, readAppliedMigrationNames };

package/dist/deploy/pending-migrations.js

@@ -1,30 +1 @@
-export function filterPendingMigrations(migrations, appliedNames) {
-    const applied = new Set(appliedNames);
-    return migrations.filter((migration) => !applied.has(migration.id));
-}
-export async function readAppliedMigrationNames(database) {
-    try {
-        const result = await database.execute(appliedMigrationsQuery(database.dialect));
-        return new Set(result.rows.flatMap((row) => (row.name ? [row.name] : [])));
-    }
-    catch (error) {
-        if (isMissingMigrationTableError(error)) {
-            return new Set();
-        }
-        throw error;
-    }
-}
-export function appliedMigrationsQuery(dialect) {
-    switch (dialect) {
-        case "postgres":
-            return "select name from drizzle.__drizzle_migrations where name is not null";
-        case "sqlite":
-            return "select name from __drizzle_migrations where name is not null";
-    }
-}
-function isMissingMigrationTableError(error) {
-    return (error instanceof Error &&
-        (("code" in error && (error.code === "42P01" || error.code === "3F000")) ||
-            error.message.includes("no such table") ||
-            error.message.includes("no such schema")));
-}
+function e(e,t){let n=new Set(t);return e.filter(e=>!n.has(e.id))}async function t(e){try{let t=await e.execute(n(e.dialect));return new Set(t.rows.flatMap(e=>e.name?[e.name]:[]))}catch(e){if(r(e))return new Set;throw e}}function n(e){switch(e){case`postgres`:return`select name from drizzle.__drizzle_migrations where name is not null`;case`sqlite`:return`select name from __drizzle_migrations where name is not null`}}function r(e){return e instanceof Error&&(`code`in e&&(e.code===`42P01`||e.code===`3F000`)||e.message.includes(`no such table`)||e.message.includes(`no such schema`))}export{n as appliedMigrationsQuery,e as filterPendingMigrations,t as readAppliedMigrationNames};

package/dist/deploy/tauri-release.d.ts

@@ -1,85 +1,105 @@
-import type { TauriReleaseConfig, TauriReleasePlatform } from "./config.ts";
-export type TauriReleaseArgs = {
-    tauriLocalPlatforms: TauriReleasePlatform[];
-    tauriWorkflowPlatforms: TauriReleasePlatform[];
-    tauriWorkflowName?: string;
-    tauriWorkflowRef?: string;
+import { TauriReleaseConfig, TauriReleasePlatform } from "./config.js";
+
+//#region deploy/tauri-release.d.ts
+type TauriReleaseArgs = {
+  tauriLocalPlatforms: TauriReleasePlatform[];
+  tauriWorkflowPlatforms: TauriReleasePlatform[];
+  tauriWorkflowName?: string;
+  tauriWorkflowRef?: string;
 };
-export type TauriReleasePlan = {
-    artifactDownloadDir: string;
-    b2ApplicationKey?: string;
-    b2ApplicationKeyId?: string;
-    b2Bucket?: string;
-    enabled: boolean;
-    latestManifestPath: string;
-    localPlatforms: TauriReleasePlatform[];
-    platform: Record<TauriReleasePlatform, ResolvedTauriReleasePlatformConfig>;
-    publicBaseUrl?: string;
-    publicPathPrefix: string;
-    releaseNotesPath?: string;
-    releasePath: string;
-    releaseUploadDir: string;
-    signingPrivateKey?: string;
-    workflowName: string;
-    workflowPlatforms: TauriReleasePlatform[];
-    workflowPollIntervalMs: number;
-    workflowRef?: string;
-    workflowTimeoutMs: number;
+type TauriReleasePlan = {
+  artifactDownloadDir: string;
+  b2ApplicationKey?: string;
+  b2ApplicationKeyId?: string;
+  b2Bucket?: string;
+  enabled: boolean;
+  latestManifestPath: string;
+  localPlatforms: TauriReleasePlatform[];
+  platform: Record<TauriReleasePlatform, ResolvedTauriReleasePlatformConfig>;
+  publicBaseUrl?: string;
+  publicPathPrefix: string;
+  releaseNotesPath?: string;
+  releasePath: string;
+  releaseUploadDir: string;
+  signingPrivateKey?: string;
+  workflowName: string;
+  workflowPlatforms: TauriReleasePlatform[];
+  workflowPollIntervalMs: number;
+  workflowRef?: string;
+  workflowTimeoutMs: number;
 };
-export type TauriReleaseMetadataSnapshot = {
-    files: {
-        path: string;
-        source: string;
-    }[];
+type TauriReleaseMetadataSnapshot = {
+  files: {
+    path: string;
+    source: string;
+  }[];
 };
-export type PreparedTauriRelease = {
-    manifestPath: string;
-    uploadDir: string;
+type PreparedTauriRelease = {
+  manifestPath: string;
+  uploadDir: string;
 };
 type ResolvedTauriReleasePlatformConfig = {
-    artifactGlobs: string[];
-    buildArgs: string[];
-    targetTriple: string;
-    updatePlatform: string;
+  artifactGlobs: string[];
+  buildArgs: string[];
+  targetTriple: string;
+  updatePlatform: string;
 };
 type TauriUpdateManifest = {
-    notes?: string;
-    platforms: Record<string, {
-        signature: string;
-        url: string;
-    }>;
-    pub_date: string;
-    version: string;
+  notes?: string;
+  platforms: Record<string, {
+    signature: string;
+    url: string;
+  }>;
+  pub_date: string;
+  version: string;
 };
-export declare function parseTauriReleasePlatformList(value: string | undefined): ("macos" | "windows" | "linux" | "ios" | "android")[];
-export declare function parseTauriReleasePlatform(value: string): TauriReleasePlatform;
-export declare function resolveTauriReleasePlan({ args, config, env, }: {
-    args: TauriReleaseArgs;
-    config?: TauriReleaseConfig;
-    env: NodeJS.ProcessEnv;
+declare function parseTauriReleasePlatformList(value: string | undefined): ("macos" | "windows" | "linux" | "ios" | "android")[];
+declare function parseTauriReleasePlatform(value: string): TauriReleasePlatform;
+declare function resolveTauriReleasePlan({
+  args,
+  config,
+  env
+}: {
+  args: TauriReleaseArgs;
+  config?: TauriReleaseConfig;
+  env: NodeJS.ProcessEnv;
 }): TauriReleasePlan;
-export declare function validateTauriReleasePlan(plan: TauriReleasePlan, cwd?: string): Promise<void>;
-export declare function writeTauriReleaseMetadata(plan: TauriReleasePlan, version: string, cwd?: string): Promise<TauriReleaseMetadataSnapshot>;
-export declare function restoreTauriReleaseMetadata(snapshot: TauriReleaseMetadataSnapshot): Promise<void>;
-export declare function prepareTauriRelease({ env, plan, releaseName, version, }: {
-    env: NodeJS.ProcessEnv;
-    plan: TauriReleasePlan;
-    releaseName: string;
-    version: string;
+declare function validateTauriReleasePlan(plan: TauriReleasePlan, cwd?: string): Promise<void>;
+declare function writeTauriReleaseMetadata(plan: TauriReleasePlan, version: string, cwd?: string): Promise<TauriReleaseMetadataSnapshot>;
+declare function restoreTauriReleaseMetadata(snapshot: TauriReleaseMetadataSnapshot): Promise<void>;
+declare function prepareTauriRelease({
+  env,
+  plan,
+  releaseName,
+  version
+}: {
+  env: NodeJS.ProcessEnv;
+  plan: TauriReleasePlan;
+  releaseName: string;
+  version: string;
 }): Promise<PreparedTauriRelease | undefined>;
-export declare function uploadTauriReleaseToB2(plan: TauriReleasePlan, release: PreparedTauriRelease): Promise<void>;
-export declare function createTauriUpdateManifest({ artifacts, notes, pubDate, version, }: {
-    artifacts: {
-        signature: string;
-        updatePlatform: string;
-        url: string;
-    }[];
-    notes?: string;
-    pubDate?: Date;
-    version: string;
+declare function uploadTauriReleaseToB2(plan: TauriReleasePlan, release: PreparedTauriRelease): Promise<void>;
+declare function createTauriUpdateManifest({
+  artifacts,
+  notes,
+  pubDate,
+  version
+}: {
+  artifacts: {
+    signature: string;
+    updatePlatform: string;
+    url: string;
+  }[];
+  notes?: string;
+  pubDate?: Date;
+  version: string;
 }): TauriUpdateManifest;
-export declare function createTauriReleaseUpload({ plan, version, }: {
-    plan: TauriReleasePlan;
-    version: string;
+declare function createTauriReleaseUpload({
+  plan,
+  version
+}: {
+  plan: TauriReleasePlan;
+  version: string;
 }): Promise<PreparedTauriRelease>;
-export {};
+//#endregion
+export { PreparedTauriRelease, TauriReleaseArgs, TauriReleaseMetadataSnapshot, TauriReleasePlan, createTauriReleaseUpload, createTauriUpdateManifest, parseTauriReleasePlatform, parseTauriReleasePlatformList, prepareTauriRelease, resolveTauriReleasePlan, restoreTauriReleaseMetadata, uploadTauriReleaseToB2, validateTauriReleasePlan, writeTauriReleaseMetadata };