@k2b/cloud 0.6.0 → 0.8.0

package/src/browser/app-approval-vault.ts

@@ -28,11 +28,13 @@ const pinSchema = z
 const passkeySchema = z
   .object({ type: z.literal("passkey"), credentialId: z.string().min(1).max(2048), salt: base64(32), wrapped: blobSchema })
   .strict();
-const methodSchema = z.discriminatedUnion("type", [pinSchema, passkeySchema]);
+const localSchema = z.object({ type: z.literal("local"), key: base64(32) }).strict();
+const methodSchema = z.discriminatedUnion("type", [pinSchema, passkeySchema, localSchema]);
 const configSchema = z
   .object({ version: z.literal(1), id: base64(16), methods: z.array(methodSchema).min(1).max(2) })
   .strict()
-  .refine((c) => new Set(c.methods.map((m) => m.type)).size === c.methods.length);
+  .refine((c) => new Set(c.methods.map((m) => m.type)).size === c.methods.length)
+  .refine((c) => !c.methods.some((m) => m.type === "local") || c.methods.length === 1);
 export type AppVaultConfig = z.infer<typeof configSchema>;
 export type AppVaultBlob = z.infer<typeof blobSchema>;
 export type AppVaultMethod = AppVaultConfig["methods"][number];
@@ -89,7 +91,7 @@ async function pinKey(pin: string, salt: string) {
 function wrapContext(id: string, method: Omit<z.infer<typeof pinSchema>, "wrapped"> | Omit<z.infer<typeof passkeySchema>, "wrapped">) {
   return JSON.stringify(["cloud-login-vault", 1, id, method.type, method.salt, method.type === "pin" ? method.kdf : method.credentialId]);
 }
-function methodContext(id: string, method: AppVaultMethod) {
+function methodContext(id: string, method: Exclude<AppVaultMethod, { type: "local" }>) {
   return wrapContext(
     id,
     method.type === "pin"
@@ -238,6 +240,11 @@ function session(id: string, raw: Uint8Array<ArrayBuffer>, key: CryptoKey) {
         plain.fill(0);
       }
     },
+    /** Persists the vault key without PIN protection. Never combine with protected methods. */
+    local(): AppVaultMethod {
+      check();
+      return { type: "local", key: encode(raw) };
+    },
     async pin(pin: string): Promise<AppVaultMethod> {
       check();
       const method = { type: "pin" as const, salt: encode(bytes(16)), kdf: "argon2id-64m-t3-p1" as const };
@@ -281,13 +288,18 @@ async function create() {
   const raw = bytes(32);
   return session(encode(bytes(16)), raw, await aes(raw));
 }
-async function unlock(config: AppVaultConfig, type: "pin" | "passkey", pin?: string, signal?: AbortSignal) {
+async function unlock(config: AppVaultConfig, type: AppVaultMethod["type"], pin?: string, signal?: AbortSignal) {
   const value = configSchema.parse(config);
   const method = value.methods.find((m) => m.type === type);
   if (!method) throw invalid();
-  const wrapping =
-    method.type === "pin" ? await pinKey(pin ?? "", method.salt) : await passkeyKey(method.credentialId, method.salt, signal);
-  const raw = await decrypt(wrapping, method.wrapped, methodContext(value.id, method));
+  const raw =
+    method.type === "local"
+      ? decode(method.key)
+      : await decrypt(
+          method.type === "pin" ? await pinKey(pin ?? "", method.salt) : await passkeyKey(method.credentialId, method.salt, signal),
+          method.wrapped,
+          methodContext(value.id, method),
+        );
   if (raw.length !== 32) {
     raw.fill(0);
     throw invalid();

package/src/browser/command-bridge.ts

@@ -0,0 +1,109 @@
+import type { z } from "zod";
+import type { CommandOptions } from "../contracts/commands";
+import type { GlobalSearchOptions } from "./search-bridge";
+
+export type CommandTarget = { command: string; input: unknown; options?: CommandOptions };
+export type ContextAwareCommand = {
+  id: string;
+  title: string;
+  description: string;
+  icon?: string;
+  /** Selection actions appear before page actions. Defaults to page. */
+  scope?: "selection" | "page";
+  /** One platform-aware key combination, for example mod+shift+k. */
+  shortcut?: string;
+  /** A linkable app Command, an in-place search, or a local UI interaction. */
+  action: CommandTarget | { search: GlobalSearchOptions } | (() => void | Promise<void>);
+};
+type HandleRequest = { target: CommandTarget; handlers: Array<() => void | Promise<void>> };
+type CollectRequest = { commands: ContextAwareCommand[] };
+const HANDLE = "cloud.command.handle";
+const COLLECT = "cloud.command.collect";
+const EXECUTE = "cloud.command.execute";
+type ExecuteRequest = { command: ContextAwareCommand; run: () => Promise<void>; result?: Promise<void> };
+export const COMMANDS_CHANGED = "cloud.command.changed";
+
+/** Document events work across independently hydrated islands and bundles. */
+export const registerCommandHandler = <S extends z.ZodType>(
+  command: string,
+  schema: S,
+  handler: (input: z.output<S>, options: CommandOptions) => void | Promise<void>,
+  accepts: (input: z.output<S>) => boolean = () => true,
+): (() => void) => {
+  let active = true;
+  const listener = (event: Event) => {
+    const request = (event as CustomEvent<HandleRequest>).detail;
+    if (request.target.command !== command) return;
+    const parsed = schema.safeParse(request.target.input);
+    if (!parsed.success || !accepts(parsed.data)) return;
+    // Collect owners before invoking one, so overlapping islands cannot choose by listener order.
+    request.handlers.push(() => {
+      if (!active) throw new Error("Command context is no longer available");
+      return handler(parsed.data, request.target.options ?? {});
+    });
+  };
+  window.addEventListener(HANDLE, listener);
+  return () => {
+    active = false;
+    window.removeEventListener(HANDLE, listener);
+  };
+};
+export const requestCommandHandling = (target: CommandTarget): Promise<void> | undefined => {
+  const detail: HandleRequest = { target, handlers: [] };
+  window.dispatchEvent(new CustomEvent(HANDLE, { detail }));
+  if (detail.handlers.length > 1) return Promise.reject(new Error("Multiple Command owners accepted the request"));
+  const handler = detail.handlers[0];
+  return handler ? Promise.resolve().then(handler) : undefined;
+};
+
+/** Register within a reactive effect and dispose it when the visible context changes. */
+export const registerContextAwareCommand = (command: ContextAwareCommand): (() => void) => {
+  let active = true;
+  let pending: Promise<void> | undefined;
+  const registered = { ...command };
+  const execute = (event: Event) => {
+    const request = (event as CustomEvent<ExecuteRequest>).detail;
+    if (request.command.id !== registered.id || request.command.action !== registered.action) return;
+    if (pending) {
+      request.result = Promise.resolve();
+      return;
+    }
+    pending = Promise.resolve()
+      .then(() => {
+        if (!active) throw new Error("Command context is no longer available");
+        return request.run();
+      })
+      .finally(() => {
+        pending = undefined;
+      });
+    request.result = pending;
+  };
+  const listener = (event: Event) => {
+    const request = (event as CustomEvent<CollectRequest>).detail;
+    request.commands.push(registered);
+  };
+  window.addEventListener(COLLECT, listener);
+  window.addEventListener(EXECUTE, execute);
+  window.dispatchEvent(new Event(COMMANDS_CHANGED));
+  return () => {
+    active = false;
+    window.removeEventListener(COLLECT, listener);
+    window.removeEventListener(EXECUTE, execute);
+    window.dispatchEvent(new Event(COMMANDS_CHANGED));
+  };
+};
+export const collectContextAwareCommands = (): ContextAwareCommand[] => {
+  if (typeof window === "undefined") return [];
+  const detail: CollectRequest = { commands: [] };
+  window.dispatchEvent(new CustomEvent(COLLECT, { detail }));
+  // Ambiguous IDs are not executable, regardless of island hydration order.
+  return detail.commands
+    .filter((command) => detail.commands.filter((other) => other.id === command.id).length === 1)
+    .sort((a, b) => Number(b.scope === "selection") - Number(a.scope === "selection"));
+};
+
+export const requestContextCommandExecution = (command: ContextAwareCommand, run: () => Promise<void>): Promise<void> | undefined => {
+  const detail: ExecuteRequest = { command, run };
+  window.dispatchEvent(new CustomEvent(EXECUTE, { detail }));
+  return detail.result;
+};

package/src/browser/command-shortcuts.ts

@@ -0,0 +1,76 @@
+import { COMMANDS_CHANGED, type ContextAwareCommand, collectContextAwareCommands } from "./command-bridge";
+
+const isMac = () => typeof navigator !== "undefined" && /Mac|iPhone|iPad/.test(navigator.platform);
+const modifiers = ["ctrl", "alt", "shift", "meta"] as const;
+type Combination = { key: string; ctrl: boolean; alt: boolean; shift: boolean; meta: boolean };
+
+const parse = (shortcut: string): Combination | undefined => {
+  const parts = shortcut.toLowerCase().split("+");
+  const key = parts.pop();
+  if (!key || parts.some((part) => !["mod", ...modifiers].includes(part))) return;
+  const keys = new Set(parts.map((part) => (part === "mod" ? (isMac() ? "meta" : "ctrl") : part)));
+  return { key, ctrl: keys.has("ctrl"), alt: keys.has("alt"), shift: keys.has("shift"), meta: keys.has("meta") };
+};
+const signature = (shortcut: string) => {
+  const parsed = parse(shortcut);
+  return parsed && JSON.stringify(parsed);
+};
+
+/** Shared projection for the dispatcher, palette and Help. Conflicts never choose a winner. */
+export const contextCommandsWithShortcuts = (): ContextAwareCommand[] => {
+  const commands = collectContextAwareCommands();
+  const keys = commands.map((command) => (command.shortcut ? signature(command.shortcut) : undefined));
+  return commands.map((command, index) => ({
+    ...command,
+    shortcut: keys[index] && keys.filter((key) => key === keys[index]).length === 1 ? command.shortcut : undefined,
+  }));
+};
+
+export const shortcutLabel = (shortcut: string): string => {
+  const combination = parse(shortcut);
+  if (!combination) return "";
+  const mac = isMac();
+  const names = { ctrl: mac ? "⌃" : "Ctrl", alt: mac ? "⌥" : "Alt", shift: mac ? "⇧" : "Shift", meta: mac ? "⌘" : "Meta" };
+  return [...modifiers.filter((key) => combination[key]).map((key) => names[key]), combination.key.toUpperCase()].join(mac ? "" : "+");
+};
+
+/** One owner in the Cloud layout; app islands only publish commands. */
+export const attachCommandShortcuts = (run: (command: ContextAwareCommand) => void): (() => void) => {
+  const listener = (event: KeyboardEvent) => {
+    if (event.defaultPrevented || event.repeat || event.isComposing || (!isMac() && event.getModifierState("AltGraph"))) return;
+    const target = event.target;
+    const editing =
+      target instanceof Element &&
+      Boolean(target.closest("input, textarea, select, [contenteditable]:not([contenteditable=false]), [role=textbox]"));
+    const dialogOpen = Boolean(document.querySelector('dialog[open], [role="dialog"][aria-modal="true"]'));
+    const matches = contextCommandsWithShortcuts().filter((command) => {
+      if (!command.shortcut) return false;
+      if (command.id !== "cloud.search" && dialogOpen) return false;
+      const combo = parse(command.shortcut);
+      if (!combo || (editing && !combo.ctrl && !combo.meta)) return false;
+      // Shift+/ reports '?' on common keyboard layouts.
+      const key = event.key === "?" && combo.key === "/" ? "/" : event.key.toLowerCase();
+      const physicalLetter =
+        combo.alt &&
+        (event.key === "Dead" || !/^[a-z]$/i.test(event.key)) &&
+        /^[a-z]$/.test(combo.key) &&
+        event.code === `Key${combo.key.toUpperCase()}`;
+      return (
+        (key === combo.key || physicalLetter) &&
+        event.ctrlKey === combo.ctrl &&
+        event.altKey === combo.alt &&
+        event.shiftKey === combo.shift &&
+        event.metaKey === combo.meta
+      );
+    });
+    if (matches.length !== 1) return;
+    event.preventDefault();
+    event.stopPropagation();
+    run(matches[0]!);
+  };
+  // Registered app combinations must win over editor bindings such as Mod+Shift+K.
+  window.addEventListener("keydown", listener, true);
+  return () => window.removeEventListener("keydown", listener, true);
+};
+
+export { COMMANDS_CHANGED };

package/src/browser/commands.ts

@@ -0,0 +1,67 @@
+import { toast } from "@k2b/ui";
+import { resolveCommand } from "../capabilities/client";
+import { type CommandOptions, CommandOptionsSchema, clearCommand, readCommand } from "../contracts/commands";
+import {
+  type ContextAwareCommand,
+  collectContextAwareCommands,
+  requestCommandHandling,
+  requestContextCommandExecution,
+} from "./command-bridge";
+import { resourceSearchMessages } from "./resource-search-messages";
+import { requestGlobalSearch } from "./search-bridge";
+
+export type { CommandOptions } from "../contracts/commands";
+export type { CommandTarget, ContextAwareCommand } from "./command-bridge";
+export { registerCommandHandler, registerContextAwareCommand } from "./command-bridge";
+
+/** Opens locally only when a mounted owner explicitly accepts; otherwise follows the app's URL. */
+export const openCommand = async (command: string, input: unknown = {}, options: CommandOptions = {}): Promise<void> => {
+  const parsedOptions = CommandOptionsSchema.parse(options);
+  const handled = requestCommandHandling({ command, input, options: parsedOptions });
+  if (handled) return handled;
+  const result = await resolveCommand(command, input, parsedOptions);
+  if (!result.ok) throw new Error(result.error.message);
+  window.location.assign(result.data.href);
+};
+
+/** Call after this page's handlers have mounted. Each entry is consumed, including invalid links. */
+export const consumeCommandLink = async (): Promise<void> => {
+  const url = new URL(window.location.href);
+  const messages = resourceSearchMessages.resolve([document.documentElement.lang]).t;
+  let target: ReturnType<typeof readCommand>;
+  try {
+    target = readCommand(url);
+  } catch {
+    window.history.replaceState(window.history.state, "", clearCommand(url));
+    toast.error(messages.commandFailed);
+    return;
+  }
+  if (!target) return;
+  window.history.replaceState(window.history.state, "", clearCommand(url));
+  try {
+    const handled = requestCommandHandling({ command: target.id, input: target.input, options: target.options });
+    if (!handled) {
+      toast.error(messages.commandUnavailable);
+      return;
+    }
+    await handled;
+  } catch (error) {
+    toast.error(error instanceof Error && error.message ? error.message : messages.commandFailed);
+  }
+};
+
+/** The palette and keyboard share live ownership checks, pending guards and error feedback. */
+export const runContextAwareCommand = async (command: ContextAwareCommand): Promise<void> => {
+  const messages = resourceSearchMessages.resolve([document.documentElement.lang]).t;
+  try {
+    const current = collectContextAwareCommands().find((item) => item.id === command.id && item.action === command.action);
+    if (!current) throw new Error(messages.commandUnavailable);
+    await requestContextCommandExecution(current, async () => {
+      if (typeof current.action === "function") await current.action();
+      else if ("search" in current.action) await requestGlobalSearch({ query: "", ...current.action.search });
+      else await openCommand(current.action.command, current.action.input, current.action.options);
+    });
+  } catch (error) {
+    toast.error(error instanceof Error && error.message ? error.message : messages.commandFailed);
+  }
+};

package/src/browser/navigation-search.ts

@@ -0,0 +1,48 @@
+import { fuzzy } from "@k2b/stdlib";
+import type { SearchItem } from "../api/search/schemas";
+import type { AppMeta } from "../contracts/app";
+
+/** UI-only rows. The synthetic ref is a row key, never a readable resource. */
+export type NavigationSearchItem = SearchItem & { keywords?: readonly string[] };
+
+export const navigationSearchItems = (apps: readonly AppMeta[], visibleAppIds: readonly string[]): NavigationSearchItem[] => {
+  const visible = new Set(visibleAppIds);
+  return apps
+    .filter((app) => visible.has(app.id))
+    .flatMap((app) =>
+      (app.searchLinks ?? []).map((link) => ({
+        appId: app.id,
+        appName: app.name,
+        appIcon: app.icon,
+        ref: { type: "cloud.navigation", id: `${app.id}:${link.href}` },
+        readable: false,
+        title: link.label,
+        preview: link.description,
+        href: link.href,
+        icon: link.icon ?? app.icon,
+        priority: 0,
+        keywords: link.keywords,
+      })),
+    );
+};
+
+export const matchNavigationSearchItems = (
+  items: readonly NavigationSearchItem[],
+  input: { query: string; tags: readonly string[]; appId?: string | null; requireReader?: boolean },
+): NavigationSearchItem[] => {
+  const query = input.query.trim().toLowerCase();
+  if (input.requireReader || input.tags.length > 0 || (!input.appId && query.length < 2)) return [];
+  if (input.appId) {
+    const scoped = items.filter((item) => item.appId === input.appId);
+    return query
+      ? fuzzy
+          .filter(query, scoped, { key: (item) => [item.title, item.preview ?? "", ...(item.keywords ?? [])].join(" ") })
+          .map((hit) => hit.item)
+      : scoped;
+  }
+  const words = query.split(/\s+/);
+  return items.filter((item) => {
+    const text = [item.title, item.preview ?? "", ...(item.keywords ?? [])].join(" ").toLowerCase();
+    return words.every((word) => text.includes(word));
+  });
+};

package/src/browser/notifications.ts

@@ -56,7 +56,7 @@ const subscriptionPayload = (subscription: PushSubscription): BrowserPushSubscri
   };
 };
 
-const responseError = async (response: Response, fallback: string): Promise<Error> => {
+const responseError = async (response: Pick<Response, "json">, fallback: string): Promise<Error> => {
   try {
     const payload = (await response.json()) as { message?: unknown };
     if (typeof payload.message === "string" && payload.message.trim()) return new Error(payload.message);

package/src/browser/resource-picker.tsx

@@ -1,11 +1,11 @@
-import { prompts } from "@k2b/ui";
+import { dialogCore } from "@k2b/ui";
 import type { SearchItem } from "../api/search/schemas";
 import type { CloudResourceRef } from "../contracts";
 import CloudResourceSearch from "./CloudResourceSearch";
+import { resourceSearchDialogOptions } from "./resource-search-dialog";
 import { resourceSearchMessages } from "./resource-search-messages";
 
 export type CloudResourcePickerItem = SearchItem;
-
 export type CloudResourcePickerOptions = {
   title?: string;
   placeholder?: string;
@@ -17,23 +17,10 @@ export type CloudResourcePickerOptions = {
 export const openCloudResourcePicker = (options: CloudResourcePickerOptions = {}): Promise<CloudResourcePickerItem | undefined> => {
   const locale = typeof document === "undefined" ? "en" : document.documentElement.lang || "en";
   const t = resourceSearchMessages.resolve([locale]).t;
-  return prompts.dialog<CloudResourcePickerItem>(
+  return dialogCore.open<CloudResourcePickerItem>(
     (close) => (
-      <div class="k2b-dialog__body h-[min(36rem,var(--ui-dialog-available-height))] min-h-0 p-0">
-        <CloudResourceSearch
-          initialAppId={options.initialAppId}
-          excludeRefs={options.excludeRefs}
-          requireReader={options.requireReader}
-          placeholder={options.placeholder ?? t.searchPlaceholder}
-          onSelect={close}
-        />
-      </div>
+      <CloudResourceSearch {...options} title={options.title ?? t.chooseResource} selectionMode onSelect={close} onClose={() => close()} />
     ),
-    {
-      title: options.title ?? t.chooseResource,
-      icon: "ti ti-cloud-search",
-      size: "large",
-      ariaLabel: options.title ?? t.chooseResource,
-    },
+    resourceSearchDialogOptions(options.title ?? t.chooseResource),
   );
 };

package/src/browser/resource-search-dialog.ts

@@ -0,0 +1,9 @@
+import type { OpenDialogOptions } from "@k2b/ui";
+
+/** One shell for global navigation and resource selection, with native focus/escape handling. */
+export const resourceSearchDialogOptions = (ariaLabel: string): OpenDialogOptions => ({
+  panelClassName: "cloud-search-dialog",
+  contentClassName: "cloud-search-dialog__content",
+  initialFocus: "first-input",
+  ariaLabel,
+});

package/src/browser/resource-search-input.ts

@@ -0,0 +1,46 @@
+import type { SearchApp } from "../api/search/schemas";
+
+export type SearchTag = NonNullable<SearchApp["tags"]>[number] & { appName: string; appIcon: string };
+
+/** Keep aliases discoverable without listing the same facet repeatedly. */
+export const searchTags = (apps: readonly SearchApp[], appId?: string | null): SearchTag[] => {
+  const seen = new Set<string>();
+  return apps
+    .filter((app) => !appId || app.id === appId)
+    .flatMap((app) =>
+      (app.tags ?? []).flatMap((tag) => {
+        if (seen.has(tag.tag)) return [];
+        seen.add(tag.tag);
+        return [{ ...tag, appName: app.name, appIcon: app.icon }];
+      }),
+    );
+};
+
+export const tagAtCursor = (text: string, caret: number) => {
+  const pos = Math.min(caret, text.length);
+  let start = pos;
+  let end = pos;
+  while (start > 0 && !/\s/.test(text[start - 1]!)) start--;
+  while (end < text.length && !/\s/.test(text[end]!)) end++;
+  if (text[start] !== "#" || pos <= start || text.slice(start + 1, end).includes("#")) return null;
+  return { start, end, prefix: text.slice(start + 1, pos).toLowerCase() };
+};
+
+/** Only whitespace commits a typed/pasted tag; an unfinished #prefix is not an error. */
+export const commitTypedTags = (text: string, caret: number) => {
+  const tags: string[] = [];
+  let nextCaret = caret;
+  const input = text.replace(/(^|\s)#([^\s#]+)(?=\s)/g, (match: string, space: string, tag: string, offset: number) => {
+    tags.push(tag.toLowerCase());
+    if (offset < caret) nextCaret -= Math.min(match.length - space.length, caret - offset - space.length);
+    return space;
+  });
+  return { input, caret: Math.max(0, nextCaret), tags };
+};
+
+export const matchingSearchTags = (tags: readonly SearchTag[], prefix: string, selected: readonly string[]) =>
+  tags.filter(
+    (tag) =>
+      !selected.some((value) => value === tag.tag || tag.aliases?.includes(value)) &&
+      (!prefix || [tag.tag, tag.title.toLowerCase(), ...(tag.aliases ?? [])].some((value) => value.startsWith(prefix))),
+  );

package/src/browser/resource-search-messages.ts

@@ -4,52 +4,88 @@ export const resourceSearchMessages = i18n.define({
   baseLocale: "en",
   messages: {
     en: {
-      searchFailed: "Search failed.",
-      searchPlaceholder: "Search across apps…",
+      actions: "Actions",
+      contextActions: "On this page",
+      commandPlaceholder: "Find an action…",
+      commandFailed: "Could not open this action. Try again.",
+      commandUnavailable: "This action is no longer available. Choose another action.",
+      commandHint: "Choose an action, or type > next time.",
+      searchFailed: "Search is currently unavailable. Try again.",
+      navigationFailed: "Could not open this result. Try again.",
+      partialFailure: "Some search sources are unavailable. Results may be incomplete.",
+      searchPlaceholder: "Search Cloud…",
+      scopedSearchPlaceholder: "Search…",
       searchCloudResources: "Search Cloud resources",
-      tagSuggestions: "Tag suggestions",
-      filterByApp: "Filter by app",
-      allApps: "All apps",
-      removeTag: ({ tag }: { tag: string }) => `Remove tag ${tag}`,
-      removeTagTitle: ({ tag }: { tag: string }) => `Remove #${tag}`,
+      chooseResource: "Choose a resource",
+      pickerPlaceholder: "Find a resource…",
+      close: "Close search",
+      add: "Add",
+      chooseFirst: "Select a resource",
+      details: "Details",
+      back: "Back to results",
+      tagSuggestions: "Search filters",
+      allTags: "All filters",
+      backToSearch: "Back to search",
+      navigationHint: "Search available pages.",
+      startHint: "Find content, or narrow your search with a tag.",
+      pickerHint: "Find a note, file, or another resource.",
+      noMatches: "No matches. Try another search term.",
+      noTags: "No matching filter.",
+      unsupportedTags: "Unknown filter. Remove it or choose another.",
+      removeTag: ({ tag }: { tag: string }) => `Remove #${tag}`,
+      removeScope: ({ app }: { app: string }) => `Search beyond ${app}`,
       resultCount: ({ count }: { count: number }) => i18n.plural(count, "en", { one: `${count} result`, other: `${count} results` }),
-      tagHelp: "tag help",
-      typeToSearchBeforeTag: "Type to search, or use a",
-      typeToSearchAfterTag: "to focus on one app.",
-      noTagsAvailable: "No tags available.",
-      addTag: ({ tag, app }: { tag: string; app: string }) => `Add #${tag} (${app})`,
-      seeAllTagDescriptions: "See all tag descriptions",
-      noAppSupports: "No app supports",
-      removeTagOrPick: "Remove the tag or pick one below.",
-      removeNamedTag: ({ tag }: { tag: string }) => `Remove #${tag}`,
-      noMatches: "No matches",
-      matchesFor: "for",
-      selectPreview: "Select a result to preview details.",
-      chooseResource: "Choose Cloud resource",
+      retry: "Try again",
+      navigate: "navigate",
+      open: "open",
+      newTab: "new tab",
+      homeHint: "Back to center",
+      releaseHint: "Release to center",
+      select: "select",
+      loading: "Searching…",
+      loadingTags: "Loading filters…",
     },
     de: {
-      searchFailed: "Die Suche ist fehlgeschlagen.",
-      searchPlaceholder: "Apps durchsuchen…",
+      actions: "Aktionen",
+      contextActions: "Auf dieser Seite",
+      commandPlaceholder: "Aktion finden…",
+      commandFailed: "Die Aktion konnte nicht geöffnet werden. Versuche es erneut.",
+      commandUnavailable: "Diese Aktion ist nicht mehr verfügbar. Wähle eine andere Aktion.",
+      commandHint: "Wähle eine Aktion – beim nächsten Mal geht auch >.",
+      searchFailed: "Suche gerade nicht erreichbar. Versuche es erneut.",
+      navigationFailed: "Der Treffer konnte nicht geöffnet werden. Versuche es erneut.",
+      partialFailure: "Einige Suchquellen sind nicht erreichbar. Ergebnisse können unvollständig sein.",
+      searchPlaceholder: "Cloud durchsuchen…",
+      scopedSearchPlaceholder: "Durchsuchen…",
       searchCloudResources: "Cloud-Inhalte durchsuchen",
-      tagSuggestions: "Tag-Vorschläge",
-      filterByApp: "Nach App filtern",
-      allApps: "Alle Apps",
-      removeTag: ({ tag }) => `Tag ${tag} entfernen`,
-      removeTagTitle: ({ tag }) => `#${tag} entfernen`,
+      chooseResource: "Ressource wählen",
+      pickerPlaceholder: "Ressource suchen…",
+      close: "Suche schließen",
+      add: "Hinzufügen",
+      chooseFirst: "Eine Ressource auswählen",
+      details: "Details",
+      back: "Zurück zu Ergebnissen",
+      tagSuggestions: "Suchfilter",
+      allTags: "Alle Filter",
+      backToSearch: "Zurück zur Suche",
+      navigationHint: "Verfügbare Seiten durchsuchen.",
+      startHint: "Inhalte finden oder mit einem Tag eingrenzen.",
+      pickerHint: "Finde eine Notiz, Datei oder einen anderen Inhalt.",
+      noMatches: "Keine Treffer. Versuche einen anderen Suchbegriff.",
+      noTags: "Kein passender Filter.",
+      unsupportedTags: "Unbekannter Filter. Entferne ihn oder wähle einen anderen.",
+      removeTag: ({ tag }) => `#${tag} entfernen`,
+      removeScope: ({ app }) => `Außerhalb von ${app} suchen`,
       resultCount: ({ count }) => i18n.plural(count, "de", { one: `${count} Ergebnis`, other: `${count} Ergebnisse` }),
-      tagHelp: "Hilfe zu Tags",
-      typeToSearchBeforeTag: "Gib einen Suchbegriff ein oder verwende einen",
-      typeToSearchAfterTag: "für die Suche in einer bestimmten App.",
-      noTagsAvailable: "Keine Tags verfügbar.",
-      addTag: ({ tag, app }) => `#${tag} hinzufügen (${app})`,
-      seeAllTagDescriptions: "Alle Tag-Beschreibungen anzeigen",
-      noAppSupports: "Keine App unterstützt",
-      removeTagOrPick: "Entferne den Tag oder wähle unten einen anderen aus.",
-      removeNamedTag: ({ tag }) => `#${tag} entfernen`,
-      noMatches: "Keine Treffer",
-      matchesFor: "für",
-      selectPreview: "Wähle ein Ergebnis aus, um Details anzuzeigen.",
-      chooseResource: "Cloud-Inhalt auswählen",
+      retry: "Erneut versuchen",
+      navigate: "navigieren",
+      open: "öffnen",
+      newTab: "neuer Tab",
+      homeHint: "Zurück zur Mitte",
+      releaseHint: "Loslassen zum Zentrieren",
+      select: "auswählen",
+      loading: "Suche läuft…",
+      loadingTags: "Filter werden geladen…",
     },
   },
 });

package/src/browser/resource-search.ts

@@ -8,12 +8,19 @@ export const cloudResourceSearchUrl = (request: {
   query: string;
   tags: readonly string[];
   appId?: string | null;
+  scope?: CloudResourceRef;
+  scopeTag?: string;
   requireReader?: boolean;
 }): string => {
   const params = new URLSearchParams({ provider_limit: String(PROVIDER_LIMIT) });
   if (request.query.length > 0) params.set("q", request.query);
   for (const tag of request.tags) params.append("tag", tag);
   if (request.appId) params.set("app", request.appId);
+  if (request.scopeTag !== undefined) params.set("scope_tag", request.scopeTag);
+  if (request.scope) {
+    params.set("scope_type", request.scope.type);
+    params.set("scope_id", request.scope.id);
+  }
   if (request.requireReader) params.set("require_reader", "true");
   return `/api/search?${params.toString()}`;
 };