sidekick-shared 0.26.4 → 0.26.6

package/dist/providers/rolloutWalker.js

@@ -9,11 +9,16 @@
  * `limit` can stop early, stats each file exactly once, and returns results
  * newest first with the size and session id already attached.
  *
- * With `limit`, the early exit is by directory date: a rollout that was
- * created days ago but is still being written lands in its creation day's
- * directory, so a very small limit can miss it in favour of newer-dated,
- * older-modified files. Callers that need exact mtime order over the whole
- * history omit `limit` (the `maxFiles` cap still applies).
+ * With `limit` or `since`, the early exit is by directory date: a rollout
+ * that was created days ago but is still being written lands in its creation
+ * day's directory, so a very small limit (or a recent `since`) can miss it in
+ * favour of newer-dated, older-modified files. Callers that need exact mtime
+ * order over the whole history omit both (the `maxFiles` cap still applies);
+ * a live session missed this way is picked up by its next watch event.
+ *
+ * The async walker accepts a {@link DirectoryListingCache}: unchanged
+ * directories are then one stat each instead of a readdir plus a stat per
+ * file, which is what makes repeated discovery over a large history cheap.
  *
  * @module providers/rolloutWalker
  */
@@ -54,6 +59,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_ROLLOUT_WALK_MAX_FILES = exports.DEFAULT_ROLLOUT_WALK_MAX_DEPTH = void 0;
 exports.isRolloutFile = isRolloutFile;
 exports.extractRolloutSessionId = extractRolloutSessionId;
+exports.isDatedDirectoryBefore = isDatedDirectoryBefore;
 exports.walkRolloutFiles = walkRolloutFiles;
 exports.walkRolloutFilesAsync = walkRolloutFilesAsync;
 const fs = __importStar(require("fs"));
@@ -90,8 +96,12 @@ function walkState(options) {
         seen: new Set(),
         cap: Math.min(maxFiles, limit),
         maxDepth: options.maxDepth ?? exports.DEFAULT_ROLLOUT_WALK_MAX_DEPTH,
+        since: options.since !== undefined && Number.isFinite(options.since) ? options.since : null,
         sessionId: options.sessionId ? options.sessionId.trim().toLowerCase() : null,
         includeEmpty: options.includeEmpty ?? false,
+        cache: options.cache ?? null,
+        revalidateRecent: options.revalidateRecent ?? false,
+        stats: options.stats,
     };
 }
 /** Newest-dated first: directory and file names sort descending. */
@@ -106,12 +116,14 @@ function matchesFilter(state, name) {
 function record(state, fullPath, name, stat) {
     if (!state.includeEmpty && stat.size <= 0)
         return;
+    if (state.since !== null && stat.mtimeMs < state.since)
+        return;
     if (state.seen.has(fullPath))
         return;
     state.seen.add(fullPath);
     state.results.push({
         path: fullPath,
-        mtime: stat.mtime,
+        mtime: new Date(stat.mtimeMs),
         sizeBytes: stat.size,
         sessionId: extractRolloutSessionId(name),
     });
@@ -119,9 +131,38 @@ function record(state, fullPath, name, stat) {
 function finish(state) {
     return state.results.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
 }
-function visitSync(state, dir, depth) {
+/** Slack added to a dated directory's range so a timezone skew cannot prune a live day. */
+const DATE_DIR_SLACK_MS = 24 * 60 * 60_000;
+/**
+ * True when `segments` (the directory names below the root, e.g. `['2026',
+ * '09', '04']`) are all numeric and describe a year, month, or day that ended
+ * more than a day before `since`. Non-numeric names are never pruned.
+ */
+function isDatedDirectoryBefore(segments, since) {
+    if (segments.length === 0 || segments.length > 3)
+        return false;
+    const numbers = segments.map((segment) => (/^\d+$/.test(segment) ? Number(segment) : NaN));
+    if (numbers.some((value) => !Number.isFinite(value)))
+        return false;
+    const [year, month, day] = numbers;
+    if (year < 1970 || year > 9999)
+        return false;
+    if (segments.length >= 2 && (month < 1 || month > 12))
+        return false;
+    if (segments.length === 3 && (day < 1 || day > 31))
+        return false;
+    const rangeEnd = segments.length === 1
+        ? new Date(year + 1, 0, 1).getTime()
+        : segments.length === 2
+            ? new Date(year, month, 1).getTime()
+            : new Date(year, month - 1, day + 1).getTime();
+    return rangeEnd + DATE_DIR_SLACK_MS < since;
+}
+function visitSync(state, dir, depth, segments) {
     if (depth > state.maxDepth || state.results.length >= state.cap)
         return;
+    if (state.since !== null && isDatedDirectoryBefore(segments, state.since))
+        return;
     let entries;
     try {
         entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -146,8 +187,9 @@ function visitSync(state, dir, depth) {
     for (const entry of entries) {
         if (state.results.length >= state.cap)
             return;
-        if (entry.isDirectory())
-            visitSync(state, path.join(dir, entry.name), depth + 1);
+        if (entry.isDirectory()) {
+            visitSync(state, path.join(dir, entry.name), depth + 1, [...segments, entry.name]);
+        }
     }
 }
 /**
@@ -157,18 +199,52 @@ function visitSync(state, dir, depth) {
 function walkRolloutFiles(roots, options = {}) {
     const state = walkState(options);
     for (const root of roots)
-        visitSync(state, root, 0);
+        visitSync(state, root, 0, []);
     return finish(state);
 }
 function yieldToEventLoop() {
     return new Promise((resolve) => setImmediate(resolve));
 }
-async function visitAsync(state, dir, depth) {
+function byStringDescending(a, b) {
+    return b.localeCompare(a);
+}
+async function visitCached(state, cache, dir, depth, segments) {
     if (depth > state.maxDepth || state.results.length >= state.cap)
         return;
+    if (state.since !== null && isDatedDirectoryBefore(segments, state.since))
+        return;
+    const listing = await cache.listDirectory(dir, (name) => matchesFilter(state, name), {
+        revalidateRecent: state.revalidateRecent,
+        stats: state.stats,
+    });
+    if (!listing)
+        return;
+    const names = [...listing.files.keys()].sort(byStringDescending);
+    for (const name of names) {
+        if (state.results.length >= state.cap)
+            return;
+        const stat = listing.files.get(name);
+        if (!stat)
+            continue;
+        record(state, path.join(dir, name), name, { size: stat.sizeBytes, mtimeMs: stat.mtimeMs });
+    }
+    await yieldToEventLoop();
+    for (const name of [...listing.subdirectories].sort(byStringDescending)) {
+        if (state.results.length >= state.cap)
+            return;
+        await visitCached(state, cache, path.join(dir, name), depth + 1, [...segments, name]);
+    }
+}
+async function visitAsync(state, dir, depth, segments) {
+    if (depth > state.maxDepth || state.results.length >= state.cap)
+        return;
+    if (state.since !== null && isDatedDirectoryBefore(segments, state.since))
+        return;
     let entries;
     try {
         entries = await fs.promises.readdir(dir, { withFileTypes: true });
+        if (state.stats)
+            state.stats.directoriesListed = (state.stats.directoriesListed ?? 0) + 1;
     }
     catch {
         return;
@@ -182,7 +258,10 @@ async function visitAsync(state, dir, depth) {
             continue;
         const fullPath = path.join(dir, entry.name);
         try {
-            record(state, fullPath, entry.name, await fs.promises.stat(fullPath));
+            const stat = await fs.promises.stat(fullPath);
+            if (state.stats)
+                state.stats.filesStatted = (state.stats.filesStatted ?? 0) + 1;
+            record(state, fullPath, entry.name, stat);
         }
         catch {
             // Skip files that vanish between readdir and stat.
@@ -196,14 +275,19 @@ async function visitAsync(state, dir, depth) {
     for (const entry of entries) {
         if (state.results.length >= state.cap)
             return;
-        if (entry.isDirectory())
-            await visitAsync(state, path.join(dir, entry.name), depth + 1);
+        if (entry.isDirectory()) {
+            await visitAsync(state, path.join(dir, entry.name), depth + 1, [...segments, entry.name]);
+        }
     }
 }
 /** Async twin of {@link walkRolloutFiles} that yields between directories. */
 async function walkRolloutFilesAsync(roots, options = {}) {
     const state = walkState(options);
-    for (const root of roots)
-        await visitAsync(state, root, 0);
+    for (const root of roots) {
+        if (state.cache)
+            await visitCached(state, state.cache, root, 0, []);
+        else
+            await visitAsync(state, root, 0, []);
+    }
     return finish(state);
 }

package/dist/providers/types.d.ts

@@ -59,6 +59,46 @@ export interface SessionFileInfo {
     /** Optional provider-recorded creation timestamp. */
     createdAt?: Date;
 }
+/** Payload-free counters of what an enumeration cost. */
+export interface SessionEnumerationCounters {
+    directoriesListed?: number;
+    directoriesStatted?: number;
+    filesStatted?: number;
+}
+/** Options for `listSessionFilesAsync()`; every field is optional and additive. */
+export interface ListSessionFilesOptions {
+    /** Return at most this many files, newest first (may skip an old-directory live session; see rolloutWalker). */
+    limit?: number;
+    /** Only files modified at or after this epoch-ms. */
+    since?: number;
+    /** Re-stat recently modified files even when their directory is unchanged. */
+    revalidateRecent?: boolean;
+    /** Counters the enumerator increments for real readdir/stat calls. */
+    stats?: SessionEnumerationCounters;
+}
+/**
+ * What a recursive-watch event under one of the provider's watch roots maps
+ * to, resolved with at most one stat.
+ *
+ * - `ignored`: structurally not a session of this provider (wrong depth or
+ *   extension, another workspace); nothing to do.
+ * - `unknown`: a directory or something the provider cannot classify; the
+ *   caller should fall back to a full enumeration.
+ * - `missing`: the path names a session that is gone or still empty.
+ * - `present`: the session file with its current stat.
+ */
+export type WatchedSessionFile = {
+    status: 'ignored';
+} | {
+    status: 'unknown';
+} | {
+    status: 'missing';
+    path: string;
+    sessionId: string;
+} | {
+    status: 'present';
+    file: SessionFileInfo;
+};
 /** How much of a session `readSessionStats()` could read. */
 export type SessionFileStatsAvailability = 'full' | 'partial' | 'unavailable';
 /**
@@ -225,7 +265,14 @@ export interface SessionProviderBase {
      */
     listAllSessionFiles?(): SessionFileInfo[];
     /** Event-loop-safe enumeration used by async preview and subscription APIs. */
-    listSessionFilesAsync?(workspacePath?: string): Promise<SessionFileInfo[]>;
+    listSessionFilesAsync?(workspacePath?: string, options?: ListSessionFilesOptions): Promise<SessionFileInfo[]>;
+    /**
+     * Resolve a recursive-watch event (`root` from `getWatchRoots()`, the
+     * root-relative `relativePath` the watcher reported) to a session file with
+     * at most one stat, applying the same workspace filter as
+     * `listSessionFilesAsync(workspacePath)`.
+     */
+    statWatchedSessionFile?(root: string, relativePath: string, workspacePath?: string): Promise<WatchedSessionFile>;
     /** Batch label extraction. DB-backed implementations use at most one query. */
     extractSessionLabelsAsync?(sessionPaths: readonly string[]): Promise<Map<string, string | null>>;
     /** Tests whether a provider can monitor a directory path, including synthetic DB-backed paths. */

package/dist/schemas/accountManager.d.ts

@@ -28,16 +28,18 @@ export declare const beginAccountLoginResultSchema: z.ZodUnion<readonly [z.ZodOb
     command: z.ZodOptional<z.ZodString>;
     args: z.ZodOptional<z.ZodArray<z.ZodString>>;
     env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    envUnset: z.ZodOptional<z.ZodArray<z.ZodString>>;
     configDir: z.ZodOptional<z.ZodString>;
+    existingAccountId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     success: z.ZodLiteral<false>;
     error: z.ZodString;
 }, z.core.$strip>]>;
 export declare const accountLoginStatusSchema: z.ZodObject<{
     state: z.ZodEnum<{
+        failed: "failed";
         pending: "pending";
         authenticated: "authenticated";
-        failed: "failed";
     }>;
     email: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodString>;
@@ -67,6 +69,12 @@ export declare const savedAccountProfileSchema: z.ZodObject<{
             chatgpt: "chatgpt";
             "api-key": "api-key";
         }>>;
+        origin: z.ZodOptional<z.ZodEnum<{
+            login: "login";
+            manual: "manual";
+            "live-sync": "live-sync";
+            migration: "migration";
+        }>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const listAllAccountsResultSchema: z.ZodObject<{
@@ -95,6 +103,12 @@ export declare const listAllAccountsResultSchema: z.ZodObject<{
                 chatgpt: "chatgpt";
                 "api-key": "api-key";
             }>>;
+            origin: z.ZodOptional<z.ZodEnum<{
+                login: "login";
+                manual: "manual";
+                "live-sync": "live-sync";
+                migration: "migration";
+            }>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     activeByProvider: z.ZodObject<{
@@ -102,3 +116,271 @@ export declare const listAllAccountsResultSchema: z.ZodObject<{
         codex: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
+export declare const accountHealthStateSchema: z.ZodEnum<{
+    unknown: "unknown";
+    fresh: "fresh";
+    expiring: "expiring";
+    expired: "expired";
+    missing: "missing";
+}>;
+export declare const accountHealthSourceSchema: z.ZodEnum<{
+    login: "login";
+    "live-sync": "live-sync";
+    migration: "migration";
+    switch: "switch";
+    keepalive: "keepalive";
+}>;
+export declare const accountHealthSidecarSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    capturedAt: z.ZodNumber;
+    accessExpiresAt: z.ZodOptional<z.ZodNumber>;
+    refreshExpiresAt: z.ZodOptional<z.ZodNumber>;
+    refreshExpiryEstimated: z.ZodOptional<z.ZodBoolean>;
+    lastRefreshAt: z.ZodOptional<z.ZodNumber>;
+    hasRefreshToken: z.ZodOptional<z.ZodBoolean>;
+    authMode: z.ZodOptional<z.ZodEnum<{
+        chatgpt: "chatgpt";
+        "api-key": "api-key";
+        oauth: "oauth";
+    }>>;
+    source: z.ZodEnum<{
+        login: "login";
+        "live-sync": "live-sync";
+        migration: "migration";
+        switch: "switch";
+        keepalive: "keepalive";
+    }>;
+}, z.core.$strip>;
+export declare const accountHealthSchema: z.ZodObject<{
+    providerId: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+    }>;
+    accountId: z.ZodString;
+    state: z.ZodEnum<{
+        unknown: "unknown";
+        fresh: "fresh";
+        expiring: "expiring";
+        expired: "expired";
+        missing: "missing";
+    }>;
+    accessExpiresAt: z.ZodOptional<z.ZodNumber>;
+    refreshExpiresAt: z.ZodOptional<z.ZodNumber>;
+    refreshExpiryEstimated: z.ZodOptional<z.ZodBoolean>;
+    lastRefreshAt: z.ZodOptional<z.ZodNumber>;
+    checkedAt: z.ZodNumber;
+    isLive: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const accountViewSchema: z.ZodObject<{
+    id: z.ZodString;
+    providerId: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+    }>;
+    label: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    planType: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodBoolean;
+    health: z.ZodObject<{
+        providerId: z.ZodEnum<{
+            "claude-code": "claude-code";
+            codex: "codex";
+        }>;
+        accountId: z.ZodString;
+        state: z.ZodEnum<{
+            unknown: "unknown";
+            fresh: "fresh";
+            expiring: "expiring";
+            expired: "expired";
+            missing: "missing";
+        }>;
+        accessExpiresAt: z.ZodOptional<z.ZodNumber>;
+        refreshExpiresAt: z.ZodOptional<z.ZodNumber>;
+        refreshExpiryEstimated: z.ZodOptional<z.ZodBoolean>;
+        lastRefreshAt: z.ZodOptional<z.ZodNumber>;
+        checkedAt: z.ZodNumber;
+        isLive: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    source: z.ZodEnum<{
+        registered: "registered";
+        learned: "learned";
+    }>;
+    addedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const runningProcessSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+    name: z.ZodString;
+    command: z.ZodString;
+}, z.core.$strip>;
+export declare const accountConsumerKindSchema: z.ZodEnum<{
+    "claude-cli": "claude-cli";
+    "claude-desktop": "claude-desktop";
+    "codex-cli": "codex-cli";
+    "codex-app": "codex-app";
+    "vscode-extension-host": "vscode-extension-host";
+}>;
+export declare const runningAccountConsumerSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "claude-cli": "claude-cli";
+        "claude-desktop": "claude-desktop";
+        "codex-cli": "codex-cli";
+        "codex-app": "codex-app";
+        "vscode-extension-host": "vscode-extension-host";
+    }>;
+    pids: z.ZodArray<z.ZodNumber>;
+    switched: z.ZodBoolean;
+    reachability: z.ZodString;
+}, z.core.$strip>;
+export declare const switchAccountResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+    warning: z.ZodOptional<z.ZodString>;
+    needsLogin: z.ZodOptional<z.ZodBoolean>;
+    profileId: z.ZodOptional<z.ZodString>;
+    codexHome: z.ZodOptional<z.ZodString>;
+    provider: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+    }>;
+    accountId: z.ZodString;
+    previousAccountId: z.ZodNullable<z.ZodString>;
+    verified: z.ZodBoolean;
+    verification: z.ZodEnum<{
+        none: "none";
+        store: "store";
+        cli: "cli";
+        failed: "failed";
+    }>;
+    health: z.ZodOptional<z.ZodObject<{
+        providerId: z.ZodEnum<{
+            "claude-code": "claude-code";
+            codex: "codex";
+        }>;
+        accountId: z.ZodString;
+        state: z.ZodEnum<{
+            unknown: "unknown";
+            fresh: "fresh";
+            expiring: "expiring";
+            expired: "expired";
+            missing: "missing";
+        }>;
+        accessExpiresAt: z.ZodOptional<z.ZodNumber>;
+        refreshExpiresAt: z.ZodOptional<z.ZodNumber>;
+        refreshExpiryEstimated: z.ZodOptional<z.ZodBoolean>;
+        lastRefreshAt: z.ZodOptional<z.ZodNumber>;
+        checkedAt: z.ZodNumber;
+        isLive: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    warnings: z.ZodArray<z.ZodString>;
+    hints: z.ZodArray<z.ZodString>;
+    runningConsumers: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "claude-cli": "claude-cli";
+            "claude-desktop": "claude-desktop";
+            "codex-cli": "codex-cli";
+            "codex-app": "codex-app";
+            "vscode-extension-host": "vscode-extension-host";
+        }>;
+        pids: z.ZodArray<z.ZodNumber>;
+        switched: z.ZodBoolean;
+        reachability: z.ZodString;
+    }, z.core.$strip>>;
+    undoToken: z.ZodOptional<z.ZodString>;
+    alreadyActive: z.ZodOptional<z.ZodBoolean>;
+    email: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const lastSwitchRecordSchema: z.ZodObject<{
+    token: z.ZodString;
+    provider: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+    }>;
+    from: z.ZodNullable<z.ZodString>;
+    to: z.ZodString;
+    at: z.ZodString;
+}, z.core.$strip>;
+export declare const providerSyncReportSchema: z.ZodObject<{
+    registered: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    folded: z.ZodOptional<z.ZodString>;
+    repointed: z.ZodOptional<z.ZodString>;
+    merged: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skipped: z.ZodOptional<z.ZodString>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const syncReportSchema: z.ZodObject<{
+    claude: z.ZodObject<{
+        registered: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            email: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        folded: z.ZodOptional<z.ZodString>;
+        repointed: z.ZodOptional<z.ZodString>;
+        merged: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        skipped: z.ZodOptional<z.ZodString>;
+        warnings: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    codex: z.ZodObject<{
+        registered: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            email: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        folded: z.ZodOptional<z.ZodString>;
+        repointed: z.ZodOptional<z.ZodString>;
+        merged: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        skipped: z.ZodOptional<z.ZodString>;
+        warnings: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    ranAt: z.ZodNumber;
+    reason: z.ZodEnum<{
+        poll: "poll";
+        manual: "manual";
+        startup: "startup";
+        watch: "watch";
+        "pre-switch": "pre-switch";
+    }>;
+}, z.core.$strip>;
+export declare const accountLaunchEnvSchema: z.ZodObject<{
+    provider: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+    }>;
+    accountId: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    home: z.ZodString;
+    env: z.ZodRecord<z.ZodString, z.ZodString>;
+    envUnset: z.ZodArray<z.ZodString>;
+    command: z.ZodEnum<{
+        codex: "codex";
+        claude: "claude";
+    }>;
+    health: z.ZodObject<{
+        providerId: z.ZodEnum<{
+            "claude-code": "claude-code";
+            codex: "codex";
+        }>;
+        accountId: z.ZodString;
+        state: z.ZodEnum<{
+            unknown: "unknown";
+            fresh: "fresh";
+            expiring: "expiring";
+            expired: "expired";
+            missing: "missing";
+        }>;
+        accessExpiresAt: z.ZodOptional<z.ZodNumber>;
+        refreshExpiresAt: z.ZodOptional<z.ZodNumber>;
+        refreshExpiryEstimated: z.ZodOptional<z.ZodBoolean>;
+        lastRefreshAt: z.ZodOptional<z.ZodNumber>;
+        checkedAt: z.ZodNumber;
+        isLive: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    warnings: z.ZodArray<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;