@getpaseo/protocol 0.3.0-beta.4 → 0.3.1

package/dist/messages.js

@@ -238,6 +238,19 @@ const McpServerConfigSchema = z.discriminatedUnion("type", [
     McpHttpServerConfigSchema,
     McpSseServerConfigSchema,
 ]);
+const ProviderOptionsSchema = z.record(z.string(), z.json());
+const McpToolRefSchema = z
+    .object({
+    kind: z.literal("mcp"),
+    server: z.string().trim().min(1),
+    tool: z.string().trim().min(1),
+})
+    .strict();
+const ToolPolicySchema = z
+    .object({
+    preapproved: z.array(McpToolRefSchema),
+})
+    .strict();
 const AgentSessionConfigSchema = z.object({
     provider: AgentProviderSchema,
     cwd: z.string(),
@@ -246,17 +259,8 @@ const AgentSessionConfigSchema = z.object({
     thinkingOptionId: z.string().optional(),
     featureValues: z.record(z.string(), z.unknown()).optional(),
     title: z.string().trim().min(1).max(MAX_EXPLICIT_AGENT_TITLE_CHARS).optional().nullable(),
-    approvalPolicy: z.string().optional(),
-    sandboxMode: z.string().optional(),
-    networkAccess: z.boolean().optional(),
-    webSearch: z.boolean().optional(),
-    extra: z
-        .object({
-        codex: z.record(z.string(), z.unknown()).optional(),
-        claude: z.record(z.string(), z.unknown()).optional(),
-    })
-        .partial()
-        .optional(),
+    providerOptions: ProviderOptionsSchema.optional(),
+    toolPolicy: ToolPolicySchema.optional(),
     systemPrompt: z.string().optional(),
     mcpServers: z.record(z.string(), McpServerConfigSchema).optional(),
 });
@@ -927,6 +931,10 @@ export const FetchAgentHistoryRequestMessageSchema = z.object({
     type: z.literal("fetch_agent_history_request"),
     requestId: z.string(),
     filter: AgentDirectoryFilterSchema.optional(),
+    // A ranked free-text query over agent title, workspace name, branch, and
+    // project name. Present only on history: agent subscriptions filter on
+    // structure, not on relevance. Ranking replaces `sort` when it is set.
+    search: z.string().optional(),
     sort: z
         .array(z.object({
         key: z.enum(["status_priority", "created_at", "updated_at", "title"]),
@@ -2117,15 +2125,38 @@ export const HubExecutionAgentCreateRequestSchema = z.object({
     provider: z.string(),
     cwd: z.string(),
     prompt: z.string(),
+    // COMPAT(hubExecutionWorkspaceSelection): semantics retired in v0.3.1; remove after 2027-08-08 once the Hub floor no longer sends it.
     workspaceId: z.string().optional(),
     model: z.string().optional(),
     modeId: z.string().optional(),
     thinkingOptionId: z.string().optional(),
     featureValues: z.record(z.string(), z.unknown()).optional(),
+    providerOptions: ProviderOptionsSchema.optional(),
+    toolPolicy: ToolPolicySchema.optional(),
     env: z.record(z.string(), z.string()).optional(),
     mcpServers: z.record(z.string(), McpServerConfigSchema).optional(),
     worktree: CreateAgentWorktreeTargetSchema.optional(),
 });
+const HubExecutionAgentCreateErrorSchema = z.discriminatedUnion("code", [
+    z.object({
+        code: z.literal("provider_options_invalid"),
+        provider: z.string(),
+        issues: z.array(z.object({
+            path: z.array(z.union([z.string(), z.number()])),
+            message: z.string(),
+        })),
+        message: z.string(),
+    }),
+    z.object({
+        code: z.literal("tool_policy_unsupported"),
+        provider: z.string(),
+        message: z.string(),
+    }),
+    z.object({
+        code: z.literal("create_failed"),
+        message: z.string(),
+    }),
+]);
 export const HubExecutionControlActionSchema = z.enum(["interrupt", "archive"]);
 export const HubExecutionControlRequestSchema = z.object({
     type: z.literal("hub.execution.control.request"),
@@ -2464,6 +2495,8 @@ export const ServerInfoStatusPayloadSchema = z
         rewind: z.boolean().optional(),
         // COMPAT(agentTimelinePromptIndex): added in v0.2.X, drop the gate when floor >= v0.2.X.
         agentTimelinePromptIndex: z.boolean().optional(),
+        // COMPAT(agentHistorySearch): added in v0.3.0, remove gate after 2027-02-07.
+        agentHistorySearch: z.boolean().optional(),
         // COMPAT(checkoutRefresh): added in v0.1.86, remove gate after 2026-11-29.
         checkoutRefresh: z.boolean().optional(),
         // COMPAT(workspaceMultiplicity): added in v0.1.97, drop the gate when floor >= v0.1.97
@@ -2858,9 +2891,25 @@ export const AgentListMessageSchema = z.object({
         agents: z.array(AgentSnapshotPayloadSchema),
     }),
 });
+export const AgentSearchMatchFieldSchema = z.enum(["workspace", "title", "branch", "project"]);
+export const AgentSearchMatchSchema = z.object({
+    field: AgentSearchMatchFieldSchema,
+    ranges: z.array(z.object({
+        start: z.number().int().nonnegative(),
+        length: z.number().int().positive(),
+    })),
+});
 const AgentDirectoryResponseEntrySchema = z.object({
     agent: AgentSnapshotPayloadSchema,
     project: ProjectPlacementPayloadSchema,
+    // Relevance of this entry to the request's `search`, lower being better.
+    // Set only when the request carried a query; a client merging results from
+    // several hosts needs it to interleave their separately ranked pages.
+    searchScore: z.number().optional(),
+    // Where the query matched, so the row can mark it. The ranker computes this
+    // anyway; sending it keeps the client from re-deriving a second opinion that
+    // could disagree with the ranking it is explaining.
+    searchMatches: z.array(AgentSearchMatchSchema).optional(),
 });
 const AgentDirectoryPageInfoSchema = z.object({
     nextCursor: z.string().nullable(),
@@ -2882,6 +2931,10 @@ export const FetchAgentHistoryResponseMessageSchema = z.object({
         requestId: z.string(),
         entries: z.array(AgentDirectoryResponseEntrySchema),
         pageInfo: AgentDirectoryPageInfoSchema,
+        // More sessions matched the request's `search` than the page could hold.
+        // Distinct from `pageInfo.hasMore`, which promises a fetchable next page —
+        // a ranked result set has none, and the way on is a narrower query.
+        searchTruncated: z.boolean().optional(),
     }),
 });
 export const FetchRecentProviderSessionsResponseMessageSchema = z.object({
@@ -4614,7 +4667,8 @@ export const HubExecutionAgentCreateResponseSchema = z.object({
         agentId: z.string().nullable(),
         agent: AgentSnapshotPayloadSchema.nullable(),
         success: z.boolean(),
-        error: z.string().nullable(),
+        toolPolicyApplied: z.literal(true).optional(),
+        error: HubExecutionAgentCreateErrorSchema.nullable(),
     }),
 });
 export const HubExecutionControlResponseSchema = z.object({

package/dist/schedule/rpc-schemas.d.ts

@@ -32,15 +32,8 @@ export declare const ScheduleCreateRequestSchema: z.ZodObject<{
                 worktree: "worktree";
             }>>;
             title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            approvalPolicy: z.ZodOptional<z.ZodString>;
-            sandboxMode: z.ZodOptional<z.ZodString>;
-            networkAccess: z.ZodOptional<z.ZodBoolean>;
-            webSearch: z.ZodOptional<z.ZodBoolean>;
+            providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
             featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            extra: z.ZodOptional<z.ZodObject<{
-                codex: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                claude: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-            }, z.core.$strip>>;
             systemPrompt: z.ZodOptional<z.ZodString>;
             mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>;
@@ -151,15 +144,8 @@ export declare const ScheduleCreateResponseSchema: z.ZodObject<{
                         worktree: "worktree";
                     }>>;
                     title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    approvalPolicy: z.ZodOptional<z.ZodString>;
-                    sandboxMode: z.ZodOptional<z.ZodString>;
-                    networkAccess: z.ZodOptional<z.ZodBoolean>;
-                    webSearch: z.ZodOptional<z.ZodBoolean>;
+                    providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
                     featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                    extra: z.ZodOptional<z.ZodObject<{
-                        codex: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                        claude: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                    }, z.core.$strip>>;
                     systemPrompt: z.ZodOptional<z.ZodString>;
                     mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 }, z.core.$strip>;
@@ -213,15 +199,8 @@ export declare const ScheduleListResponseSchema: z.ZodObject<{
                         worktree: "worktree";
                     }>>;
                     title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    approvalPolicy: z.ZodOptional<z.ZodString>;
-                    sandboxMode: z.ZodOptional<z.ZodString>;
-                    networkAccess: z.ZodOptional<z.ZodBoolean>;
-                    webSearch: z.ZodOptional<z.ZodBoolean>;
+                    providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
                     featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                    extra: z.ZodOptional<z.ZodObject<{
-                        codex: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                        claude: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                    }, z.core.$strip>>;
                     systemPrompt: z.ZodOptional<z.ZodString>;
                     mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 }, z.core.$strip>;
@@ -269,15 +248,8 @@ export declare const ScheduleInspectResponseSchema: z.ZodObject<{
                         worktree: "worktree";
                     }>>;
                     title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    approvalPolicy: z.ZodOptional<z.ZodString>;
-                    sandboxMode: z.ZodOptional<z.ZodString>;
-                    networkAccess: z.ZodOptional<z.ZodBoolean>;
-                    webSearch: z.ZodOptional<z.ZodBoolean>;
+                    providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
                     featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                    extra: z.ZodOptional<z.ZodObject<{
-                        codex: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                        claude: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                    }, z.core.$strip>>;
                     systemPrompt: z.ZodOptional<z.ZodString>;
                     mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 }, z.core.$strip>;
@@ -374,15 +346,8 @@ export declare const SchedulePauseResponseSchema: z.ZodObject<{
                         worktree: "worktree";
                     }>>;
                     title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    approvalPolicy: z.ZodOptional<z.ZodString>;
-                    sandboxMode: z.ZodOptional<z.ZodString>;
-                    networkAccess: z.ZodOptional<z.ZodBoolean>;
-                    webSearch: z.ZodOptional<z.ZodBoolean>;
+                    providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
                     featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                    extra: z.ZodOptional<z.ZodObject<{
-                        codex: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                        claude: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                    }, z.core.$strip>>;
                     systemPrompt: z.ZodOptional<z.ZodString>;
                     mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 }, z.core.$strip>;
@@ -436,15 +401,8 @@ export declare const ScheduleResumeResponseSchema: z.ZodObject<{
                         worktree: "worktree";
                     }>>;
                     title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    approvalPolicy: z.ZodOptional<z.ZodString>;
-                    sandboxMode: z.ZodOptional<z.ZodString>;
-                    networkAccess: z.ZodOptional<z.ZodBoolean>;
-                    webSearch: z.ZodOptional<z.ZodBoolean>;
+                    providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
                     featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                    extra: z.ZodOptional<z.ZodObject<{
-                        codex: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                        claude: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                    }, z.core.$strip>>;
                     systemPrompt: z.ZodOptional<z.ZodString>;
                     mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 }, z.core.$strip>;
@@ -500,15 +458,8 @@ export declare const ScheduleRunOnceResponseSchema: z.ZodObject<{
                         worktree: "worktree";
                     }>>;
                     title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    approvalPolicy: z.ZodOptional<z.ZodString>;
-                    sandboxMode: z.ZodOptional<z.ZodString>;
-                    networkAccess: z.ZodOptional<z.ZodBoolean>;
-                    webSearch: z.ZodOptional<z.ZodBoolean>;
+                    providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
                     featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                    extra: z.ZodOptional<z.ZodObject<{
-                        codex: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                        claude: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                    }, z.core.$strip>>;
                     systemPrompt: z.ZodOptional<z.ZodString>;
                     mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 }, z.core.$strip>;
@@ -577,15 +528,8 @@ export declare const ScheduleUpdateResponseSchema: z.ZodObject<{
                         worktree: "worktree";
                     }>>;
                     title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    approvalPolicy: z.ZodOptional<z.ZodString>;
-                    sandboxMode: z.ZodOptional<z.ZodString>;
-                    networkAccess: z.ZodOptional<z.ZodBoolean>;
-                    webSearch: z.ZodOptional<z.ZodBoolean>;
+                    providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
                     featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                    extra: z.ZodOptional<z.ZodObject<{
-                        codex: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                        claude: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                    }, z.core.$strip>>;
                     systemPrompt: z.ZodOptional<z.ZodString>;
                     mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 }, z.core.$strip>;

package/dist/schedule/types.d.ts

@@ -31,15 +31,8 @@ export declare const ScheduleTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
             worktree: "worktree";
         }>>;
         title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        approvalPolicy: z.ZodOptional<z.ZodString>;
-        sandboxMode: z.ZodOptional<z.ZodString>;
-        networkAccess: z.ZodOptional<z.ZodBoolean>;
-        webSearch: z.ZodOptional<z.ZodBoolean>;
+        providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
         featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        extra: z.ZodOptional<z.ZodObject<{
-            codex: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-            claude: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        }, z.core.$strip>>;
         systemPrompt: z.ZodOptional<z.ZodString>;
         mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>;
@@ -90,15 +83,8 @@ export declare const StoredScheduleSchema: z.ZodObject<{
                 worktree: "worktree";
             }>>;
             title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            approvalPolicy: z.ZodOptional<z.ZodString>;
-            sandboxMode: z.ZodOptional<z.ZodString>;
-            networkAccess: z.ZodOptional<z.ZodBoolean>;
-            webSearch: z.ZodOptional<z.ZodBoolean>;
+            providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
             featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            extra: z.ZodOptional<z.ZodObject<{
-                codex: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                claude: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-            }, z.core.$strip>>;
             systemPrompt: z.ZodOptional<z.ZodString>;
             mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>;
@@ -167,15 +153,8 @@ export declare const ScheduleSummarySchema: z.ZodObject<{
                 worktree: "worktree";
             }>>;
             title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            approvalPolicy: z.ZodOptional<z.ZodString>;
-            sandboxMode: z.ZodOptional<z.ZodString>;
-            networkAccess: z.ZodOptional<z.ZodBoolean>;
-            webSearch: z.ZodOptional<z.ZodBoolean>;
+            providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
             featureValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            extra: z.ZodOptional<z.ZodObject<{
-                codex: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-                claude: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-            }, z.core.$strip>>;
             systemPrompt: z.ZodOptional<z.ZodString>;
             mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>;

package/dist/schedule/types.js

@@ -28,18 +28,8 @@ export const ScheduleTargetSchema = z.discriminatedUnion("type", [
             archiveOnFinish: z.boolean().optional(),
             isolation: z.enum(["local", "worktree"]).optional(),
             title: z.string().trim().min(1).nullable().optional(),
-            approvalPolicy: z.string().trim().min(1).optional(),
-            sandboxMode: z.string().trim().min(1).optional(),
-            networkAccess: z.boolean().optional(),
-            webSearch: z.boolean().optional(),
+            providerOptions: z.record(z.string(), z.json()).optional(),
             featureValues: z.record(z.string(), z.unknown()).optional(),
-            extra: z
-                .object({
-                codex: z.record(z.string(), z.unknown()).optional(),
-                claude: z.record(z.string(), z.unknown()).optional(),
-            })
-                .partial()
-                .optional(),
             systemPrompt: z.string().optional(),
             mcpServers: z.record(z.string(), z.unknown()).optional(),
         }),

package/dist/search/text-match.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Ranked text matching shared by the app's pickers and the daemon's history
+ * search. A match is a tier plus the offset it was found at; lower is better on
+ * both, so callers sort ascending and never have to invent a scale.
+ *
+ * Typo tolerance is opt-in via `fuzzy`. The pickers leave it off — a combobox
+ * over a known list wants exact narrowing — while history search turns it on
+ * because the user is recalling a title from memory.
+ */
+export interface MatchScore {
+    tier: number;
+    offset: number;
+    spread?: number;
+}
+export interface MatchOptions {
+    /** Omit or pass null to match exactly. `fuzzyPolicyForToken` picks a policy. */
+    fuzzy?: FuzzyPolicy | null;
+}
+/**
+ * How much a typo in one query token is forgiven. Short tokens get
+ * transpositions and nothing else: at four characters a free substitution turns
+ * "main" into "mail", "maid", and "rain", while a swap can only ever reach the
+ * word the user meant. Null means the token is matched exactly.
+ */
+export interface FuzzyPolicy {
+    maxEdits: number;
+    transpositionsOnly: boolean;
+}
+export declare function fuzzyPolicyForToken(token: string): FuzzyPolicy | null;
+export declare function scoreMatch(query: string, text: string, options?: MatchOptions): MatchScore | null;
+export interface MatchRange {
+    start: number;
+    length: number;
+}
+/**
+ * Where a score's match actually landed, so a caller can mark it. Derived from
+ * a score rather than produced alongside one: ranking touches every candidate
+ * and needs no ranges, while only the handful of rows that get rendered do.
+ *
+ * The tier decides the shape. A substring hit is one span; a subsequence hit is
+ * the scattered characters it walked; a typo hit marks the whole word, because
+ * the characters the user got wrong are not in the text to point at.
+ */
+export declare function matchRanges(query: string, text: string, score: MatchScore): MatchRange[];
+export declare function compareMatchScores(a: MatchScore, b: MatchScore): number;
+export declare function tokenizeQuery(query: string): string[];
+export interface TextFieldsOptions {
+    /**
+     * Forgive typos. The budget is per token rather than per query, because a
+     * query mixes long words that can absorb an edit with short ones that cannot.
+     */
+    typoTolerant?: boolean;
+}
+export declare function scoreTextFields(query: string, fields: string[], options?: TextFieldsOptions): MatchScore | null;
+//# sourceMappingURL=text-match.d.ts.map

package/dist/search/text-match.js

@@ -0,0 +1,262 @@
+/**
+ * Ranked text matching shared by the app's pickers and the daemon's history
+ * search. A match is a tier plus the offset it was found at; lower is better on
+ * both, so callers sort ascending and never have to invent a scale.
+ *
+ * Typo tolerance is opt-in via `fuzzy`. The pickers leave it off — a combobox
+ * over a known list wants exact narrowing — while history search turns it on
+ * because the user is recalling a title from memory.
+ */
+/** Exact tiers, best to worst. The fuzzy tier always sorts after all of them. */
+const TIER_EXACT = 0;
+const TIER_WHOLE_WORD = 1;
+const TIER_PREFIX = 2;
+const TIER_WORD_START = 3;
+const TIER_SUBSTRING = 4;
+const TIER_SUBSEQUENCE = 5;
+const TIER_FUZZY = 6;
+function isWordBoundaryChar(ch) {
+    if (ch === undefined)
+        return true;
+    return !/[a-z0-9]/.test(ch);
+}
+function scoreSubstringMatch(query, text) {
+    let best = null;
+    let pos = 0;
+    while (pos <= text.length - query.length) {
+        const found = text.indexOf(query, pos);
+        if (found === -1)
+            break;
+        const before = found > 0 ? text[found - 1] : undefined;
+        const after = text[found + query.length];
+        const startsAtBoundary = found === 0 || isWordBoundaryChar(before);
+        const endsAtBoundary = after === undefined || isWordBoundaryChar(after);
+        let tier;
+        if (startsAtBoundary && endsAtBoundary) {
+            tier = TIER_WHOLE_WORD;
+        }
+        else if (found === 0) {
+            tier = TIER_PREFIX;
+        }
+        else if (startsAtBoundary) {
+            tier = TIER_WORD_START;
+        }
+        else {
+            tier = TIER_SUBSTRING;
+        }
+        if (!best || tier < best.tier || (tier === best.tier && found < best.offset)) {
+            best = { tier, offset: found };
+        }
+        pos = found + 1;
+    }
+    return best;
+}
+function scoreSubsequenceMatch(query, text) {
+    let queryIndex = 0;
+    let firstIndex = -1;
+    let lastIndex = -1;
+    for (let textIndex = 0; textIndex < text.length && queryIndex < query.length; textIndex += 1) {
+        if (text[textIndex] !== query[queryIndex])
+            continue;
+        if (firstIndex === -1)
+            firstIndex = textIndex;
+        lastIndex = textIndex;
+        queryIndex += 1;
+    }
+    if (queryIndex !== query.length || firstIndex === -1)
+        return null;
+    return { tier: TIER_SUBSEQUENCE, offset: firstIndex, spread: lastIndex - firstIndex + 1 };
+}
+/**
+ * Damerau-Levenshtein distance, abandoned as soon as every cell in a row is
+ * over budget. Bounding it is what keeps the fuzzy tier affordable to run
+ * against every word of every candidate.
+ */
+function boundedEditDistance(query, word, budget) {
+    if (Math.abs(query.length - word.length) > budget)
+        return null;
+    let twoRowsBack = [];
+    let previousRow = Array.from({ length: word.length + 1 }, (_, index) => index);
+    for (let queryIndex = 1; queryIndex <= query.length; queryIndex += 1) {
+        const currentRow = [queryIndex];
+        let rowBest = queryIndex;
+        for (let wordIndex = 1; wordIndex <= word.length; wordIndex += 1) {
+            const substitutionCost = query[queryIndex - 1] === word[wordIndex - 1] ? 0 : 1;
+            let cost = Math.min(currentRow[wordIndex - 1] + 1, previousRow[wordIndex] + 1, previousRow[wordIndex - 1] + substitutionCost);
+            const isTransposition = queryIndex > 1 &&
+                wordIndex > 1 &&
+                query[queryIndex - 1] === word[wordIndex - 2] &&
+                query[queryIndex - 2] === word[wordIndex - 1];
+            if (isTransposition) {
+                cost = Math.min(cost, twoRowsBack[wordIndex - 2] + 1);
+            }
+            currentRow.push(cost);
+            rowBest = Math.min(rowBest, cost);
+        }
+        if (rowBest > budget)
+            return null;
+        twoRowsBack = previousRow;
+        previousRow = currentRow;
+    }
+    const distance = previousRow[word.length];
+    return distance <= budget ? distance : null;
+}
+function transpositionDistance(query, word) {
+    return isAdjacentTransposition(query, word) ? 1 : null;
+}
+/** True when the two differ only by one swap of neighbouring characters. */
+function isAdjacentTransposition(query, word) {
+    if (query.length !== word.length)
+        return false;
+    let index = 0;
+    while (index < query.length && query[index] === word[index])
+        index += 1;
+    if (index >= query.length - 1)
+        return false;
+    if (query[index] !== word[index + 1] || query[index + 1] !== word[index])
+        return false;
+    return query.slice(index + 2) === word.slice(index + 2);
+}
+export function fuzzyPolicyForToken(token) {
+    if (token.length <= 3)
+        return null;
+    if (token.length === 4)
+        return { maxEdits: 1, transpositionsOnly: true };
+    if (token.length <= 7)
+        return { maxEdits: 1, transpositionsOnly: false };
+    return { maxEdits: 2, transpositionsOnly: false };
+}
+/**
+ * Words are what people mistype, so the fuzzy tier compares the query against
+ * each word rather than against the whole string — otherwise a long title's
+ * length difference alone would blow the budget.
+ */
+function scoreFuzzyMatch(query, text, policy) {
+    if (policy.maxEdits <= 0 || query.length <= policy.maxEdits)
+        return null;
+    let best = null;
+    const wordPattern = /[a-z0-9]+/g;
+    let word = wordPattern.exec(text);
+    while (word !== null) {
+        // Compare against the whole word and against its leading slices, so a typo
+        // in a prefix ("confug" for "configuration") still lands — the length gap
+        // to the full word would otherwise blow the budget on its own.
+        const candidates = new Set([
+            word[0],
+            word[0].slice(0, query.length),
+            word[0].slice(0, query.length + policy.maxEdits),
+        ]);
+        for (const candidate of candidates) {
+            const distance = policy.transpositionsOnly
+                ? transpositionDistance(query, candidate)
+                : boundedEditDistance(query, candidate, policy.maxEdits);
+            if (distance === null)
+                continue;
+            const score = { tier: TIER_FUZZY, offset: word.index, spread: distance };
+            if (!best || compareMatchScores(score, best) < 0) {
+                best = score;
+            }
+        }
+        word = wordPattern.exec(text);
+    }
+    return best;
+}
+export function scoreMatch(query, text, options = {}) {
+    if (!query)
+        return { tier: TIER_EXACT, offset: 0 };
+    const q = query.toLowerCase();
+    const t = text.toLowerCase();
+    if (t === q)
+        return { tier: TIER_EXACT, offset: 0 };
+    const exact = scoreSubstringMatch(q, t) ?? scoreSubsequenceMatch(q, t);
+    if (exact)
+        return exact;
+    const fuzzy = options.fuzzy;
+    return fuzzy ? scoreFuzzyMatch(q, t, fuzzy) : null;
+}
+function mergeAdjacentRanges(indices) {
+    const ranges = [];
+    for (const index of indices) {
+        const last = ranges.at(-1);
+        if (last && last.start + last.length === index) {
+            last.length += 1;
+            continue;
+        }
+        ranges.push({ start: index, length: 1 });
+    }
+    return ranges;
+}
+function wordRangeAt(text, offset) {
+    let end = offset;
+    while (end < text.length && /[a-z0-9]/.test(text[end]))
+        end += 1;
+    return { start: offset, length: Math.max(end - offset, 1) };
+}
+/**
+ * Where a score's match actually landed, so a caller can mark it. Derived from
+ * a score rather than produced alongside one: ranking touches every candidate
+ * and needs no ranges, while only the handful of rows that get rendered do.
+ *
+ * The tier decides the shape. A substring hit is one span; a subsequence hit is
+ * the scattered characters it walked; a typo hit marks the whole word, because
+ * the characters the user got wrong are not in the text to point at.
+ */
+export function matchRanges(query, text, score) {
+    if (!query)
+        return [];
+    const q = query.toLowerCase();
+    const t = text.toLowerCase();
+    if (score.tier === TIER_EXACT)
+        return [{ start: 0, length: text.length }];
+    if (score.tier === TIER_FUZZY)
+        return [wordRangeAt(t, score.offset)];
+    if (score.tier === TIER_SUBSEQUENCE) {
+        const indices = [];
+        let queryIndex = 0;
+        for (let textIndex = 0; textIndex < t.length && queryIndex < q.length; textIndex += 1) {
+            if (t[textIndex] !== q[queryIndex])
+                continue;
+            indices.push(textIndex);
+            queryIndex += 1;
+        }
+        return mergeAdjacentRanges(indices);
+    }
+    return [{ start: score.offset, length: q.length }];
+}
+export function compareMatchScores(a, b) {
+    if (a.tier !== b.tier)
+        return a.tier - b.tier;
+    if (a.offset !== b.offset)
+        return a.offset - b.offset;
+    return (a.spread ?? 0) - (b.spread ?? 0);
+}
+export function tokenizeQuery(query) {
+    return query
+        .trim()
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((token) => token.length > 0);
+}
+export function scoreTextFields(query, fields, options = {}) {
+    const tokens = tokenizeQuery(query);
+    if (tokens.length === 0)
+        return { tier: TIER_EXACT, offset: 0, spread: 0 };
+    const aggregate = { tier: TIER_EXACT, offset: 0, spread: 0 };
+    for (const token of tokens) {
+        const fuzzy = options.typoTolerant ? fuzzyPolicyForToken(token) : null;
+        let best = null;
+        for (const field of fields) {
+            const score = scoreMatch(token, field, { fuzzy });
+            if (score && (!best || compareMatchScores(score, best) < 0)) {
+                best = score;
+            }
+        }
+        if (!best)
+            return null;
+        aggregate.tier += best.tier;
+        aggregate.offset += best.offset;
+        aggregate.spread = (aggregate.spread ?? 0) + (best.spread ?? token.length);
+    }
+    return aggregate;
+}
+//# sourceMappingURL=text-match.js.map