mdorigin 0.1.8 → 0.2.0

package/README.md

@@ -108,6 +108,18 @@ mdorigin dev --root docs/site --search dist/search
 mdorigin build cloudflare --root docs/site --search dist/search
 ```
 
+For media-heavy sites that would exceed Worker bundle limits, build in external binary mode instead:
+
+```bash
+mdorigin build cloudflare --root docs/site --binary-mode external
+mdorigin sync cloudflare-r2 --dir dist/cloudflare --bucket <bucket-name>
+mdorigin init cloudflare --dir . --r2-bucket <bucket-name>
+```
+
+In this mode, markdown and other text stay embedded in the Worker bundle, smaller binaries are staged for Workers Static Assets, and oversized binaries are staged for R2.
+
+`mdorigin` ignores dotfiles and dot-directories during content traversal. `.gitignore` is not used to decide publish visibility.
+
 Runtime endpoints:
 
 - `/api/search?q=cloudflare+deploy`

package/dist/adapters/cloudflare.d.ts

@@ -1,22 +1,58 @@
-import { type ContentEntryKind } from '../core/content-store.js';
 import type { MdoPlugin } from '../core/extensions.js';
 import type { ResolvedSiteConfig } from '../core/site-config.js';
 import { type SearchBundleEntry } from '../search.js';
-export interface CloudflareManifestEntry {
+export interface TextCloudflareManifestEntry {
     path: string;
-    kind: ContentEntryKind;
+    kind: 'text';
     mediaType: string;
     text?: string;
+}
+export interface InlineBinaryCloudflareManifestEntry {
+    path: string;
+    kind: 'binary';
+    mediaType: string;
     base64?: string;
 }
+export interface ExternalBinaryCloudflareManifestEntry {
+    path: string;
+    kind: 'binary';
+    mediaType: string;
+    storageKind: 'assets' | 'r2';
+    storageKey: string;
+    byteSize: number;
+}
+export type CloudflareManifestEntry = TextCloudflareManifestEntry | InlineBinaryCloudflareManifestEntry | ExternalBinaryCloudflareManifestEntry;
+export interface CloudflareBundleRuntimeConfig {
+    binaryMode: 'inline' | 'external';
+    r2Binding?: string;
+}
 export interface CloudflareManifest {
     entries: CloudflareManifestEntry[];
     siteConfig?: ResolvedSiteConfig;
     searchEntries?: SearchBundleEntry[];
+    runtime?: CloudflareBundleRuntimeConfig;
 }
-export interface ExportedHandlerLike {
+export interface CloudflareAssetsBindingLike {
     fetch(request: Request): Promise<Response>;
 }
+export interface CloudflareR2ObjectBodyLike {
+    arrayBuffer(): Promise<ArrayBuffer>;
+}
+export interface CloudflareR2ObjectLike {
+    body: CloudflareR2ObjectBodyLike | ReadableStream | null;
+    arrayBuffer?: () => Promise<ArrayBuffer>;
+    httpEtag?: string;
+}
+export interface CloudflareR2BucketLike {
+    get(key: string): Promise<CloudflareR2ObjectLike | null>;
+}
+export interface CloudflareWorkerEnv {
+    ASSETS?: CloudflareAssetsBindingLike;
+    [binding: string]: unknown;
+}
+export interface ExportedHandlerLike {
+    fetch(request: Request, env?: CloudflareWorkerEnv, ctx?: unknown): Promise<Response>;
+}
 export interface CreateCloudflareWorkerOptions {
     plugins?: MdoPlugin[];
 }

package/dist/adapters/cloudflare.js

@@ -1,8 +1,9 @@
-import { MemoryContentStore, } from '../core/content-store.js';
+import { MemoryContentStore } from '../core/content-store.js';
 import { handleSiteRequest } from '../core/request-handler.js';
+import { resolveRequest } from '../core/router.js';
 import { createSearchApiFromBundle } from '../search.js';
 export function createCloudflareWorker(manifest, options = {}) {
-    const store = new MemoryContentStore(manifest.entries.map((entry) => {
+    const storeIndex = new MemoryContentStore(manifest.entries.map((entry) => {
         if (entry.kind === 'text') {
             return {
                 path: entry.path,
@@ -11,6 +12,13 @@ export function createCloudflareWorker(manifest, options = {}) {
                 text: entry.text ?? '',
             };
         }
+        if ('storageKind' in entry) {
+            return {
+                path: entry.path,
+                kind: 'binary',
+                mediaType: entry.mediaType,
+            };
+        }
         return {
             path: entry.path,
             kind: 'binary',
@@ -22,8 +30,13 @@ export function createCloudflareWorker(manifest, options = {}) {
         ? createSearchApiFromBundle(manifest.searchEntries)
         : undefined;
     return {
-        async fetch(request) {
+        async fetch(request, env) {
             const url = new URL(request.url);
+            const directBinaryResponse = await tryServeExternalBinary(manifest, request, env);
+            if (directBinaryResponse !== null) {
+                return directBinaryResponse;
+            }
+            const store = new CloudflareManifestContentStore(manifest, storeIndex, request, env);
             const siteResponse = await handleSiteRequest(store, url.pathname, {
                 draftMode: 'exclude',
                 siteConfig: manifest.siteConfig ?? {
@@ -33,16 +46,14 @@ export function createCloudflareWorker(manifest, options = {}) {
                     logo: undefined,
                     showDate: true,
                     showSummary: true,
-                    theme: 'paper',
-                    template: 'document',
                     topNav: [],
                     footerNav: [],
                     footerText: undefined,
                     socialLinks: [],
                     editLink: undefined,
                     showHomeIndex: true,
-                    catalogInitialPostCount: 10,
-                    catalogLoadMoreStep: 10,
+                    listingInitialPostCount: 10,
+                    listingLoadMoreStep: 10,
                     siteTitleConfigured: false,
                     siteDescriptionConfigured: false,
                 },
@@ -65,6 +76,151 @@ export function createCloudflareWorker(manifest, options = {}) {
         },
     };
 }
+async function tryServeExternalBinary(manifest, request, env) {
+    const resolved = resolveRequest(new URL(request.url).pathname);
+    if (resolved.kind !== 'asset' || !resolved.sourcePath) {
+        return null;
+    }
+    const manifestEntry = manifest.entries.find((entry) => entry.path === resolved.sourcePath && isExternalBinaryEntry(entry));
+    if (!manifestEntry) {
+        return null;
+    }
+    if (manifestEntry.storageKind === 'assets') {
+        const assetsBinding = env?.ASSETS;
+        if (!assetsBinding) {
+            throw new Error(`Cloudflare ASSETS binding is required to serve ${manifestEntry.path}.`);
+        }
+        const assetUrl = new URL(request.url);
+        assetUrl.pathname = `/${manifestEntry.storageKey}`;
+        return assetsBinding.fetch(new Request(assetUrl.toString(), request));
+    }
+    const bucket = env?.[manifest.runtime?.r2Binding ?? 'MDORIGIN_R2'];
+    if (!bucket) {
+        throw new Error(`Cloudflare R2 binding ${manifest.runtime?.r2Binding ?? 'MDORIGIN_R2'} is required to serve ${manifestEntry.path}.`);
+    }
+    const object = await bucket.get(manifestEntry.storageKey);
+    if (!object) {
+        return new Response('Not Found', {
+            status: 404,
+            headers: {
+                'content-type': 'text/plain; charset=utf-8',
+            },
+        });
+    }
+    const headers = new Headers({
+        'content-type': manifestEntry.mediaType,
+    });
+    if (object.httpEtag) {
+        headers.set('etag', object.httpEtag);
+    }
+    if (request.method === 'HEAD') {
+        return new Response(null, {
+            status: 200,
+            headers,
+        });
+    }
+    if (object.body instanceof ReadableStream) {
+        return new Response(object.body, {
+            status: 200,
+            headers,
+        });
+    }
+    if (object.body && 'arrayBuffer' in object.body) {
+        return new Response(await object.body.arrayBuffer(), {
+            status: 200,
+            headers,
+        });
+    }
+    if (typeof object.arrayBuffer === 'function') {
+        return new Response(await object.arrayBuffer(), {
+            status: 200,
+            headers,
+        });
+    }
+    return new Response(null, {
+        status: 200,
+        headers,
+    });
+}
+function isExternalBinaryEntry(entry) {
+    return entry.kind === 'binary' && 'storageKind' in entry;
+}
+class CloudflareManifestContentStore {
+    storeIndex;
+    request;
+    env;
+    entries;
+    runtime;
+    constructor(manifest, storeIndex, request, env) {
+        this.storeIndex = storeIndex;
+        this.request = request;
+        this.env = env;
+        this.entries = new Map(manifest.entries.map((entry) => [entry.path, entry]));
+        this.runtime = manifest.runtime;
+    }
+    async get(contentPath) {
+        const baseEntry = await this.storeIndex.get(contentPath);
+        if (baseEntry === null) {
+            return null;
+        }
+        const manifestEntry = this.entries.get(contentPath);
+        if (!manifestEntry || manifestEntry.kind === 'text') {
+            return baseEntry;
+        }
+        if (!('storageKind' in manifestEntry)) {
+            return baseEntry;
+        }
+        if (manifestEntry.storageKind === 'assets') {
+            const assetsBinding = this.env?.ASSETS;
+            if (!assetsBinding) {
+                throw new Error(`Cloudflare ASSETS binding is required to serve ${manifestEntry.path}.`);
+            }
+            const assetResponse = await assetsBinding.fetch(new Request(new URL(`/${manifestEntry.storageKey}`, this.request.url), {
+                method: 'GET',
+            }));
+            if (!assetResponse.ok) {
+                return null;
+            }
+            return {
+                path: manifestEntry.path,
+                kind: 'binary',
+                mediaType: manifestEntry.mediaType,
+                bytes: new Uint8Array(await assetResponse.arrayBuffer()),
+            };
+        }
+        const r2BindingName = this.findR2BindingName(manifestEntry);
+        const bucket = this.env?.[r2BindingName];
+        if (!bucket) {
+            throw new Error(`Cloudflare R2 binding ${r2BindingName} is required to serve ${manifestEntry.path}.`);
+        }
+        const object = await bucket.get(manifestEntry.storageKey);
+        if (!object) {
+            return null;
+        }
+        const arrayBuffer = typeof object.arrayBuffer === 'function'
+            ? await object.arrayBuffer()
+            : object.body instanceof ReadableStream
+                ? await new Response(object.body).arrayBuffer()
+                : object.body && 'arrayBuffer' in object.body
+                    ? await object.body.arrayBuffer()
+                    : new ArrayBuffer(0);
+        return {
+            path: manifestEntry.path,
+            kind: 'binary',
+            mediaType: manifestEntry.mediaType,
+            bytes: new Uint8Array(arrayBuffer),
+        };
+    }
+    async listDirectory(contentPath) {
+        return this.storeIndex.listDirectory(contentPath);
+    }
+    findR2BindingName(entry) {
+        if (entry.storageKind !== 'r2') {
+            return 'ASSETS';
+        }
+        return this.runtime?.r2Binding ?? 'MDORIGIN_R2';
+    }
+}
 function decodeBase64(value) {
     const decoded = atob(value);
     return Uint8Array.from(decoded, (character) => character.charCodeAt(0));

package/dist/adapters/node.js

@@ -1,7 +1,7 @@
 import { createServer } from 'node:http';
 import { readFile, readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { getMediaTypeForPath, isLikelyTextPath, normalizeContentPath, normalizeDirectoryPath, } from '../core/content-store.js';
+import { getMediaTypeForPath, isIgnoredContentName, isLikelyTextPath, normalizeContentPath, normalizeDirectoryPath, } from '../core/content-store.js';
 import { handleSiteRequest } from '../core/request-handler.js';
 export function createFileSystemContentStore(rootDir) {
     const resolvedRootDir = path.resolve(rootDir);
@@ -61,7 +61,7 @@ export function createFileSystemContentStore(rootDir) {
                 }
                 const entries = await readdir(directoryPath, { withFileTypes: true });
                 const resolvedEntries = await Promise.all(entries
-                    .filter((entry) => !entry.name.startsWith('.'))
+                    .filter((entry) => !isIgnoredContentName(entry.name))
                     .map(async (entry) => {
                     const childVisiblePath = normalizedPath === ''
                         ? entry.name

package/dist/cli/build-cloudflare.js

@@ -5,11 +5,11 @@ import { applySiteConfigFrontmatterDefaults, loadUserSiteConfig, } from '../core
 export async function runBuildCloudflareCommand(argv) {
     const args = parseArgs(argv);
     if (args.help) {
-        console.log('Usage: mdorigin build cloudflare --root <content-dir> [--out ./dist/cloudflare] [--config <config-file>] [--search ./dist/search]');
+        console.log('Usage: mdorigin build cloudflare --root <content-dir> [--out ./dist/cloudflare] [--config <config-file>] [--search ./dist/search] [--binary-mode inline|external] [--assets-max-bytes 26214400] [--r2-binding MDORIGIN_R2]');
         return;
     }
     if (!args.root) {
-        console.error('Usage: mdorigin build cloudflare --root <content-dir> [--out ./dist/cloudflare] [--config <config-file>] [--search ./dist/search]');
+        console.error('Usage: mdorigin build cloudflare --root <content-dir> [--out ./dist/cloudflare] [--config <config-file>] [--search ./dist/search] [--binary-mode inline|external] [--assets-max-bytes 26214400] [--r2-binding MDORIGIN_R2]');
         process.exitCode = 1;
         return;
     }
@@ -27,6 +27,9 @@ export async function runBuildCloudflareCommand(argv) {
         siteConfig,
         searchDir: args.search ? path.resolve(args.search) : undefined,
         configModulePath: loadedConfig.configModulePath,
+        binaryMode: args.binaryMode,
+        assetsMaxBytes: args.assetsMaxBytes,
+        r2Binding: args.r2Binding,
     });
     console.log(`cloudflare worker written to ${result.workerFile}`);
 }
@@ -59,6 +62,28 @@ function parseArgs(argv) {
             index += 1;
             continue;
         }
+        if (argument === '--binary-mode' && nextValue) {
+            if (nextValue !== 'inline' && nextValue !== 'external') {
+                throw new Error(`Invalid binary mode for mdorigin build cloudflare: ${nextValue}`);
+            }
+            result.binaryMode = nextValue;
+            index += 1;
+            continue;
+        }
+        if (argument === '--assets-max-bytes' && nextValue) {
+            const parsed = Number.parseInt(nextValue, 10);
+            if (!Number.isFinite(parsed) || parsed <= 0) {
+                throw new Error(`Invalid value for --assets-max-bytes: ${nextValue}`);
+            }
+            result.assetsMaxBytes = parsed;
+            index += 1;
+            continue;
+        }
+        if (argument === '--r2-binding' && nextValue) {
+            result.r2Binding = nextValue;
+            index += 1;
+            continue;
+        }
         throw new Error(`Unknown argument for mdorigin build cloudflare: ${argument}`);
     }
     return result;

package/dist/cli/help.js

@@ -3,8 +3,9 @@ export const ROOT_USAGE_LINES = [
     '  mdorigin dev --root <content-dir> [--port 3000] [--config <config-file>] [--search ./dist/search]',
     '  mdorigin build index (--root <content-dir> | --dir <content-dir>) [--config <config-file>]',
     '  mdorigin build search --root <content-dir> [--out ./dist/search] [--embedding-backend model2vec|hashing] [--model sentence-transformers/all-MiniLM-L6-v2] [--config <config-file>]',
-    '  mdorigin build cloudflare --root <content-dir> [--out ./dist/cloudflare] [--config <config-file>] [--search ./dist/search]',
-    '  mdorigin init cloudflare [--dir .] [--entry ./dist/cloudflare/worker.mjs] [--name <worker-name>] [--compatibility-date 2026-03-20] [--force]',
+    '  mdorigin build cloudflare --root <content-dir> [--out ./dist/cloudflare] [--config <config-file>] [--search ./dist/search] [--binary-mode inline|external] [--assets-max-bytes 26214400] [--r2-binding MDORIGIN_R2]',
+    '  mdorigin init cloudflare [--dir .] [--entry ./dist/cloudflare/worker.mjs] [--name <worker-name>] [--compatibility-date 2026-03-20] [--r2-bucket <bucket-name>] [--force]',
+    '  mdorigin sync cloudflare-r2 --dir ./dist/cloudflare --bucket <bucket-name> [--force]',
     '  mdorigin search --index <search-dir> [--top-k 10] <query>',
     '  mdorigin version',
     '',
@@ -16,11 +17,11 @@ export const BUILD_USAGE_LINES = [
     'Usage:',
     '  mdorigin build index (--root <content-dir> | --dir <content-dir>) [--config <config-file>]',
     '  mdorigin build search --root <content-dir> [--out ./dist/search] [--embedding-backend model2vec|hashing] [--model sentence-transformers/all-MiniLM-L6-v2] [--config <config-file>]',
-    '  mdorigin build cloudflare --root <content-dir> [--out ./dist/cloudflare] [--config <config-file>] [--search ./dist/search]',
+    '  mdorigin build cloudflare --root <content-dir> [--out ./dist/cloudflare] [--config <config-file>] [--search ./dist/search] [--binary-mode inline|external] [--assets-max-bytes 26214400] [--r2-binding MDORIGIN_R2]',
 ];
 export const INIT_USAGE_LINES = [
     'Usage:',
-    '  mdorigin init cloudflare [--dir .] [--entry ./dist/cloudflare/worker.mjs] [--name <worker-name>] [--compatibility-date 2026-03-20] [--force]',
+    '  mdorigin init cloudflare [--dir .] [--entry ./dist/cloudflare/worker.mjs] [--name <worker-name>] [--compatibility-date 2026-03-20] [--r2-bucket <bucket-name>] [--force]',
 ];
 export function printUsage(lines, error = false) {
     const output = lines.join('\n');

package/dist/cli/init-cloudflare.js

@@ -4,7 +4,7 @@ import { initCloudflareProject } from '../cloudflare.js';
 export async function runInitCloudflareCommand(argv) {
     const args = parseArgs(argv);
     if (args.help) {
-        console.log('Usage: mdorigin init cloudflare [--dir .] [--entry ./dist/cloudflare/worker.mjs] [--name <worker-name>] [--compatibility-date 2026-03-20] [--force]');
+        console.log('Usage: mdorigin init cloudflare [--dir .] [--entry ./dist/cloudflare/worker.mjs] [--name <worker-name>] [--compatibility-date 2026-03-20] [--r2-bucket <bucket-name>] [--force]');
         return;
     }
     const projectDir = path.resolve(args.dir ?? '.');
@@ -16,6 +16,7 @@ export async function runInitCloudflareCommand(argv) {
         workerName: args.name,
         siteTitle,
         compatibilityDate: args.compatibilityDate,
+        r2Bucket: args.r2Bucket,
         force: args.force,
     });
     console.log(`wrangler config written to ${result.configFile}`);
@@ -49,6 +50,11 @@ function parseArgs(argv) {
             index += 1;
             continue;
         }
+        if (argument === '--r2-bucket' && nextValue) {
+            result.r2Bucket = nextValue;
+            index += 1;
+            continue;
+        }
         if (argument === '--force') {
             result.force = true;
             continue;

package/dist/cli/main.js

@@ -9,6 +9,7 @@ import { runDevCommand } from './dev.js';
 import { BUILD_USAGE_LINES, INIT_USAGE_LINES, ROOT_USAGE_LINES, printUsage } from './help.js';
 import { runInitCloudflareCommand } from './init-cloudflare.js';
 import { runSearchCommand } from './search.js';
+import { runSyncCloudflareR2Command } from './sync-cloudflare-r2.js';
 async function main() {
     const argv = process.argv.slice(2);
     const [command, subcommand, ...rest] = argv;
@@ -62,6 +63,10 @@ async function main() {
         await runSearchCommand([subcommand, ...rest].filter(isDefined));
         return;
     }
+    if (command === 'sync' && subcommand === 'cloudflare-r2') {
+        await runSyncCloudflareR2Command(rest);
+        return;
+    }
     console.error(`Unknown command: ${argv.join(' ')}`);
     printUsage(ROOT_USAGE_LINES, true);
     process.exitCode = 1;

package/dist/cli/sync-cloudflare-r2.d.ts

@@ -0,0 +1 @@
+export declare function runSyncCloudflareR2Command(argv: string[]): Promise<void>;

package/dist/cli/sync-cloudflare-r2.js

@@ -0,0 +1,47 @@
+import path from 'node:path';
+import { syncCloudflareR2 } from '../cloudflare.js';
+export async function runSyncCloudflareR2Command(argv) {
+    const args = parseArgs(argv);
+    if (args.help) {
+        console.log('Usage: mdorigin sync cloudflare-r2 --dir ./dist/cloudflare --bucket <bucket-name> [--force]');
+        return;
+    }
+    if (!args.bucket) {
+        console.error('Usage: mdorigin sync cloudflare-r2 --dir ./dist/cloudflare --bucket <bucket-name> [--force]');
+        process.exitCode = 1;
+        return;
+    }
+    const result = await syncCloudflareR2({
+        dir: path.resolve(args.dir ?? 'dist/cloudflare'),
+        bucketName: args.bucket,
+        force: args.force,
+    });
+    console.log(`synced ${result.uploadedCount} R2 object(s), skipped ${result.skippedCount}, state written to ${result.stateFile}`);
+}
+function parseArgs(argv) {
+    const result = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        const nextValue = argv[index + 1];
+        if (argument === '--help' || argument === '-h') {
+            result.help = true;
+            continue;
+        }
+        if (argument === '--dir' && nextValue) {
+            result.dir = nextValue;
+            index += 1;
+            continue;
+        }
+        if (argument === '--bucket' && nextValue) {
+            result.bucket = nextValue;
+            index += 1;
+            continue;
+        }
+        if (argument === '--force') {
+            result.force = true;
+            continue;
+        }
+        throw new Error(`Unknown argument for mdorigin sync cloudflare-r2: ${argument}`);
+    }
+    return result;
+}

package/dist/cloudflare-runtime.d.ts

@@ -1,2 +1,2 @@
 export { createCloudflareWorker } from './adapters/cloudflare.js';
-export type { CloudflareManifest, CloudflareManifestEntry, ExportedHandlerLike, } from './adapters/cloudflare.js';
+export type { CloudflareBundleRuntimeConfig, CloudflareManifest, CloudflareManifestEntry, ExportedHandlerLike, } from './adapters/cloudflare.js';

package/dist/cloudflare.d.ts

@@ -1,34 +1,70 @@
-import type { CloudflareManifest, CloudflareManifestEntry } from './adapters/cloudflare.js';
+import type { CloudflareBundleRuntimeConfig, CloudflareManifest, CloudflareManifestEntry } from './adapters/cloudflare.js';
 import { createCloudflareWorker } from './adapters/cloudflare.js';
 import type { ResolvedSiteConfig } from './core/site-config.js';
 export { createCloudflareWorker };
-export type { CloudflareManifest, CloudflareManifestEntry };
+export type { CloudflareBundleRuntimeConfig, CloudflareManifest, CloudflareManifestEntry, };
+export type CloudflareBinaryMode = 'inline' | 'external';
 export interface BuildCloudflareManifestOptions {
     rootDir: string;
     siteConfig: ResolvedSiteConfig;
     searchDir?: string;
+    binaryMode?: CloudflareBinaryMode;
+    assetsMaxBytes?: number;
+    r2Binding?: string;
 }
-export interface WriteCloudflareBundleOptions {
-    rootDir: string;
+export interface WriteCloudflareBundleOptions extends BuildCloudflareManifestOptions {
     outDir: string;
-    siteConfig: ResolvedSiteConfig;
     packageImport?: string;
-    searchDir?: string;
     configModulePath?: string;
 }
+export interface CloudflareBundleMetadata {
+    version: 1;
+    workerEntry: string;
+    binaryMode: CloudflareBinaryMode;
+    assetsMaxBytes?: number;
+    assetsDir?: string;
+    r2Dir?: string;
+    r2Binding?: string;
+    siteTitle?: string;
+    r2Objects: Array<{
+        path: string;
+        mediaType: string;
+        storageKey: string;
+        file: string;
+        byteSize: number;
+    }>;
+}
 export interface InitCloudflareProjectOptions {
     projectDir: string;
     workerEntry: string;
     workerName?: string;
     siteTitle?: string;
     compatibilityDate?: string;
+    r2Bucket?: string;
+    force?: boolean;
+}
+export interface SyncCloudflareR2Options {
+    dir: string;
+    bucketName: string;
     force?: boolean;
+    runCommand?: typeof runWranglerCommand;
+}
+export interface SyncCloudflareR2Result {
+    uploadedCount: number;
+    skippedCount: number;
+    stateFile: string;
 }
 export declare function buildCloudflareManifest(options: BuildCloudflareManifestOptions): Promise<CloudflareManifest>;
 export declare function writeCloudflareBundle(options: WriteCloudflareBundleOptions): Promise<{
     manifest: CloudflareManifest;
     workerFile: string;
+    bundleFile: string;
 }>;
 export declare function initCloudflareProject(options: InitCloudflareProjectOptions): Promise<{
     configFile: string;
 }>;
+export declare function syncCloudflareR2(options: SyncCloudflareR2Options): Promise<SyncCloudflareR2Result>;
+declare function runWranglerCommand(command: string, args: string[]): {
+    status: number | null;
+    stderr: string;
+};