@mduan/paseo-cli 0.11.0-fork.34 → 0.11.0-fork.35

package/node_modules/@getpaseo/server/dist/server/server/workspace-git-service.js

@@ -10,7 +10,7 @@ import { createForgeService } from "../services/forge-registry.js";
 import { createForgeResolver, } from "../services/forge-resolver.js";
 import { parseGitRevParsePath } from "../utils/git-rev-parse-path.js";
 import { createRealpathAwarePathMatcher, getRealpathAwareRelativePath, isPathInsideRoot, isRealpathInsideRoot, looksLikeDefiniteWindowsPath, } from "../utils/path.js";
-import { createRunGitCommand, runGitCommand, } from "../utils/run-git-command.js";
+import { createRunGitCommand, runGitCommand, runWithGitCommandPriority, } from "../utils/run-git-command.js";
 import { branchNameFromRef } from "../utils/worktree-metadata.js";
 import { listPaseoWorktrees } from "../utils/worktree.js";
 import { READ_ONLY_GIT_ENV } from "./checkout-git-utils.js";
@@ -86,6 +86,16 @@ export function getWorkspaceGitObservationReensurePhaseMs(cwd) {
 }
 // Kept for local diagnostic fixtures that only use the stable phase calculation.
 export const getWorkspaceGitSelfHealPhaseMs = getWorkspaceGitObservationReensurePhaseMs;
+// Demand refreshes keep the caller's Git lane; watcher and poll refreshes run in background.
+var WorkspaceGitRefreshOrigin;
+(function (WorkspaceGitRefreshOrigin) {
+    WorkspaceGitRefreshOrigin["Demand"] = "demand";
+    WorkspaceGitRefreshOrigin["Observation"] = "observation";
+})(WorkspaceGitRefreshOrigin || (WorkspaceGitRefreshOrigin = {}));
+// A caller waiting on a merged refresh keeps it out of the background lane.
+function mergeRefreshOrigins(pending, request) {
+    return pending === WorkspaceGitRefreshOrigin.Demand ? pending : request;
+}
 class WorkspaceGitServiceDisposedError extends Error {
     constructor() {
         super("WorkspaceGitService is disposed");
@@ -255,14 +265,17 @@ export class WorkspaceGitServiceImpl {
         }
         return this.requestWorkspaceSnapshot(target, request);
     }
-    async getCheckout(cwd) {
+    async getCheckout(cwd, options) {
         this.assertNotDisposed();
         const normalizedCwd = resolve(cwd);
-        const status = await this.deps.getCheckoutStatus(normalizedCwd, {
+        const readStatus = () => this.deps.getCheckoutStatus(normalizedCwd, {
             paseoHome: this.paseoHome,
             worktreesRoot: this.worktreesRoot,
             logger: this.logger,
         });
+        const status = await (options?.priority
+            ? runWithGitCommandPriority(options.priority, readStatus)
+            : readStatus());
         if (!status.isGit) {
             return checkoutLiteFromGitSnapshot(normalizedCwd, {
                 isGit: false,
@@ -407,6 +420,7 @@ export class WorkspaceGitServiceImpl {
         cwd = resolve(cwd);
         const target = this.ensureWorkspaceTarget(cwd);
         await this.refreshWorkspaceTarget(target, {
+            origin: WorkspaceGitRefreshOrigin.Demand,
             force: false,
             refreshStructure: true,
             refreshWorktree: true,
@@ -435,7 +449,10 @@ export class WorkspaceGitServiceImpl {
         cwd = resolve(cwd);
         const target = this.workspaceTargets.get(cwd);
         if (target) {
-            this.scheduleWorkspaceRefresh(target, { queueIfBusy: false });
+            this.scheduleWorkspaceRefresh(target, {
+                origin: WorkspaceGitRefreshOrigin.Demand,
+                queueIfBusy: false,
+            });
         }
     }
     onWorkspaceStateMayHaveChanged(cwd) {
@@ -447,6 +464,7 @@ export class WorkspaceGitServiceImpl {
         }
         this.invalidateForge(normalizedCwd);
         this.scheduleWorkspaceRefresh(target, {
+            origin: WorkspaceGitRefreshOrigin.Demand,
             force: true,
             includeForge: true,
             reason: "external-state-change",
@@ -632,6 +650,7 @@ export class WorkspaceGitServiceImpl {
                 return;
             }
             void this.refreshWorkspaceTarget(target, {
+                origin: WorkspaceGitRefreshOrigin.Demand,
                 force: false,
                 refreshStructure: true,
                 refreshWorktree: true,
@@ -958,6 +977,7 @@ export class WorkspaceGitServiceImpl {
                     return false;
                 }
                 const changed = await this.refreshDegradedPollTarget(workspaceTarget, {
+                    origin: WorkspaceGitRefreshOrigin.Observation,
                     force: false,
                     refreshStructure: target.repoRoot === null,
                     refreshWorktree: true,
@@ -1383,7 +1403,11 @@ export class WorkspaceGitServiceImpl {
         for (const workspaceKey of target.workspaceKeys) {
             const workspaceTarget = this.workspaceTargets.get(workspaceKey);
             if (workspaceTarget) {
-                this.scheduleWorkspaceRefresh(workspaceTarget, { scope: "worktree", reason });
+                this.scheduleWorkspaceRefresh(workspaceTarget, {
+                    origin: WorkspaceGitRefreshOrigin.Observation,
+                    scope: "worktree",
+                    reason,
+                });
             }
         }
     }
@@ -1818,6 +1842,7 @@ export class WorkspaceGitServiceImpl {
                     }
                 }
                 this.scheduleWorkspaceRefresh(workspaceTarget, {
+                    origin: WorkspaceGitRefreshOrigin.Observation,
                     scope,
                     emitUnchanged: refresh.refreshBase,
                     reason,
@@ -1856,6 +1881,7 @@ export class WorkspaceGitServiceImpl {
                     workingTreeTargets.add(workingTreeTarget);
                 }
                 return await this.refreshDegradedPollTarget(workspaceTarget, {
+                    origin: WorkspaceGitRefreshOrigin.Observation,
                     force: false,
                     refreshStructure: true,
                     refreshWorktree: true,
@@ -2141,6 +2167,8 @@ export class WorkspaceGitServiceImpl {
             if (request.queueIfBusy || addsWork) {
                 target.refreshState.queued = this.mergeRefreshRequests(target.refreshState.queued, request);
             }
+            // The caller now waits on this refresh — promote its remaining Git work.
+            active.origin = mergeRefreshOrigins(active.origin, request.origin);
             return target.refreshState.promise;
         }
         if (!request.force && !request.queueIfBusy && this.shouldThrottleNonForcedRefresh(target)) {
@@ -2166,6 +2194,7 @@ export class WorkspaceGitServiceImpl {
         }
         const force = options?.force === true;
         return {
+            origin: WorkspaceGitRefreshOrigin.Demand,
             force,
             refreshStructure: options?.refreshGit !== false,
             refreshWorktree: options?.refreshGit !== false,
@@ -2183,17 +2212,18 @@ export class WorkspaceGitServiceImpl {
         return this.deps.now().getTime() - target.lastShellOutAtMs < WORKSPACE_GIT_INTERNAL_MIN_GAP_MS;
     }
     buildScheduledRefreshRequest(options) {
-        const scope = options?.scope;
+        const scope = options.scope;
         return {
-            force: options?.force === true,
+            origin: options.origin,
+            force: options.force === true,
             refreshStructure: scope !== "worktree" && scope !== "refs",
             refreshWorktree: scope !== "structure" && scope !== "refs",
-            includeForge: options?.includeForge ?? false,
-            emitUnchanged: options?.emitUnchanged,
-            reason: options?.reason ?? "watch",
+            includeForge: options.includeForge ?? false,
+            emitUnchanged: options.emitUnchanged,
+            reason: options.reason ?? "watch",
             notify: true,
-            queueIfBusy: options?.queueIfBusy ?? true,
-            movedRemoteRefs: new Set(options?.movedRemoteRefs),
+            queueIfBusy: options.queueIfBusy ?? true,
+            movedRemoteRefs: new Set(options.movedRemoteRefs),
         };
     }
     mergeRefreshRequests(pending, request) {
@@ -2208,6 +2238,7 @@ export class WorkspaceGitServiceImpl {
         const upgradesEmit = request.emitUnchanged === true && pending.emitUnchanged !== true;
         const { merged: movedRemoteRefs, added: upgradesMovedRefs } = mergeSets(pending.movedRemoteRefs, request.movedRemoteRefs);
         return {
+            origin: mergeRefreshOrigins(pending.origin, request.origin),
             force,
             refreshStructure: pending.refreshStructure || request.refreshStructure,
             refreshWorktree: pending.refreshWorktree || request.refreshWorktree,
@@ -2240,7 +2271,7 @@ export class WorkspaceGitServiceImpl {
                 });
             }
             try {
-                const runRefreshGitCommand = createRunGitCommand(`workspace-refresh:${request.reason}`);
+                const runRefreshGitCommand = this.createRefreshGitCommand(request);
                 const admittedSnapshot = await this.workspaceRefreshLimit(() => {
                     if (target.closed || this.workspaceTargets.get(target.cwd) !== target) {
                         return null;
@@ -2276,6 +2307,16 @@ export class WorkspaceGitServiceImpl {
         }
         return snapshot;
     }
+    // Origin is read per command so a joining demand caller promotes the rest of the refresh.
+    // Demand uses the ambient lane so a "high" user action is not demoted.
+    createRefreshGitCommand(request) {
+        const provenance = `workspace-refresh:${request.reason}`;
+        const runDemand = createRunGitCommand(provenance);
+        const runObservation = createRunGitCommand(provenance, { priority: "background" });
+        return (args, options) => request.origin === WorkspaceGitRefreshOrigin.Observation
+            ? runObservation(args, options)
+            : runDemand(args, options);
+    }
     async refreshSnapshot(target, request, runRefreshGitCommand) {
         let facts = target.latestFacts;
         if (request.movedRemoteRefs.size > 0 && !request.refreshStructure && !request.refreshWorktree) {
@@ -2531,7 +2572,7 @@ export class WorkspaceGitServiceImpl {
                             eventsBeforeFetchSnapshot.push(...events);
                         }
                     },
-                }, createRunGitCommand("background-fetch"));
+                }, createRunGitCommand("background-fetch", { priority: "background" }));
             }
             catch (error) {
                 this.logger.warn({ err: error, repoGitRoot: target.repoGitRoot, cwd: target.cwd }, "Background git fetch failed");

package/node_modules/@getpaseo/server/dist/server/server/workspace-reconciliation-service.js

@@ -1,10 +1,13 @@
 import { statSync, watch as watchPath } from "node:fs";
+import pLimit from "p-limit";
 import { areEquivalentPaths } from "../utils/path.js";
 import { deriveProjectKind, reconcileWorkspacePlacement, } from "./workspace-registry-model.js";
 import { workspaceIdsForProjects } from "./workspace-directory.js";
 import { deriveProjectKey } from "./project-key.js";
 const DEFAULT_RESCAN_INTERVAL_MS = 5 * 60000;
 const DEFAULT_DEBOUNCE_MS = 100;
+// ~15 Git commands per read — unbounded sibling reads queued 1,000+ commands per rescan.
+const CHECKOUT_READ_CONCURRENCY = 4;
 const systemClock = {
     setTimeout: (callback, delayMs) => setTimeout(() => void callback(), delayMs),
     clearTimeout: (timer) => clearTimeout(timer),
@@ -169,11 +172,12 @@ export class WorkspaceReconciliationService {
     }
     async reconcileGitMetadataForProjects(projectsToReconcile, workspacesByProject, changes) {
         const checkoutReads = [];
+        const checkoutReadLimit = pLimit(CHECKOUT_READ_CONCURRENCY);
         const readCheckout = (cwd) => {
             const existing = checkoutReads.find((read) => areEquivalentPaths(read.cwd, cwd));
             if (existing)
                 return existing.checkout;
-            const checkout = this.readCheckout(cwd);
+            const checkout = checkoutReadLimit(() => this.readCheckout(cwd));
             checkoutReads.push({ cwd, checkout });
             return checkout;
         };
@@ -367,7 +371,7 @@ export class WorkspaceReconciliationService {
                 mainRepoRoot: null,
             };
         }
-        return this.workspaceGitService.getCheckout(cwd);
+        return this.workspaceGitService.getCheckout(cwd, { priority: "background" });
     }
     inspectDirectory(targetPath) {
         try {

package/node_modules/@getpaseo/server/dist/server/server/workspace-registry.d.ts

@@ -58,6 +58,8 @@ declare const PersistedWorkspaceRecordSchema: z.ZodObject<{
             color: z.ZodString;
         }, z.core.$strip>>;
     }, z.core.$strip>>>;
+    lastHumanPromptAt: z.ZodOptional<z.ZodString>;
+    lastAgentResponseAt: z.ZodOptional<z.ZodString>;
     untrustedSource: z.ZodOptional<z.ZodObject<{
         kind: z.ZodLiteral<"change_request">;
         forge: z.ZodString;

package/node_modules/@getpaseo/server/dist/server/server/workspace-registry.js

@@ -98,6 +98,10 @@ const PersistedWorkspaceRecordSchema = z.object({
         .transform((value) => value ?? null),
     labels: z.array(z.string()).optional(),
     linearIssues: z.array(LinearIssueSchema).optional(),
+    // Last client-sent prompt; automated prompts never set it — see `recordHumanPrompt`.
+    lastHumanPromptAt: z.string().optional(),
+    // Last completed agent turn, whoever prompted it — see `attachWorkspaceResponseRecorder`.
+    lastAgentResponseAt: z.string().optional(),
     untrustedSource: UntrustedWorkspaceSourceSchema.optional(),
 });
 class FileBackedRegistry {

package/node_modules/@getpaseo/server/dist/server/server/workspace-response-recorder.d.ts

@@ -0,0 +1,13 @@
+import type { Logger } from "pino";
+import type { AgentManager } from "./agent/agent-manager.js";
+import type { WorkspaceRegistry } from "./workspace-registry.js";
+/**
+ * Stamps `lastAgentResponseAt` on the owning workspace each time a live agent turn completes,
+ * whoever prompted it. History replays never reach subscribers, so restarts don't move it.
+ */
+export declare function attachWorkspaceResponseRecorder(input: {
+    logger: Logger;
+    agentManager: Pick<AgentManager, "subscribe" | "getAgent">;
+    workspaceRegistry: Pick<WorkspaceRegistry, "update">;
+}): () => void;
+//# sourceMappingURL=workspace-response-recorder.d.ts.map

package/node_modules/@getpaseo/server/dist/server/server/workspace-response-recorder.js

@@ -0,0 +1,21 @@
+/**
+ * Stamps `lastAgentResponseAt` on the owning workspace each time a live agent turn completes,
+ * whoever prompted it. History replays never reach subscribers, so restarts don't move it.
+ */
+export function attachWorkspaceResponseRecorder(input) {
+    const { logger, agentManager, workspaceRegistry } = input;
+    return agentManager.subscribe((event) => {
+        if (event.type !== "agent_stream" || event.event.type !== "turn_completed")
+            return;
+        const agent = agentManager.getAgent(event.agentId);
+        if (!agent?.workspaceId || agent.internal)
+            return;
+        const lastAgentResponseAt = event.timestamp ?? new Date().toISOString();
+        void workspaceRegistry
+            .update(agent.workspaceId, (existing) => ({ ...existing, lastAgentResponseAt }))
+            .catch((error) => {
+            logger.warn({ err: error, agentId: event.agentId, workspaceId: agent.workspaceId }, "Failed to record agent response time");
+        });
+    }, { replayState: false });
+}
+//# sourceMappingURL=workspace-response-recorder.js.map

package/node_modules/@getpaseo/server/dist/server/utils/git-process-scheduler.d.ts

@@ -7,7 +7,7 @@ export interface ScheduledGitProcess<T> {
     result: Promise<T>;
     exited: Promise<void>;
 }
-export type GitProcessPriority = "normal" | "high";
+export type GitProcessPriority = "high" | "normal" | "background";
 export declare function resolveGitProcessPolicy(input: {
     env: NodeJS.ProcessEnv;
     persisted?: Partial<GitProcessPolicy>;
@@ -15,9 +15,9 @@ export declare function resolveGitProcessPolicy(input: {
 export declare class GitProcessScheduler {
     readonly policy: GitProcessPolicy;
     private readonly startThrottled;
-    private readonly highPriorityQueue;
-    private readonly normalPriorityQueue;
+    private readonly queues;
     private admitted;
+    private reservedStarts;
     private running;
     private waiting;
     private drainScheduled;
@@ -27,8 +27,10 @@ export declare class GitProcessScheduler {
     run<T>(start: () => ScheduledGitProcess<T>, options?: {
         priority?: GitProcessPriority;
     }): Promise<T>;
+    private canReserveStart;
     private scheduleDrain;
     private drainOne;
+    private startNext;
     private execute;
 }
 //# sourceMappingURL=git-process-scheduler.d.ts.map

package/node_modules/@getpaseo/server/dist/server/utils/git-process-scheduler.js

@@ -23,12 +23,18 @@ export function resolveGitProcessPolicy(input) {
             DEFAULT_GIT_PROCESS_POLICY.maxProcessConcurrency,
     };
 }
+// Admission reserves a slot and a start-rate token; the job is chosen when the token fires, so
+// work submitted while background reservations wait on the rate limit takes the next start.
 export class GitProcessScheduler {
     constructor(policy) {
         this.policy = policy;
-        this.highPriorityQueue = [];
-        this.normalPriorityQueue = [];
+        this.queues = {
+            high: [],
+            normal: [],
+            background: [],
+        };
         this.admitted = 0;
+        this.reservedStarts = 0;
         this.running = 0;
         this.waiting = 0;
         this.drainScheduled = false;
@@ -37,7 +43,7 @@ export class GitProcessScheduler {
             interval: 1000,
             strict: true,
         });
-        this.startThrottled = throttle((start) => start());
+        this.startThrottled = throttle(() => this.startNext());
     }
     get activeCount() {
         return this.running;
@@ -48,16 +54,7 @@ export class GitProcessScheduler {
     run(start, options) {
         this.waiting += 1;
         return new Promise((resolve, reject) => {
-            const admit = () => {
-                void this.startThrottled(() => this.execute(start, resolve, reject)).catch((error) => {
-                    this.waiting = Math.max(0, this.waiting - 1);
-                    this.admitted = Math.max(0, this.admitted - 1);
-                    reject(error);
-                    this.scheduleDrain();
-                });
-            };
-            const queue = options?.priority === "high" ? this.highPriorityQueue : this.normalPriorityQueue;
-            queue.push(admit);
+            this.queues[options?.priority ?? "normal"].push(() => this.execute(start, resolve, reject));
             if (this.admitted === 0 && !this.drainScheduled) {
                 this.drainOne();
             }
@@ -66,11 +63,12 @@ export class GitProcessScheduler {
             }
         });
     }
+    // Every reservation is backed by a queued job: jobs leave the queues only in startNext.
+    canReserveStart() {
+        return this.admitted < this.policy.maxProcessConcurrency && this.waiting > this.reservedStarts;
+    }
     scheduleDrain() {
-        if (this.drainScheduled || this.admitted >= this.policy.maxProcessConcurrency) {
-            return;
-        }
-        if (this.highPriorityQueue.length === 0 && this.normalPriorityQueue.length === 0) {
+        if (this.drainScheduled || !this.canReserveStart()) {
             return;
         }
         this.drainScheduled = true;
@@ -78,19 +76,24 @@ export class GitProcessScheduler {
     }
     drainOne() {
         this.drainScheduled = false;
-        if (this.admitted >= this.policy.maxProcessConcurrency) {
-            return;
-        }
-        const admit = this.highPriorityQueue.shift() ?? this.normalPriorityQueue.shift();
-        if (!admit) {
+        if (!this.canReserveStart()) {
             return;
         }
         this.admitted += 1;
-        admit();
+        this.reservedStarts += 1;
+        void this.startThrottled();
         // Spawning can be synchronous and expensive on a throttled host. Let timers,
         // sockets, and child exits run before admitting another Git process.
         this.scheduleDrain();
     }
+    startNext() {
+        this.reservedStarts -= 1;
+        const next = this.queues.high.shift() ?? this.queues.normal.shift() ?? this.queues.background.shift();
+        if (!next) {
+            throw new Error("Git process start fired without a queued process");
+        }
+        return next();
+    }
     async execute(start, resolve, reject) {
         this.waiting = Math.max(0, this.waiting - 1);
         this.running += 1;

package/node_modules/@getpaseo/server/dist/server/utils/run-git-command.d.ts

@@ -22,7 +22,11 @@ export interface GitCommandResult<Output = string> {
     signal: NodeJS.Signals | null;
 }
 export type RunGitCommand = (args: string[], options: GitCommandOptions) => Promise<GitCommandResult>;
-export declare function createRunGitCommand(provenance: string): RunGitCommand;
+export interface GitCommandRunnerOptions {
+    /** Overrides the ambient `runWithGitCommandPriority` lane for every command this runner starts. */
+    priority?: GitProcessPriority;
+}
+export declare function createRunGitCommand(provenance: string, runnerOptions?: GitCommandRunnerOptions): RunGitCommand;
 export interface GitCommandMetric {
     args: string[];
     cwd: string;
@@ -47,6 +51,7 @@ export interface GitCommandMetricsSnapshot {
 export interface GitCommandSubmissionMetric {
     args: string[];
     cwd: string;
+    priority: GitProcessPriority;
 }
 export declare function startGitCommandMetrics(): void;
 export declare function stopGitCommandMetrics(): GitCommandMetricsSnapshot;

package/node_modules/@getpaseo/server/dist/server/utils/run-git-command.js

@@ -23,8 +23,12 @@ export function configureGitProcessPolicy(policy) {
     gitProcessScheduler = new GitProcessScheduler(policy);
     gitRuntimeMetrics = createGitCommandRuntimeMetricsWindow(policy);
 }
-export function createRunGitCommand(provenance) {
-    return (args, options) => runGitCommandWithProvenance(args, options, provenance);
+export function createRunGitCommand(provenance, runnerOptions) {
+    const priority = runnerOptions?.priority;
+    if (!priority) {
+        return (args, options) => runGitCommandWithProvenance(args, options, provenance);
+    }
+    return (args, options) => runWithGitCommandPriority(priority, () => runGitCommandWithProvenance(args, options, provenance));
 }
 let gitCommandMetricsState = null;
 export function startGitCommandMetrics() {
@@ -92,8 +96,8 @@ function snapshotGitCommandMetricsState(state) {
     return {
         commands: [...state.commands],
         submissions: state.submissions.map((submission) => ({
+            ...submission,
             args: [...submission.args],
-            cwd: submission.cwd,
         })),
         submitted: state.submitted,
         started: state.started,
@@ -111,12 +115,12 @@ export function snapshotGitCommandRuntimeMetrics() {
         pending: gitProcessScheduler.pendingCount,
     });
 }
-function submitGitCommandMetric(args, cwd) {
+function submitGitCommandMetric(submission) {
     const state = gitCommandMetricsState;
     if (!state) {
         return null;
     }
-    state.submissions.push({ args: [...args], cwd });
+    state.submissions.push({ ...submission, args: [...submission.args] });
     state.submitted += 1;
     state.lastSubmittedAtMs = Date.now();
     return state;
@@ -157,7 +161,8 @@ export function runGitCommandBytes(args, options) {
     return executeGitCommand(args, options, (output) => output);
 }
 function executeGitCommand(args, options, decode, provenance) {
-    const metricsState = submitGitCommandMetric(args, options.cwd);
+    const priority = gitCommandPriority.getStore() ?? "normal";
+    const metricsState = submitGitCommandMetric({ args, cwd: options.cwd, priority });
     const commandTrace = submitGitCommandTrace(args, options.cwd, {
         active: gitProcessScheduler.activeCount,
         pending: gitProcessScheduler.pendingCount,
@@ -394,9 +399,7 @@ function executeGitCommand(args, options, decode, provenance) {
         });
         return { result: resultPromise, exited };
     };
-    const promise = gitProcessScheduler.run(startCommand, {
-        priority: gitCommandPriority.getStore() ?? "normal",
-    });
+    const promise = gitProcessScheduler.run(startCommand, { priority });
     gitRuntimeMetrics.observeLimiter(gitProcessScheduler.activeCount, gitProcessScheduler.pendingCount);
     return promise;
 }

package/node_modules/@getpaseo/server/dist/server/web-ui/_expo/static/js/web/{desktop-attachment-bridge-ffe0cd60080175f6fb2dec3200390aec.js → desktop-attachment-bridge-e52f9cb2de89e698c51c18241d12cb99.js}

@@ -1 +1 @@
-__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentBridge=function(){const l=(0,s.createDesktopPreviewUrlResolver)({reader:(0,s.createDesktopFileReader)(),objectUrls:(0,s.createBrowserObjectUrlMinter)()});return{copyFile:t.copyDesktopAttachmentFile,writeBase64:t.writeDesktopAttachmentBase64,writeBytes:t.writeDesktopAttachmentBytes,deleteFile:t.deleteDesktopAttachmentFile,garbageCollect:t.garbageCollectDesktopAttachmentFiles,readFileBase64:s.readDesktopFileBase64,resolvePreviewUrl:t=>l.resolve(t),releasePreviewUrl:t=>l.release(t)}};var t=r(d[0]),s=r(d[1])},5198,[4426,4427]);
+__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentBridge=function(){const l=(0,s.createDesktopPreviewUrlResolver)({reader:(0,s.createDesktopFileReader)(),objectUrls:(0,s.createBrowserObjectUrlMinter)()});return{copyFile:t.copyDesktopAttachmentFile,writeBase64:t.writeDesktopAttachmentBase64,writeBytes:t.writeDesktopAttachmentBytes,deleteFile:t.deleteDesktopAttachmentFile,garbageCollect:t.garbageCollectDesktopAttachmentFiles,readFileBase64:s.readDesktopFileBase64,resolvePreviewUrl:t=>l.resolve(t),releasePreviewUrl:t=>l.release(t)}};var t=r(d[0]),s=r(d[1])},5200,[4426,4427]);

package/node_modules/@getpaseo/server/dist/server/web-ui/_expo/static/js/web/{desktop-attachment-store-4d76abbc28cb391667944e7e96595e46.js → desktop-attachment-store-8cb998792f7a176d7612229dafb2c2d3.js}

@@ -1 +1 @@
-__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentStore=function(n){return{storageType:"desktop-file",async save(s){const o=s.id??(0,t.generateAttachmentId)(),l=s.fileName??null;if("file_uri"===s.source.kind)return await c(n,{id:o,uri:s.source.uri,mimeType:s.mimeType,fileName:l});if("data_url"===s.source.kind){const c=(0,t.parseDataUrl)(s.source.dataUrl),p=(0,t.normalizeMimeType)(s.mimeType??c.mimeType);return await y(n,{id:o,base64:c.base64,mimeType:p,fileName:l})}if("bytes"===s.source.kind){const c=(0,t.normalizeMimeType)(s.mimeType);return await p(n,{id:o,bytes:s.source.bytes,mimeType:c,fileName:l})}const f=(0,t.normalizeMimeType)(s.mimeType??s.source.blob.type),u=await(0,t.blobToBase64)(s.source.blob);return await y(n,{id:o,base64:u,mimeType:f,fileName:l})},encodeBase64:async({attachment:t})=>(f(t),await n.readFileBase64(t.storageKey)),resolvePreviewUrl:async({attachment:t})=>(f(t),await n.resolvePreviewUrl(t)),async releasePreviewUrl({attachment:t,url:s}){f(t),await n.releasePreviewUrl({url:s})},async delete({attachment:t}){f(t),await n.deleteFile({path:t.storageKey})},async garbageCollect({referencedIds:t}){await n.garbageCollect({referencedIds:Array.from(t)})}}};var t=r(d[0]);const n={"image/png":".png","image/jpeg":".jpg","image/jpg":".jpg","image/gif":".gif","image/webp":".webp","image/avif":".avif","image/heic":".heic","image/heif":".heif","image/tiff":".tiff","image/bmp":".bmp","image/svg+xml":".svg"};function s(t){const n=t.replace(/\\/g,"/").split("/"),s=n[n.length-1];return s&&s.length>0?s:null}function o(s){const o=(0,t.getFileExtensionFromName)(s.fileName);if(o)return o;const l=(0,t.getFileExtensionFromName)(s.sourcePath);return l||(n[s.mimeType]??".img")}function l(t){return{id:t.id,mimeType:t.mimeType,storageType:"desktop-file",storageKey:t.storagePath,fileName:t.fileName??null,byteSize:t.byteSize,createdAt:Date.now()}}async function c(n,c){const y=(0,t.fileUriToPath)(c.uri),p=c.fileName??s(y),f=(0,t.normalizeMimeType)(c.mimeType),u=o({fileName:p,sourcePath:y,mimeType:f}),T=await n.copyFile({attachmentId:c.id,sourcePath:y,extension:u});return l({id:c.id,mimeType:f,storagePath:T.path,byteSize:T.byteSize,fileName:p})}async function y(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBase64({attachmentId:n.id,base64:n.base64,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}async function p(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBytes({attachmentId:n.id,bytes:n.bytes,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}function f(t){if("desktop-file"!==t.storageType)throw new Error(`Unsupported desktop attachment storage type '${t.storageType}'.`)}},5197,[4301]);
+__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentStore=function(n){return{storageType:"desktop-file",async save(s){const o=s.id??(0,t.generateAttachmentId)(),l=s.fileName??null;if("file_uri"===s.source.kind)return await c(n,{id:o,uri:s.source.uri,mimeType:s.mimeType,fileName:l});if("data_url"===s.source.kind){const c=(0,t.parseDataUrl)(s.source.dataUrl),p=(0,t.normalizeMimeType)(s.mimeType??c.mimeType);return await y(n,{id:o,base64:c.base64,mimeType:p,fileName:l})}if("bytes"===s.source.kind){const c=(0,t.normalizeMimeType)(s.mimeType);return await p(n,{id:o,bytes:s.source.bytes,mimeType:c,fileName:l})}const f=(0,t.normalizeMimeType)(s.mimeType??s.source.blob.type),u=await(0,t.blobToBase64)(s.source.blob);return await y(n,{id:o,base64:u,mimeType:f,fileName:l})},encodeBase64:async({attachment:t})=>(f(t),await n.readFileBase64(t.storageKey)),resolvePreviewUrl:async({attachment:t})=>(f(t),await n.resolvePreviewUrl(t)),async releasePreviewUrl({attachment:t,url:s}){f(t),await n.releasePreviewUrl({url:s})},async delete({attachment:t}){f(t),await n.deleteFile({path:t.storageKey})},async garbageCollect({referencedIds:t}){await n.garbageCollect({referencedIds:Array.from(t)})}}};var t=r(d[0]);const n={"image/png":".png","image/jpeg":".jpg","image/jpg":".jpg","image/gif":".gif","image/webp":".webp","image/avif":".avif","image/heic":".heic","image/heif":".heif","image/tiff":".tiff","image/bmp":".bmp","image/svg+xml":".svg"};function s(t){const n=t.replace(/\\/g,"/").split("/"),s=n[n.length-1];return s&&s.length>0?s:null}function o(s){const o=(0,t.getFileExtensionFromName)(s.fileName);if(o)return o;const l=(0,t.getFileExtensionFromName)(s.sourcePath);return l||(n[s.mimeType]??".img")}function l(t){return{id:t.id,mimeType:t.mimeType,storageType:"desktop-file",storageKey:t.storagePath,fileName:t.fileName??null,byteSize:t.byteSize,createdAt:Date.now()}}async function c(n,c){const y=(0,t.fileUriToPath)(c.uri),p=c.fileName??s(y),f=(0,t.normalizeMimeType)(c.mimeType),u=o({fileName:p,sourcePath:y,mimeType:f}),T=await n.copyFile({attachmentId:c.id,sourcePath:y,extension:u});return l({id:c.id,mimeType:f,storagePath:T.path,byteSize:T.byteSize,fileName:p})}async function y(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBase64({attachmentId:n.id,base64:n.base64,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}async function p(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBytes({attachmentId:n.id,bytes:n.bytes,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}function f(t){if("desktop-file"!==t.storageType)throw new Error(`Unsupported desktop attachment storage type '${t.storageType}'.`)}},5199,[4301]);