@agent-native/core 0.184.0 → 0.184.1-nightly-20260922203115

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 9718
+- template files: 9727

package/corpus/templates/analytics/changelog/2026-09-22-apps-start-with-an-app-shaped-skeleton-while-session-data-lo.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-09-22
+---
+
+Apps start with an app-shaped skeleton while session data loads immediately.

package/corpus/templates/calendar/changelog/2026-09-22-apps-start-with-an-app-shaped-skeleton-while-session-data-lo.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-09-22
+---
+
+Apps start with an app-shaped skeleton while session data loads immediately.

package/corpus/templates/clips/changelog/2026-09-22-apps-start-with-an-app-shaped-skeleton-while-session-data-lo.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-09-22
+---
+
+Apps start with an app-shaped skeleton while session data loads immediately.

package/corpus/templates/content/AGENTS.md

@@ -63,7 +63,7 @@ Read the relevant skill before deeper work:
 | `navigate` | Move the UI to a document, comments, media, or settings |
 | `refresh-list` | Repaint the sidebar after an out-of-band mutation |
 | `list-documents` | Document metadata tree, without bodies |
-| `search-documents` | Title and content search with snippets |
+| `search-documents` | Title-first search with snippets |
 | `get-document` | One document with full content |
 | `pull-document` | Flush live collab state, then read (external edits) |
 | `get-blocks-field-word-count` | Count one exact Blocks field; omit `propertyId` for the primary Content body |

package/corpus/templates/content/actions/_document-search-ranking.ts

@@ -0,0 +1,191 @@
+import { and, or, sql, type SQL, type SQLWrapper } from "drizzle-orm";
+
+import type {
+  ParsedSearchQuery,
+  SearchQueryGroup,
+  SearchQueryTerm,
+} from "../shared/search-query.js";
+
+function escapeLike(value: string) {
+  return value.replace(/([\\%_])/g, "\\$1");
+}
+
+function substringMatch(column: SQLWrapper, term: SearchQueryTerm): SQL {
+  return sql`${column} ILIKE ${`%${escapeLike(term.text)}%`} ESCAPE '\\'`;
+}
+
+function escapeRegex(value: string) {
+  return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+
+function regexTerm(value: string) {
+  return escapeRegex(value.trim()).replace(/\s+/g, "[[:space:]]+");
+}
+
+export function searchQueryProximityPattern(parsed: ParsedSearchQuery) {
+  if (
+    parsed.groups.length < 2 ||
+    parsed.groups.some(
+      (group) => group.terms.length !== 1 || group.terms[0]!.titleOnly,
+    )
+  ) {
+    return null;
+  }
+  return parsed.groups
+    .map((group) => regexTerm(group.terms[0]!.text))
+    .join("(.|\\n){0,240}");
+}
+
+function wordPrefixMatch(column: SQLWrapper, term: SearchQueryTerm): SQL {
+  const pattern = regexTerm(term.text);
+  return sql`${column} ~* ${`(^|[^[:alnum:]_])${pattern}`}`;
+}
+
+function groupSubstringMatch(column: SQLWrapper, group: SearchQueryGroup): SQL {
+  return or(...group.terms.map((term) => substringMatch(column, term)))!;
+}
+
+function nonTitleGroupSubstringMatch(
+  column: SQLWrapper,
+  group: SearchQueryGroup,
+): SQL {
+  const terms = group.terms.filter((term) => !term.titleOnly);
+  return terms.length
+    ? or(...terms.map((term) => substringMatch(column, term)))!
+    : sql`false`;
+}
+
+function groupWordPrefixMatch(
+  column: SQLWrapper,
+  group: SearchQueryGroup,
+): SQL {
+  return or(...group.terms.map((term) => wordPrefixMatch(column, term)))!;
+}
+
+function countMatchingGroups(
+  column: SQLWrapper,
+  groups: SearchQueryGroup[],
+  nonTitleOnly = false,
+): SQL<number> {
+  if (!groups.length) return sql<number>`0`;
+  return sql<number>`(${sql.join(
+    groups.map(
+      (group) =>
+        sql`case when ${nonTitleOnly ? nonTitleGroupSubstringMatch(column, group) : groupSubstringMatch(column, group)} then 1 else 0 end`,
+    ),
+    sql` + `,
+  )})`;
+}
+
+export interface DocumentSearchRankingColumns {
+  title: SQLWrapper;
+  description: SQLWrapper;
+  content: SQLWrapper;
+}
+
+export interface DocumentSearchRankingOptions {
+  includeNonTitleFields?: boolean;
+}
+
+function bodyProximityScore(
+  parsed: ParsedSearchQuery,
+  content: SQLWrapper,
+): SQL<number> {
+  if (
+    parsed.groups.length < 2 ||
+    parsed.groups.some(
+      (group) => group.terms.length !== 1 || group.terms[0]!.titleOnly,
+    )
+  ) {
+    return sql<number>`case when true then 0 else 0 end`;
+  }
+  const phrase = parsed.groups
+    .map((group) => group.terms[0]!.text.trim())
+    .join(" ");
+  return sql<number>`case when ${content} ILIKE ${`%${escapeLike(phrase)}%`} ESCAPE '\\' then 1 else 0 end`;
+}
+
+/**
+ * Returns lexicographic ranking keys. The first key is a protected match tier:
+ * no recency or repetition signal can move a body match above a title match.
+ */
+export function documentSearchRanking(
+  parsed: ParsedSearchQuery,
+  columns: DocumentSearchRankingColumns,
+  options: DocumentSearchRankingOptions = {},
+) {
+  const groups = parsed.groups;
+  const includeNonTitleFields = options.includeNonTitleFields ?? true;
+  const normalizedTitle = sql<string>`regexp_replace(lower(trim(coalesce(${columns.title}, ''))), '\\s+', ' ', 'g')`;
+  const simpleQueries =
+    groups.length > 0 && groups.every((group) => group.terms.length === 1)
+      ? [groups.map((group) => group.terms[0]!.text.trim()).join(" ")]
+      : groups.length === 1
+        ? groups[0]!.terms.map((term) => term.text.trim())
+        : [];
+  const normalizedSimpleQueries = simpleQueries.map((query) =>
+    query.toLocaleLowerCase().replace(/\s+/g, " "),
+  );
+  const guardNormalizedTitle = groups.every((group) =>
+    group.terms.every((term) => !/\s/.test(term.text)),
+  );
+  const allTitleSubstrings = groups.length
+    ? and(...groups.map((group) => groupSubstringMatch(columns.title, group)))!
+    : sql`false`;
+  const allTitleWordPrefixes = groups.length
+    ? and(...groups.map((group) => groupWordPrefixMatch(columns.title, group)))!
+    : sql`false`;
+  const allTitleOrDescription = groups.length
+    ? and(
+        ...groups.map((group) =>
+          includeNonTitleFields
+            ? or(
+                groupSubstringMatch(columns.title, group),
+                nonTitleGroupSubstringMatch(columns.description, group),
+              )!
+            : groupSubstringMatch(columns.title, group),
+        ),
+      )!
+    : sql`false`;
+  const matchTier = sql<number>`case
+    when ${
+      normalizedSimpleQueries.length
+        ? and(
+            guardNormalizedTitle ? allTitleSubstrings : sql`true`,
+            or(
+              ...normalizedSimpleQueries.map(
+                (query) => sql`${normalizedTitle} = ${query}`,
+              ),
+            )!,
+          )!
+        : sql`false`
+    } then 5
+    when ${
+      normalizedSimpleQueries.length
+        ? and(
+            guardNormalizedTitle ? allTitleSubstrings : sql`true`,
+            or(
+              ...normalizedSimpleQueries.map(
+                (query) =>
+                  sql`${normalizedTitle} like ${`${escapeLike(query)}%`} escape '\\'`,
+              ),
+            )!,
+          )!
+        : sql`false`
+    } then 4
+    when ${allTitleSubstrings} and ${allTitleWordPrefixes} then 3
+    when ${allTitleSubstrings} then 2
+    when ${allTitleOrDescription} then 1
+    else 0
+  end`;
+  return {
+    matchTier,
+    titleCoverage: countMatchingGroups(columns.title, groups),
+    descriptionCoverage: includeNonTitleFields
+      ? countMatchingGroups(columns.description, groups, true)
+      : sql<number>`0::integer`,
+    bodyProximity: includeNonTitleFields
+      ? bodyProximityScore(parsed, columns.content)
+      : sql<number>`0::integer`,
+  };
+}

package/corpus/templates/content/actions/search-documents.ts

@@ -32,6 +32,10 @@ import {
   documentDiscoveryPagination,
   documentDiscoveryWhere,
 } from "./_document-discovery-query.js";
+import {
+  documentSearchRanking,
+  searchQueryProximityPattern,
+} from "./_document-search-ranking.js";
 
 function escapeLike(s: string): string {
   return s.replace(/([\\%_])/g, "\\$1");
@@ -45,15 +49,21 @@ function escapeLike(s: string): string {
 // no-match case. The row is still returned either way.
 function makeSnippet(content: string, query: string, radius = 120) {
   const compact = content.replace(/\s+/g, " ").trim();
+  const compactQuery = query.replace(/\s+/g, " ").trim();
   if (!compact) return "";
-  const index = compact.toLowerCase().indexOf(query.toLowerCase());
+  if (!compactQuery) {
+    return compact.length <= radius * 2
+      ? compact
+      : `${compact.slice(0, radius * 2).trimEnd()}...`;
+  }
+  const index = compact.toLowerCase().indexOf(compactQuery.toLowerCase());
   if (index < 0) {
     return compact.length <= radius * 2
       ? compact
       : `${compact.slice(0, radius * 2).trimEnd()}...`;
   }
   const start = Math.max(0, index - radius);
-  const end = Math.min(compact.length, index + query.length + radius);
+  const end = Math.min(compact.length, index + compactQuery.length + radius);
   return `${start > 0 ? "..." : ""}${compact.slice(start, end).trim()}${
     end < compact.length ? "..." : ""
   }`;
@@ -61,7 +71,7 @@ function makeSnippet(content: string, query: string, radius = 120) {
 
 export default defineAction({
   description:
-    'Search one bounded page of access-scoped documents by title and content, or find an exact title within a parent, space, and document type. The query supports Google-style operators: "exact phrase", -excludedTerm, OR between terms (uppercase), intitle:term; bare words combine with AND and %, _ match literally. Returns explicit pagination; follow nextOffset until hasMore is false. Returns metadata and snippets; use get-document for full content.',
+    'Search one relevance-ranked, bounded page of access-scoped documents by title and content, or find an exact title within a parent, space, and document type. Exact and partial title matches rank above description and body matches. The query supports Google-style operators: "exact phrase", -excludedTerm, OR between terms (uppercase), intitle:term; bare words combine with AND and %, _ match literally. Returns explicit pagination; follow nextOffset until hasMore is false. Returns metadata and snippets; use get-document for full content.',
   deferLoading: false,
   mcpTool: true,
   schema: z
@@ -131,6 +141,7 @@ export default defineAction({
       ]),
     ];
     let bodyNeedles: string[] = [];
+    let parsedQuery: ReturnType<typeof parseSearchQuery> | null = null;
     const queryTermPredicate = (term: SearchQueryTerm): SQL => {
       const pattern = `%${escapeLike(term.text)}%`;
       const columns =
@@ -148,6 +159,7 @@ export default defineAction({
     const matchPredicates: SQL[] = [];
     if (args.query) {
       const parsed = parseSearchQuery(args.query);
+      parsedQuery = parsed;
       if (parsed.empty) {
         // Punctuation-only input (lone `-`, empty quotes) matches nothing by
         // design; report that as a loud empty page rather than every document.
@@ -169,7 +181,7 @@ export default defineAction({
                 .map((term) => term.text),
             ),
           ),
-        ];
+        ].slice(0, 256);
       }
     }
     const where = documentDiscoveryWhere({
@@ -204,39 +216,110 @@ export default defineAction({
           : undefined,
       ),
     });
-    const [countRow] = await db
-      .select({ count: sql<number>`count(*)` })
-      .from(schema.documents)
-      .where(where);
-    const totalItems = Number(countRow?.count ?? 0);
-
     // Project a bounded preview of `content` instead of the full column:
     // document bodies can be multi-MB, and this action only returns a short
     // snippet (use get-document for full content). In free-text mode the
-    // preview window is anchored at the earliest in-body occurrence of an
-    // eligible positive term. The selected term is projected with the window
-    // so `makeSnippet` centers on the same match. Query order breaks ties;
+    // preview window is anchored at an in-body occurrence that keeps the most
+    // eligible positive terms in view. The selected term is projected with the
+    // window so `makeSnippet` preserves the complete match. Position and query
+    // order break ties;
     // title-only matches and exactTitle mode keep the head projection. The
     // true length still comes from SQL `length()` rather than reading `.length`
     // off a truncated string. Mirrors the
     // `substr`/`length` projection style in list-documents.ts; `position`,
     // `substr`, and `length` all work in PostgreSQL and PGlite.
     const normalizedContent = sql<string>`coalesce(${schema.documents.content}, '')`;
-    const selectedBodyNeedle = bodyNeedles.length
-      ? sql<string>`(
-          select candidate.needle
-          from unnest(array[${sql.join(
-            bodyNeedles.map((needle) => sql`${needle}`),
-            sql`, `,
-          )}]::text[]) with ordinality as candidate(needle, query_order)
-          where position(lower(candidate.needle) in lower(${normalizedContent})) > 0
-          order by position(lower(candidate.needle) in lower(${normalizedContent})), candidate.query_order
+    const bodyNeedleArray = bodyNeedles.length
+      ? sql`array[${sql.join(
+          bodyNeedles.map((needle) => sql`${needle}`),
+          sql`, `,
+        )}]::text[]`
+      : undefined;
+    const maxOccurrencesPerNeedle = Math.max(
+      1,
+      Math.floor(256 / Math.max(1, bodyNeedles.length)),
+    );
+    const proximityPattern =
+      bodyNeedleArray && parsedQuery
+        ? searchQueryProximityPattern(parsedQuery)
+        : null;
+    const proximityPosition = proximityPattern
+      ? sql<number>`regexp_instr(${normalizedContent}, ${proximityPattern}, 1, 1, 0, 'i')`
+      : undefined;
+    // Inspect repeated occurrences so the snippet can prefer a later,
+    // denser passage. Cap each needle to keep pathological repeated-token
+    // documents from turning one result preview into an unbounded scan.
+    const fallbackBodyPosition =
+      bodyNeedles.length === 1
+        ? sql<number>`nullif(position(lower(${bodyNeedles[0]!}) in lower(${normalizedContent})), 0)`
+        : bodyNeedleArray
+          ? sql<number>`(
+          with recursive body_occurrence(needle, query_order, match_position, occurrence_number) as (
+            select candidate.needle, candidate.query_order,
+              position(lower(candidate.needle) in lower(${normalizedContent})), 1
+            from unnest(${bodyNeedleArray}) with ordinality as candidate(needle, query_order)
+            where position(lower(candidate.needle) in lower(${normalizedContent})) > 0
+            union all
+            select occurrence.needle, occurrence.query_order,
+              occurrence.match_position + position(
+                lower(occurrence.needle)
+                in substring(lower(${normalizedContent}) from occurrence.match_position + 1)
+              ), occurrence.occurrence_number + 1
+            from body_occurrence as occurrence
+            where occurrence.occurrence_number < ${maxOccurrencesPerNeedle} and position(
+              lower(occurrence.needle)
+              in substring(lower(${normalizedContent}) from occurrence.match_position + 1)
+            ) > 0
+          )
+          select candidate.match_position
+          from body_occurrence as candidate
+          order by (
+            select count(*)
+            from unnest(${bodyNeedleArray}) as nearby(needle)
+            where position(
+              lower(nearby.needle)
+              in lower(substr(
+                ${normalizedContent},
+                greatest(1, candidate.match_position - 120),
+                240 + length(candidate.needle)
+              ))
+            ) > 0
+          ) desc,
+          candidate.match_position,
+          candidate.query_order
           limit 1
         )`
-      : undefined;
-    const matchWindow = selectedBodyNeedle
-      ? sql<string>`case when ${selectedBodyNeedle} is not null then substr(${normalizedContent}, greatest(1, position(lower(${selectedBodyNeedle}) in lower(${normalizedContent})) - 120), 240 + length(${selectedBodyNeedle})) else substr(${normalizedContent}, 1, 5000) end`
+          : undefined;
+    const selectedBodyPosition =
+      proximityPosition && fallbackBodyPosition
+        ? sql<number>`coalesce(nullif(${proximityPosition}, 0), ${fallbackBodyPosition})`
+        : fallbackBodyPosition;
+    const selectedBodyNeedle =
+      bodyNeedleArray && selectedBodyPosition
+        ? sql<string>`(
+            select candidate.needle
+            from unnest(${bodyNeedleArray}) with ordinality as candidate(needle, query_order)
+            where lower(substr(${normalizedContent}, ${selectedBodyPosition}, length(candidate.needle))) = lower(candidate.needle)
+            order by candidate.query_order
+            limit 1
+          )`
+        : undefined;
+    const matchWindow = selectedBodyPosition
+      ? sql<string>`case when ${selectedBodyPosition} is not null then substr(${normalizedContent}, greatest(1, ${selectedBodyPosition} - 120), least(5000, 240 + coalesce(length(${selectedBodyNeedle}), 0))) else substr(${normalizedContent}, 1, 5000) end`
       : sql<string>`substr(${normalizedContent}, 1, 5000)`;
+    const ranking = parsedQuery?.groups.length
+      ? documentSearchRanking(
+          parsedQuery,
+          {
+            title: schema.documents.title,
+            description: schema.documents.description,
+            content: normalizedContent,
+          },
+          {
+            includeNonTitleFields: args.searchFields !== "title",
+          },
+        )
+      : null;
     const docs = await db
       .select({
         id: schema.documents.id,
@@ -244,11 +327,6 @@ export default defineAction({
         title: schema.documents.title,
         description: schema.documents.description,
         icon: schema.documents.icon,
-        contentPreview: matchWindow,
-        snippetNeedle: selectedBodyNeedle
-          ? sql<string>`coalesce(${selectedBodyNeedle}, '')`
-          : sql<string>`''`,
-        contentLength: sql<number>`length(${normalizedContent})`,
         hideFromSearch: schema.documents.hideFromSearch,
         updatedAt: schema.documents.updatedAt,
         sourceKind: schema.documents.sourceKind,
@@ -264,12 +342,63 @@ export default defineAction({
               ),
             ),
         )} then 'database' else 'page' end`,
+        totalItems: sql<number>`count(*) over()`,
       })
       .from(schema.documents)
       .where(where)
-      .orderBy(desc(schema.documents.updatedAt), asc(schema.documents.id))
+      .orderBy(
+        ...(ranking
+          ? [
+              desc(ranking.matchTier),
+              desc(ranking.titleCoverage),
+              desc(ranking.descriptionCoverage),
+              // Phrase coherence is a minor body-only tie-breaker. Bound its
+              // full-body scan so broad searches keep predictable latency;
+              // protected field tiers still rank the complete result set.
+              desc(
+                sql<number>`case when count(*) over() <= 1000 then ${ranking.bodyProximity} else 0 end`,
+              ),
+            ]
+          : []),
+        desc(schema.documents.updatedAt),
+        asc(schema.documents.id),
+      )
       .limit(args.limit)
       .offset(args.offset);
+    const previews = docs.length
+      ? await db
+          .select({
+            id: schema.documents.id,
+            contentPreview: matchWindow,
+            snippetNeedle: selectedBodyNeedle
+              ? sql<string>`coalesce(${selectedBodyNeedle}, '')`
+              : sql<string>`''`,
+            contentLength: sql<number>`length(${normalizedContent})`,
+          })
+          .from(schema.documents)
+          .where(
+            and(
+              where,
+              inArray(
+                schema.documents.id,
+                docs.map((doc) => doc.id),
+              ),
+            ),
+          )
+      : [];
+    const previewById = new Map(
+      previews.map((preview) => [preview.id, preview]),
+    );
+    const totalItems = docs.length
+      ? Number(docs[0]!.totalItems)
+      : Number(
+          (
+            await db
+              .select({ count: sql<number>`count(*)` })
+              .from(schema.documents)
+              .where(where)
+          )[0]?.count ?? 0,
+        );
 
     const parentIds = [
       ...new Set(docs.flatMap((doc) => (doc.parentId ? [doc.parentId] : []))),
@@ -290,24 +419,30 @@ export default defineAction({
     const parentById = new Map(parents.map((parent) => [parent.id, parent]));
 
     return {
-      documents: docs.map((doc) => ({
-        id: doc.id,
-        parentId:
-          doc.parentId && parentById.has(doc.parentId) ? doc.parentId : null,
-        parentTitle: doc.parentId
-          ? (parentById.get(doc.parentId)?.title ?? null)
-          : null,
-        documentType: doc.documentType,
-        sourceKind: doc.sourceKind,
-        sourceUpdatedAt: doc.sourceUpdatedAt,
-        title: doc.title,
-        description: doc.description,
-        icon: doc.icon,
-        snippet: makeSnippet(doc.contentPreview, doc.snippetNeedle),
-        contentLength: Number(doc.contentLength) || 0,
-        hideFromSearch: parseDocumentHideFromSearch(doc.hideFromSearch),
-        updatedAt: doc.updatedAt,
-      })),
+      documents: docs.map((doc) => {
+        const preview = previewById.get(doc.id);
+        return {
+          id: doc.id,
+          parentId:
+            doc.parentId && parentById.has(doc.parentId) ? doc.parentId : null,
+          parentTitle: doc.parentId
+            ? (parentById.get(doc.parentId)?.title ?? null)
+            : null,
+          documentType: doc.documentType,
+          sourceKind: doc.sourceKind,
+          sourceUpdatedAt: doc.sourceUpdatedAt,
+          title: doc.title,
+          description: doc.description,
+          icon: doc.icon,
+          snippet: makeSnippet(
+            preview?.contentPreview ?? "",
+            preview?.snippetNeedle ?? "",
+          ),
+          contentLength: Number(preview?.contentLength) || 0,
+          hideFromSearch: parseDocumentHideFromSearch(doc.hideFromSearch),
+          updatedAt: doc.updatedAt,
+        };
+      }),
       pagination: documentDiscoveryPagination({
         offset: args.offset,
         limit: args.limit,

package/corpus/templates/content/changelog/2026-09-21-search-ranks-title-matches-first.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-09-21
+---
+
+Search now ranks exact and partial title matches above incidental matches in document bodies.

package/corpus/templates/content/docs/product/capabilities/content.knowledge.search.md

@@ -59,7 +59,7 @@ Given a stale connected Source result, when it appears, then its freshness state
 
 ## Current evidence
 
-Existing search paths are in progress donor substrate, but complete indexed, freshness, ranking, and agent-parity proof is incomplete. This Capability remains `in_progress`.
+Existing search paths are in progress donor substrate, but complete indexed, freshness, and agent-parity proof is incomplete. This Capability remains `in_progress`.
 
 The command picker uses the shared paginated search Action, with title-only,
 document-type and modified-date predicates applied before pagination. Parent
@@ -67,13 +67,16 @@ context is independently access-scoped. The query supports a bounded
 Google-style operator set: quoted "exact phrases", `-excludedTerm`,
 uppercase `OR` between terms, `intitle:term`, and implicit AND across bare
 words; `%`, `_`, and `*` stay literal, and an all-workspaces scope option
-omits the space filter while keeping server-side access scoping. Snippet
-windows anchor at the first in-body occurrence of the first match needle,
-so deep-body matches show their own context. Focused
-tests cover later pages, private-parent suppression, hidden-result counts,
-type filters, and each operator. This is bounded lexical search substrate,
-not proof of indexed retrieval across every Source, authoritative author
-filtering, ranking, or policy-governed global search.
+omits the space filter while keeping server-side access scoping. Search ranks
+the complete authorized match set before pagination. Exact and contiguous
+partial titles form protected tiers above title-word, description, and body
+matches; modification time only breaks otherwise equal results. Snippet windows
+prefer context containing more positive terms. Focused tests cover later pages,
+private-parent suppression, hidden-result counts, title tiers, useful snippets,
+type filters, and each operator. A 10,000-document PGlite benchmark covers the
+current warm-query budget. This is bounded lexical search substrate, not proof
+of indexed retrieval across every Source, authoritative author filtering,
+freshness ranking, or policy-governed global search.
 
 Local browser verification of the command picker covered 27 authorized matches
 across two result pages, equal-title parent context, keyboard opening, title/body

package/corpus/templates/design/.generated/bridge/editor-chrome.generated.ts

@@ -2539,6 +2539,13 @@ export const editorChromeBridgeScript: string = `"use strict";
       }
       return containerScopeAncestor(resolved, scope);
     }
+    function plainClickSelectionTarget(hit) {
+      if (!designCanvasBoardSurface) {
+        selectionContainerScope = null;
+        return selectionTargetForHit(hit);
+      }
+      return containerFirstSelectionTarget(hit);
+    }
     function clickThroughSelectionTarget(hit, ev) {
       if (ev.detail > 1) return null;
       if (!selectedEl || !document.documentElement.contains(selectedEl)) {
@@ -8247,7 +8254,7 @@ export const editorChromeBridgeScript: string = `"use strict";
         return;
       }
       hoveredSpacingHandleKey = "";
-      var resolvedClickTarget = e.metaKey || e.ctrlKey ? selectionTargetForHit(target) : containerFirstSelectionTarget(target);
+      var resolvedClickTarget = e.metaKey || e.ctrlKey ? selectionTargetForHit(target) : plainClickSelectionTarget(target);
       var toggled = resolveShiftClickToggleOff(resolvedClickTarget, e);
       if (toggled !== void 0) {
         postToggledSelection(toggled);
@@ -16258,7 +16265,7 @@ export const editorChromeBridgeScript: string = `"use strict";
         }
         if (ev) stopNativeInteraction(ev);
         var cycledEl = !readOnly && (e.metaKey || e.ctrlKey) && !e.shiftKey ? stackCycleTarget(e.clientX, e.clientY, selectedEl) : null;
-        var primaryClickTarget = !readOnly && (e.metaKey || e.ctrlKey) ? selectionTargetForHit(hit) : (!readOnly && !e.shiftKey ? clickThroughSelectionTarget(hit, ev) : null) || containerFirstSelectionTarget(hit);
+        var primaryClickTarget = !readOnly && (e.metaKey || e.ctrlKey) ? selectionTargetForHit(hit) : !designCanvasBoardSurface ? plainClickSelectionTarget(hit) : (!readOnly && !e.shiftKey ? clickThroughSelectionTarget(hit, ev) : null) || containerFirstSelectionTarget(hit);
         if (cycledEl) {
           selectTarget(cycledEl, ev, true);
         } else {
@@ -17205,7 +17212,7 @@ export const editorChromeBridgeScript: string = `"use strict";
     var lastHoverClientPoint = null;
     function resolveHoverTarget(clientX, clientY, deepSelect) {
       var rawHit = elementFromEditorPoint(clientX, clientY);
-      return deepSelect ? selectionTargetForHit(rawHit) : containerFirstSelectionTarget(rawHit);
+      return deepSelect || !designCanvasBoardSurface ? selectionTargetForHit(rawHit) : containerFirstSelectionTarget(rawHit);
     }
     function reresolveHoverAtLastPoint(deepSelect) {
       if (!lastHoverClientPoint) return;

package/corpus/templates/design/.generated/bridge/nav.generated.ts

@@ -28,6 +28,7 @@ export const navBridgeScript: string = `"use strict";
         if (!t || !t.closest) return;
         var a = t.closest("a[href], [data-screen]");
         if (!a) return;
+        if (e.metaKey || e.ctrlKey || e.shiftKey || e.button !== 0) return;
         var ds = a.getAttribute && a.getAttribute("data-screen");
         if (!ds) {
           var rawHref = a.getAttribute("href");