@funnelsgrove/cli 0.1.142 → 0.1.146

package/README.md

@@ -7,6 +7,17 @@ npm install -g @funnelsgrove/cli
 fgrove login
 ```
 
+Update every global installation visible on `PATH` (including separate NVM and
+Homebrew prefixes) with one command:
+
+```bash
+fgrove update
+```
+
+Use `fgrove update --dry-run` to inspect the installations first. The updater
+runs each installation's sibling `npm`, so duplicate global installs cannot
+silently remain on different CLI versions.
+
 Sync a funnel into its own local folder:
 
 ```bash
@@ -29,14 +40,27 @@ fgrove publish --env preview
 
 Inside a synced folder, `fgrove` reads `.funnelsgrove-sync.json` first, so you do not need to run `fgrove use` when switching between local funnel directories. Use `fgrove use` only when you want a global fallback context for commands outside a synced folder.
 
+`fgrove funnels clone` copies the draft and the funnel's offer-set mapping. The
+clone reuses the same project-level offer sets and payment profiles; custom-domain
+configuration is not copied into the new preview.
+
 `fgrove sync down` refuses to overwrite local changes in an existing synced
-folder. If `fgrove sync up` says the remote draft changed since your local sync,
-run `fgrove sync rebase`: it performs a three-way merge from the recorded base,
-preserves CLI-managed files, and leaves the working tree untouched when it finds
-conflicts. Review the merged diff, rerun `fgrove validate`, then sync up again.
+folder. `fgrove sync up` sends only changed and deleted paths in one atomic
+draft patch. Disjoint concurrent edits are rebased automatically; if the same
+path changed remotely, run `fgrove sync rebase`: it performs a three-way merge
+from the recorded base, preserves CLI-managed files, and leaves the working tree
+untouched when it finds conflicts. Review the merged diff, rerun `fgrove
+validate`, then sync up again.
 `sync down --force` is the explicit discard path and writes an automatic source
 backup under `.funnelsgrove/rebase-backups/` before replacing hosted paths.
 
+Changed images below `public/` are uploaded directly to asset storage, then the
+small immutable asset references are included in the atomic patch. Sync retries
+use a deterministic durable idempotency key, so a lost response cannot create a
+second draft version. The CLI automatically falls back to candidate sync when
+the compatible deployed API lacks the fast procedures or a change set exceeds
+patch limits.
+
 `fgrove sync up` is for funnels without GitHub source sync. When GitHub is
 connected, commit and push source changes with normal git, then run `fgrove
 github pull` to sync GitHub into the hosted draft. Do not run `fgrove sync up`
@@ -78,6 +102,8 @@ fgrove publish --funnel claimbee-general --env preview
 The GitHub commands use the FunnelsGrove API only. `fgrove github pull` pulls
 the repository into the hosted draft after you push normal git commits.
 `fgrove publish` waits for the current draft to reach GitHub before publishing.
+It writes validation, GitHub sync, queue, build, image optimization, and upload
+progress to stderr while keeping the final URL/version row alone on stdout.
 If the exact job is still pending or running when that wait times out, publish
 continues with a warning on stderr and asks you to check the eventual result
 with `fgrove github status`. Terminal job failures, missing jobs, and API

package/dist/apiClient.d.ts

@@ -18,6 +18,47 @@ export type FunnelSourceCandidateApiContext = {
     fetchFn?: FetchFn;
     signal?: AbortSignal;
 };
+export type DraftPatchFile = {
+    path: string;
+    content: string;
+    contentType?: string;
+};
+export type ApplyDraftPatchInput = {
+    workspaceId: string;
+    funnelId: string;
+    baseDraftVersionId: string | null;
+    idempotencyKey: string;
+    message?: string;
+    changedFiles: DraftPatchFile[];
+    deletedPaths: string[];
+};
+export type ApplyDraftPatchResult = {
+    funnelId: string;
+    previousDraftVersionId: string | null;
+    draftVersionId: string;
+    draftVersionSeq: number;
+    rebasedFromVersionId: string | null;
+    changedPaths: string[];
+    deletedPaths: string[];
+    changedContentBytes: number;
+    idempotent: boolean;
+};
+export type DirectAssetUploadDescription = {
+    workspaceId: string;
+    funnelId: string;
+    path: string;
+    contentType: string;
+    sizeBytes: number;
+    sha256: string;
+};
+export type PreparedDirectAssetUpload = Omit<DirectAssetUploadDescription, 'workspaceId' | 'funnelId'> & {
+    uploadKey: string;
+    uploadUrl: string;
+    uploadHeaders: Record<string, string>;
+};
+export type FinalizeDirectAssetUploadInput = DirectAssetUploadDescription & {
+    uploadKey: string;
+};
 export type CreateFunnelExperimentFromSpecInput = {
     workspaceId: string;
     funnelId: string;
@@ -96,6 +137,12 @@ export declare class FunnelContractApiError extends Error {
     readonly funnelContract: FunnelContractApiErrorData;
     constructor(message: string, funnelContract: FunnelContractApiErrorData);
 }
+export declare class TrpcApiError extends Error {
+    readonly code: string | null;
+    readonly httpStatus: number | null;
+    constructor(message: string, code: string | null, httpStatus: number | null);
+}
+export declare const isMissingTrpcProcedureError: (error: unknown) => boolean;
 export declare const parseFunnelContractApiErrorData: (value: unknown) => FunnelContractApiErrorData | null;
 export declare function parseTrpcJsonResponse<T = unknown>(response: unknown): T;
 export declare function callTrpcProcedure<T = unknown>(input: TrpcCallInput): Promise<T>;
@@ -103,5 +150,8 @@ export declare const beginFunnelSourceCandidate: (context: FunnelSourceCandidate
 export declare const stageFunnelSourceCandidate: (context: FunnelSourceCandidateApiContext, input: StageFunnelSourceCandidateInput) => Promise<StageFunnelSourceCandidateResult>;
 export declare const finalizeFunnelSourceCandidate: (context: FunnelSourceCandidateApiContext, input: FinalizeFunnelSourceCandidateInput) => Promise<FinalizeFunnelSourceCandidateResult>;
 export declare const abortFunnelSourceCandidate: (context: FunnelSourceCandidateApiContext, input: FinishFunnelSourceCandidateInput) => Promise<FunnelSourceCandidateSummary>;
+export declare const applyFunnelDraftPatch: (context: FunnelSourceCandidateApiContext, input: ApplyDraftPatchInput) => Promise<ApplyDraftPatchResult>;
+export declare const prepareFunnelDirectAssetUpload: (context: FunnelSourceCandidateApiContext, input: DirectAssetUploadDescription) => Promise<PreparedDirectAssetUpload>;
+export declare const finalizeFunnelDirectAssetUpload: (context: FunnelSourceCandidateApiContext, input: FinalizeDirectAssetUploadInput) => Promise<DraftPatchFile>;
 export declare const createFunnelExperimentFromSpec: (context: FunnelSourceCandidateApiContext, input: CreateFunnelExperimentFromSpecInput) => Promise<ExperimentCreateResponse>;
 export {};

package/dist/apiClient.js

@@ -48,6 +48,19 @@ export class FunnelContractApiError extends Error {
         this.funnelContract = funnelContract;
     }
 }
+export class TrpcApiError extends Error {
+    code;
+    httpStatus;
+    constructor(message, code, httpStatus) {
+        super(`tRPC request failed: ${message}`);
+        this.code = code;
+        this.httpStatus = httpStatus;
+        this.name = 'TrpcApiError';
+    }
+}
+export const isMissingTrpcProcedureError = (error) => (error instanceof TrpcApiError
+    && error.code === 'NOT_FOUND'
+    && /no procedure found on path/i.test(error.message));
 const ENVELOPE_KEYS = Object.freeze([
     'schemaVersion',
     'contractVersion',
@@ -238,7 +251,14 @@ export function parseTrpcJsonResponse(response) {
         if (funnelContract) {
             throw new FunnelContractApiError(message, funnelContract);
         }
-        throw new Error(`tRPC request failed: ${message}`);
+        const data = ownDataValue(errorValue, 'data');
+        const code = isObject(data) && typeof ownDataValue(data, 'code') === 'string'
+            ? ownDataValue(data, 'code')
+            : null;
+        const httpStatus = isObject(data) && typeof ownDataValue(data, 'httpStatus') === 'number'
+            ? ownDataValue(data, 'httpStatus')
+            : null;
+        throw new TrpcApiError(message, code, httpStatus);
     }
     const result = ownDataValue(response, 'result');
     if (!isObject(result)) {
@@ -316,6 +336,9 @@ export const beginFunnelSourceCandidate = (context, input) => callFunnelSourceCa
 export const stageFunnelSourceCandidate = (context, input) => callFunnelSourceCandidateMutation(context, 'funnels.stageSourceCandidate', input);
 export const finalizeFunnelSourceCandidate = (context, input) => callFunnelSourceCandidateMutation(context, 'funnels.finalizeSourceCandidate', input);
 export const abortFunnelSourceCandidate = (context, input) => callFunnelSourceCandidateMutation(context, 'funnels.abortSourceCandidate', input);
+export const applyFunnelDraftPatch = (context, input) => callFunnelSourceCandidateMutation(context, 'funnels.applyDraftPatch', input);
+export const prepareFunnelDirectAssetUpload = (context, input) => callFunnelSourceCandidateMutation(context, 'funnels.prepareDirectAssetUpload', input);
+export const finalizeFunnelDirectAssetUpload = (context, input) => callFunnelSourceCandidateMutation(context, 'funnels.finalizeDirectAssetUpload', input);
 export const createFunnelExperimentFromSpec = (context, input) => callTrpcProcedure({
     ...context,
     path: 'funnelExperiments.createFromSpec',

package/dist/cli.d.ts

@@ -239,6 +239,8 @@ type PublishCommandBackend = {
         funnelId: string;
     }) => Promise<FunnelDetailResponse>;
 };
+export type PublishProgressReporter = (message: string) => void;
+export declare const formatPublishProgress: (deployment: PublishDeploymentStatus) => string;
 export declare const executePublishAndWait: (input: {
     token: string;
     workspaceId: string;
@@ -246,6 +248,7 @@ export declare const executePublishAndWait: (input: {
     message?: string;
     domains?: string[];
     backend?: PublishCommandBackend;
+    onProgress?: PublishProgressReporter;
 }) => Promise<string>;
 export declare const buildCloneFunnelMutationInput: (input: {
     workspaceId: string;

package/dist/cli.js

@@ -8,13 +8,15 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Command } from 'commander';
 import { CURRENT_STEP_CONTRACT_VERSION, FUNNEL_CONTRACT_DIAGNOSTIC_CODES, PREVIOUS_STEP_CONTRACT_VERSION, createFunnelContractDiagnostic, } from '@funnelsgrove/runtime';
-import { abortFunnelSourceCandidate, beginFunnelSourceCandidate, callTrpcProcedure, createFunnelExperimentFromSpec, finalizeFunnelSourceCandidate, stageFunnelSourceCandidate, } from './apiClient.js';
+import { abortFunnelSourceCandidate, applyFunnelDraftPatch, beginFunnelSourceCandidate, callTrpcProcedure, createFunnelExperimentFromSpec, finalizeFunnelDirectAssetUpload, finalizeFunnelSourceCandidate, prepareFunnelDirectAssetUpload, stageFunnelSourceCandidate, } from './apiClient.js';
 import { cliReleaseIdentity } from './cliIdentity.js';
 import { clearActiveContext, getDefaultAuthConfigPath, loadActiveContext, loadAuthToken, saveActiveContext, saveAuthToken, } from './authStore.js';
 import { buildCommittedSyncManifest, buildDownloadedSyncManifest, buildSourceCandidateOperations, collectChangedSourceFiles, collectSourceFiles, collectSourceSnapshot, ensureGitignore, formatSyncUploadSummary, hasLocalSourceChanges, rebaseSourceFiles, readSyncManifest, replaceSourceFiles, runSyncDownLocalLifecycle, runSourceCandidateSync, writeLocalEnvFile, writeSourceFiles, writeSourceRebaseBackup, writeSyncManifest, } from './localSync.js';
 import { mergeTextSourceWithGit } from './sourceRebase.js';
 import { executeExperimentCreate, formatExperimentCreateSuccess, recoverExperimentCreateTransaction, } from './experimentCreate.js';
 import { pullEnvFile } from './envSync.js';
+import { executeFastDraftPatchSync, uploadDirectAssetWithFetch } from './draftPatchSync.js';
+import { updateCliInstallations } from './selfUpdate.js';
 import { executeExpensePublish, executeExpensePull } from './expenseCommands.js';
 import { executeEmailPull, executeEmailPush, executeEmailSend, executeEmailUpdateVariables, executeEmailSequenceAddStep, executeEmailSequenceCancel, executeEmailSequenceCreate, executeEmailSequencePublish, executeEmailSequenceSetActive, executeEmailTemplatePublish, executeEmailValidate, parseEmailVariablesJson, } from './emailCommands.js';
 import { formatGitHubConnectRows, formatGitHubJobRows, formatGitHubStatusRows, } from './githubOutput.js';
@@ -1200,6 +1202,39 @@ export const formatPublishTerminalSuccess = (input) => {
         || input.acknowledgement.deploymentUrl;
     return `${deploymentUrl}\tv${publishedVersionSeq}\t${versionId}`;
 };
+const PUBLISH_BUILD_STAGE_LABELS = {
+    sandboxCreate: 'starting build environment',
+    writeFiles: 'writing source files',
+    install: 'installing dependencies',
+    nextBuild: 'building funnel',
+    readExport: 'reading build output',
+    imageVariants: 'optimizing images',
+    r2Upload: 'uploading publish artifact',
+};
+export const formatPublishProgress = (deployment) => {
+    const state = deployment.state.trim().toLowerCase();
+    const metadata = isRecord(deployment.metadata) ? deployment.metadata : {};
+    const publishBuild = isRecord(metadata.publishBuild) ? metadata.publishBuild : null;
+    const stageName = publishBuild ? nonEmptyString(publishBuild.stageName) : null;
+    const stageStatus = publishBuild ? nonEmptyString(publishBuild.status) : null;
+    if (stageName) {
+        const label = PUBLISH_BUILD_STAGE_LABELS[stageName] || stageName;
+        if (stageStatus === 'completed')
+            return `Publish: ${label} completed.`;
+        if (stageStatus === 'failed')
+            return `Publish: ${label} failed.`;
+        return `Publish: ${label}...`;
+    }
+    if (state === 'queued')
+        return 'Publish: queued...';
+    if (state === 'building')
+        return 'Publish: preparing build...';
+    if (state === 'syncing')
+        return 'Publish: uploading publish artifact...';
+    if (state === 'ready')
+        return 'Publish: ready.';
+    return `Publish: ${state}...`;
+};
 const getApiUrl = () => {
     const options = program.opts();
     return options.apiUrl || process.env.FUNNELSGROVE_API_URL || DEFAULT_API_URL;
@@ -1234,6 +1269,7 @@ const isTerminalDeploymentState = (state) => {
 };
 const waitForPublishDeployment = async (input) => {
     const deadline = Date.now() + PUBLISH_WAIT_TIMEOUT_MS;
+    let lastProgressMessage = null;
     while (Date.now() <= deadline) {
         const detail = input.detail
             ? await input.detail(input)
@@ -1247,6 +1283,13 @@ const waitForPublishDeployment = async (input) => {
                 },
             });
         const deployment = detail.deployments.find((item) => item.id === input.deploymentId);
+        if (deployment && input.onProgress) {
+            const progressMessage = formatPublishProgress(deployment);
+            if (progressMessage !== lastProgressMessage) {
+                input.onProgress(progressMessage);
+                lastProgressMessage = progressMessage;
+            }
+        }
         if (deployment && isTerminalDeploymentState(deployment.state)) {
             if (deployment.state === 'failed') {
                 throw new Error(formatPublishTerminalFailure(deployment));
@@ -1283,6 +1326,7 @@ export const executePublishAndWait = async (input) => {
             },
         }),
     };
+    input.onProgress?.('Publish: requesting deployment...');
     const acknowledgement = await backend.publish({
         token: input.token,
         workspaceId: input.workspaceId,
@@ -1290,12 +1334,14 @@ export const executePublishAndWait = async (input) => {
         message: input.message,
         domains: input.domains,
     });
+    input.onProgress?.(`Publish: deployment ${acknowledgement.deploymentId} accepted.`);
     const deployment = await waitForPublishDeployment({
         token: input.token,
         workspaceId: input.workspaceId,
         funnelId: input.funnelId,
         deploymentId: acknowledgement.deploymentId,
         detail: backend.detail,
+        onProgress: input.onProgress,
     });
     return formatPublishTerminalSuccess({ acknowledgement, deployment });
 };
@@ -1618,10 +1664,28 @@ program
     .option('--config <path>', 'Auth config path', process.env.FUNNELSGROVE_CONFIG || getDefaultAuthConfigPath());
 addExamples(program, [
     'fgrove login',
+    'fgrove update',
     'fgrove sync down --funnel claimbee-ios --dir ./claimbee-ios',
     'cd ./claimbee-ios && fgrove status',
     'fgrove publish --env preview',
 ]);
+addExamples(program
+    .command('update')
+    .description('Update every global fgrove installation found on PATH')
+    .option('--dry-run', 'List installations without changing them'), [
+    'fgrove update',
+    'fgrove update --dry-run',
+])
+    .action(async (options) => {
+    const installations = await updateCliInstallations({
+        dryRun: options.dryRun,
+        entrypointPath: process.argv[1],
+        report: (message) => console.error(message),
+    });
+    console.log(options.dryRun
+        ? `Found ${installations.length} global fgrove installation${installations.length === 1 ? '' : 's'}.`
+        : `Updated ${installations.length} global fgrove installation${installations.length === 1 ? '' : 's'} to the latest release.`);
+});
 addExamples(program
     .command('login')
     .description('Authorize this CLI with your FunnelsGrove account')
@@ -2666,7 +2730,7 @@ addExamples(envCommand
 });
 addExamples(syncCommand
     .command('up')
-    .description('Upload local source into a new funnel draft version for funnels without GitHub source sync')
+    .description('Atomically upload changed local paths into the hosted draft for funnels without GitHub source sync')
     .option('--workspace <id-or-slug-or-name>', 'Workspace id, slug, or name')
     .option('--funnel <id-or-slug>', 'Funnel id or slug')
     .option('--dir <path>', 'Local source directory', '.')
@@ -2719,40 +2783,59 @@ addExamples(syncCommand
         process.once('SIGINT', cancel);
         process.once('SIGTERM', cancel);
         try {
-            const candidateResult = await runSourceCandidateSync({
+            const apiContext = {
+                apiUrl: getApiUrl(),
+                token,
+                signal: cancellation.signal,
+            };
+            const patchResult = await executeFastDraftPatchSync({
                 workspaceId: target.workspaceId,
                 funnelId: target.funnelId,
                 baseDraftVersionId: changes.currentManifest.draftVersionId,
                 message: options.message,
-                operations: buildSourceCandidateOperations({
-                    previousFiles: target.manifest?.files ?? [],
-                    files: changes.files,
-                    deletedPaths: changes.deletedPaths,
-                }),
+                files: changes.files,
+                deletedPaths: changes.deletedPaths,
                 signal: cancellation.signal,
                 api: {
-                    begin: (input) => beginFunnelSourceCandidate({
-                        apiUrl: getApiUrl(),
-                        token,
-                        signal: cancellation.signal,
-                    }, input),
-                    stage: (input) => stageFunnelSourceCandidate({
-                        apiUrl: getApiUrl(),
-                        token,
-                        signal: cancellation.signal,
-                    }, input),
-                    finalize: (input) => finalizeFunnelSourceCandidate({
-                        apiUrl: getApiUrl(),
-                        token,
-                        signal: cancellation.signal,
-                    }, input),
-                    abort: (input) => abortFunnelSourceCandidate({
-                        apiUrl: getApiUrl(),
-                        token,
-                    }, input),
+                    apply: (input) => applyFunnelDraftPatch(apiContext, input),
+                    prepareAsset: (input) => prepareFunnelDirectAssetUpload(apiContext, input),
+                    uploadAsset: uploadDirectAssetWithFetch,
+                    finalizeAsset: (input) => finalizeFunnelDirectAssetUpload(apiContext, input),
                 },
             });
-            result = { versionId: candidateResult.versionId };
+            if (patchResult.kind === 'committed') {
+                result = { versionId: patchResult.result.draftVersionId };
+                if (patchResult.directAssetCount > 0) {
+                    console.log(`Uploaded ${patchResult.directAssetCount} changed image${patchResult.directAssetCount === 1 ? '' : 's'} directly to asset storage.`);
+                }
+            }
+            else {
+                console.warn(patchResult.reason === 'legacy-api'
+                    ? 'The API does not support fast draft patches yet; using compatible source sync.'
+                    : 'This change set exceeds fast draft patch limits; using compatible source sync.');
+                const candidateResult = await runSourceCandidateSync({
+                    workspaceId: target.workspaceId,
+                    funnelId: target.funnelId,
+                    baseDraftVersionId: changes.currentManifest.draftVersionId,
+                    message: options.message,
+                    operations: buildSourceCandidateOperations({
+                        previousFiles: target.manifest?.files ?? [],
+                        files: changes.files,
+                        deletedPaths: changes.deletedPaths,
+                    }),
+                    signal: cancellation.signal,
+                    api: {
+                        begin: (input) => beginFunnelSourceCandidate(apiContext, input),
+                        stage: (input) => stageFunnelSourceCandidate(apiContext, input),
+                        finalize: (input) => finalizeFunnelSourceCandidate(apiContext, input),
+                        abort: (input) => abortFunnelSourceCandidate({
+                            apiUrl: getApiUrl(),
+                            token,
+                        }, input),
+                    },
+                });
+                result = { versionId: candidateResult.versionId };
+            }
         }
         finally {
             process.off('SIGINT', cancel);
@@ -2826,8 +2909,10 @@ addExamples(program
         throw new Error('--domain is required when publishing production');
     }
     const sourceDir = path.resolve(process.cwd(), options.dir);
+    console.error('Publish: validating local funnel...');
     await assertFunnelValidForMutation(sourceDir);
     const token = await readAuthToken();
+    console.error('Publish: resolving funnel target...');
     const target = await resolveSyncTarget({
         token,
         workspace: options.workspace,
@@ -2835,6 +2920,7 @@ addExamples(program
         dir: options.dir,
     });
     if (shouldSyncGitHubDraft(options)) {
+        console.error('Publish: checking GitHub draft sync...');
         await syncGitHubDraftForCli({
             token,
             workspaceId: target.workspaceId,
@@ -2848,6 +2934,7 @@ addExamples(program
         funnelId: target.funnelId,
         message: options.message,
         domains: publishEnv === 'production' && options.domain ? [options.domain] : undefined,
+        onProgress: (message) => console.error(message),
     }));
 });
 const githubCommand = addExamples(program.command('github').description('Manage GitHub funnel sync'), [

package/dist/contractCompatibility.js

@@ -13,7 +13,7 @@ export class ContractCompatibilityError extends Error {
 }
 const SHA256 = /^[a-f0-9]{64}$/;
 const SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
-const UPDATE_COMMAND = 'npm install -g @funnelsgrove/cli@latest';
+const UPDATE_COMMAND = 'fgrove update';
 const DEFAULT_TIMEOUT_MS = 3_000;
 const MAX_TIMEOUT_MS = 10_000;
 const MAX_HEALTH_RESPONSE_BYTES = 64 * 1_024;

package/dist/draftPatchSync.d.ts

@@ -0,0 +1,39 @@
+import type { ApplyDraftPatchInput, ApplyDraftPatchResult, DirectAssetUploadDescription, DraftPatchFile, FinalizeDirectAssetUploadInput, PreparedDirectAssetUpload } from './apiClient.js';
+import { type SourceFile } from './localSync.js';
+export type DraftPatchSyncApi = {
+    apply: (input: ApplyDraftPatchInput) => Promise<ApplyDraftPatchResult>;
+    prepareAsset: (input: DirectAssetUploadDescription) => Promise<PreparedDirectAssetUpload>;
+    uploadAsset: (input: {
+        uploadUrl: string;
+        uploadHeaders: Record<string, string>;
+        body: Uint8Array;
+        signal?: AbortSignal;
+    }) => Promise<void>;
+    finalizeAsset: (input: FinalizeDirectAssetUploadInput) => Promise<DraftPatchFile>;
+};
+export type DraftPatchSyncResult = {
+    kind: 'committed';
+    result: ApplyDraftPatchResult;
+    directAssetCount: number;
+} | {
+    kind: 'fallback';
+    reason: 'unsupported-patch' | 'legacy-api';
+};
+export declare const uploadDirectAssetWithFetch: (input: {
+    uploadUrl: string;
+    uploadHeaders: Record<string, string>;
+    body: Uint8Array;
+    signal?: AbortSignal;
+    fetchFn?: typeof fetch;
+}) => Promise<void>;
+export declare const executeFastDraftPatchSync: (input: {
+    workspaceId: string;
+    funnelId: string;
+    baseDraftVersionId: string | null;
+    message?: string;
+    files: readonly SourceFile[];
+    deletedPaths: readonly string[];
+    signal?: AbortSignal;
+    uploadConcurrency?: number;
+    api: DraftPatchSyncApi;
+}) => Promise<DraftPatchSyncResult>;

package/dist/draftPatchSync.js

@@ -0,0 +1,132 @@
+import { createHash } from 'node:crypto';
+import { isMissingTrpcProcedureError } from './apiClient.js';
+import { sourceFileBytes } from './localSync.js';
+const MAX_PATCH_FILES = 600;
+const MAX_PATCH_FILE_CONTENT_CHARS = 3_000_000;
+const MAX_PATCH_CONTENT_BYTES = 65_000_000;
+const MAX_DIRECT_ASSET_BYTES = 25_000_000;
+const MAX_DIRECT_ASSET_REF_BYTES = 1_024;
+const DEFAULT_UPLOAD_CONCURRENCY = 4;
+const isDirectImage = (file) => (file.path.startsWith('public/')
+    && Boolean(file.contentType?.toLowerCase().startsWith('image/')));
+const hash = (value) => (createHash('sha256').update(value).digest('hex'));
+const mapWithConcurrency = async (values, concurrency, worker) => {
+    const results = new Array(values.length);
+    let cursor = 0;
+    const run = async () => {
+        while (cursor < values.length) {
+            const index = cursor;
+            cursor += 1;
+            results[index] = await worker(values[index]);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, () => run()));
+    return results;
+};
+const createIdempotencyKey = (input) => {
+    const payload = JSON.stringify({
+        ...input,
+        changedFiles: [...input.changedFiles]
+            .map((file) => ({
+            path: file.path,
+            contentType: file.contentType || 'text/plain',
+            contentHash: hash(file.content),
+        }))
+            .sort((left, right) => left.path.localeCompare(right.path)),
+        deletedPaths: [...input.deletedPaths].sort((left, right) => left.localeCompare(right)),
+    });
+    return `cli-sync-patch:${hash(payload)}`;
+};
+const patchIsSupported = (files, deletedPaths) => {
+    if (files.length > MAX_PATCH_FILES || deletedPaths.length > MAX_PATCH_FILES)
+        return false;
+    let projectedBytes = 0;
+    for (const file of files) {
+        if (isDirectImage(file)) {
+            const sizeBytes = sourceFileBytes(file).byteLength;
+            if (sizeBytes < 1 || sizeBytes > MAX_DIRECT_ASSET_BYTES)
+                return false;
+            projectedBytes += MAX_DIRECT_ASSET_REF_BYTES;
+            continue;
+        }
+        if (file.content.length > MAX_PATCH_FILE_CONTENT_CHARS)
+            return false;
+        projectedBytes += Buffer.byteLength(file.content, 'utf8');
+    }
+    return projectedBytes <= MAX_PATCH_CONTENT_BYTES;
+};
+export const uploadDirectAssetWithFetch = async (input) => {
+    const response = await (input.fetchFn || fetch)(input.uploadUrl, {
+        method: 'PUT',
+        headers: input.uploadHeaders,
+        body: new Uint8Array(input.body).buffer,
+        signal: input.signal,
+    });
+    if (!response.ok) {
+        throw new Error(`Direct asset upload failed with HTTP ${response.status}.`);
+    }
+};
+export const executeFastDraftPatchSync = async (input) => {
+    if (!patchIsSupported(input.files, input.deletedPaths)) {
+        return { kind: 'fallback', reason: 'unsupported-patch' };
+    }
+    const directFiles = input.files.filter(isDirectImage);
+    let uploadedAssets;
+    try {
+        const uploadConcurrency = Number.isSafeInteger(input.uploadConcurrency)
+            ? Math.min(16, Math.max(1, input.uploadConcurrency))
+            : DEFAULT_UPLOAD_CONCURRENCY;
+        uploadedAssets = await mapWithConcurrency(directFiles, uploadConcurrency, async (file) => {
+            const body = sourceFileBytes(file);
+            const description = {
+                workspaceId: input.workspaceId,
+                funnelId: input.funnelId,
+                path: file.path,
+                contentType: file.contentType,
+                sizeBytes: body.byteLength,
+                sha256: hash(body),
+            };
+            const prepared = await input.api.prepareAsset(description);
+            await input.api.uploadAsset({
+                uploadUrl: prepared.uploadUrl,
+                uploadHeaders: prepared.uploadHeaders,
+                body,
+                signal: input.signal,
+            });
+            return input.api.finalizeAsset({ ...description, uploadKey: prepared.uploadKey });
+        });
+    }
+    catch (error) {
+        if (isMissingTrpcProcedureError(error)) {
+            return { kind: 'fallback', reason: 'legacy-api' };
+        }
+        throw error;
+    }
+    const uploadedByPath = new Map(uploadedAssets.map((file) => [file.path, file]));
+    const changedFiles = input.files.map((file) => (uploadedByPath.get(file.path) ?? {
+        path: file.path,
+        content: file.content,
+        contentType: file.contentType,
+    }));
+    const requestWithoutKey = {
+        workspaceId: input.workspaceId,
+        funnelId: input.funnelId,
+        baseDraftVersionId: input.baseDraftVersionId,
+        message: input.message,
+        changedFiles,
+        deletedPaths: [...input.deletedPaths],
+    };
+    try {
+        const result = await input.api.apply({
+            ...requestWithoutKey,
+            idempotencyKey: createIdempotencyKey(requestWithoutKey),
+        });
+        return { kind: 'committed', result, directAssetCount: directFiles.length };
+    }
+    catch (error) {
+        if (isMissingTrpcProcedureError(error)) {
+            return { kind: 'fallback', reason: 'legacy-api' };
+        }
+        throw error;
+    }
+};

package/dist/emailCommands.js

@@ -113,7 +113,7 @@ export async function executeEmailSequenceCancel(input, dependencies = {}) {
     const remote = await emailApiRequest({
         apiUrl: input.apiUrl,
         privateToken: input.privateToken,
-        path: `/sdk/private/sequences/${encodeURIComponent(sequence.id)}`,
+        path: `/integration/v1/email/sequences/${encodeURIComponent(sequence.id)}`,
         fetchImpl: dependencies.fetchImpl || fetch,
     });
     if (!isRecord(remote.sequence)
@@ -124,7 +124,7 @@ export async function executeEmailSequenceCancel(input, dependencies = {}) {
     const response = await emailApiRequest({
         apiUrl: input.apiUrl,
         privateToken: input.privateToken,
-        path: `/sdk/private/sequences/${encodeURIComponent(sequence.id)}/enrollments/${encodeURIComponent(input.funnelEndUserId)}/cancel`,
+        path: `/integration/v1/email/sequences/${encodeURIComponent(sequence.id)}/enrollments/${encodeURIComponent(input.funnelEndUserId)}/cancel`,
         method: 'POST',
         body: { reason: input.reason },
         fetchImpl: dependencies.fetchImpl || fetch,

package/dist/localSync.d.ts

@@ -128,6 +128,7 @@ export declare function collectSourceSnapshot(rootDir: string): Promise<{
     sourceFiles: SourceFile[];
 }>;
 export declare function collectSourceFiles(rootDir: string): Promise<SourceFile[]>;
+export declare const sourceFileBytes: (file: SourceFile) => Buffer;
 export declare function rebaseSourceFiles(input: {
     baseFiles: readonly SourceFile[];
     localFiles: readonly SourceFile[];

package/dist/localSync.js

@@ -382,7 +382,7 @@ export async function collectSourceSnapshot(rootDir) {
 export async function collectSourceFiles(rootDir) {
     return (await collectSourceSnapshot(rootDir)).sourceFiles;
 }
-const sourceFileBytes = (file) => (decodeBinarySourceContent(file) ?? Buffer.from(file.content, 'utf8'));
+export const sourceFileBytes = (file) => (decodeBinarySourceContent(file) ?? Buffer.from(file.content, 'utf8'));
 const sourceFilesEqual = (left, right) => {
     if (!left || !right)
         return left === right;