auricui-skill 0.0.0-stage → 0.1.2

package/skill/assets/upstream/apps/desktop/chat/src/lib/studio-film.ts

@@ -0,0 +1,44 @@
+/**
+ * The film as Studio has it: film.html, read through Studio's own API (this page is Studio's, so the API is ours too).
+ * The chat reads it when a project opens and keeps which file each clip is, so a clip an agent names in its reply gets
+ * the icon of what it is.
+ */
+import React from 'react';
+import type { FilmDoc } from 'openfilm/film-doc';
+
+/** how long a read may take before it is given up */
+const READ_WAIT_MS = 4000;
+
+let clipSrc = new Map<string, string>();
+const listeners = new Set<() => void>();
+
+/** The project's film as Studio reads it from its folder; null when it cannot say (no film, one with problems, no answer). */
+export async function readStudioFilm(projectId: string): Promise<FilmDoc | null> {
+  const stop = new AbortController();
+  const timer = setTimeout(() => stop.abort(), READ_WAIT_MS);
+  try {
+    const res = await fetch(`/api/projects/${encodeURIComponent(projectId)}`, { signal: stop.signal });
+    if (!res.ok) return null;
+    const { doc } = await res.json() as { doc?: FilmDoc | null };
+    if (!doc || !Array.isArray(doc.tracks)) return null;
+    const next = new Map<string, string>();
+    for (const track of doc.tracks) for (const clip of track.clips) if (clip?.id && clip.src) next.set(clip.id, clip.src);
+    clipSrc = next;
+    for (const listener of listeners) listener();
+    return doc;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function subscribe(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => { listeners.delete(listener); };
+}
+
+/** The file of the clip with this id in the film last read; null when that film has no such clip (or none was read). */
+export function useClipSrc(id: string | null): string | null {
+  return React.useSyncExternalStore(subscribe, () => (id ? clipSrc.get(id) ?? null : null), () => null);
+}

package/skill/assets/upstream/apps/desktop/chat/src/lib/studio-transfer.ts

@@ -0,0 +1,40 @@
+/**
+ * Studio's things carried into the composer, dropped or pasted: what Studio drags out (STUDIO_REF_TYPE, a JSON array
+ * of references) and a file dragged from its media pane (RESOURCE_DRAG_TYPE), which becomes a reference to that file.
+ */
+import { STUDIO_REF_TYPE } from 'openfilm/studio-ui/lib/host.ts';
+import { RESOURCE_DRAG_TYPE, readResourceDragData } from 'openfilm/studio-ui/lib/resource-drag.ts';
+import type { StudioRef } from '@/app-bridge';
+
+const KINDS = new Set(['clip', 'layer', 'region', 'time', 'range', 'track', 'file', 'subtitle']);
+
+/** Whether a drag or a paste carries Studio's things (a drag shows only its types until the drop). */
+export function transferHasStudioRefs(data: Pick<DataTransfer, 'types'>): boolean {
+  const types = [...data.types];
+  return types.includes(STUDIO_REF_TYPE) || types.includes(RESOURCE_DRAG_TYPE);
+}
+
+/**
+ * The references a drop or a paste carries, none when it carries none. The data comes from outside the chat and may
+ * not be what Studio put there: anything not shaped as a reference is left out.
+ */
+export function studioRefsFromTransfer(data: Pick<DataTransfer, 'getData' | 'types'>): StudioRef[] {
+  const types = [...data.types];
+  if (types.includes(STUDIO_REF_TYPE)) {
+    try {
+      const list: unknown = JSON.parse(data.getData(STUDIO_REF_TYPE));
+      return (Array.isArray(list) ? list : [list]).filter((ref): ref is StudioRef => Boolean(ref) && typeof ref === 'object' && KINDS.has((ref as { kind?: unknown }).kind as string));
+    } catch {
+      return [];
+    }
+  }
+  const file = types.includes(RESOURCE_DRAG_TYPE) ? readResourceDragData(data) : null;
+  if (!file) return [];
+  return [{
+    kind: 'file',
+    path: file.path,
+    fileKind: file.kind,
+    ...(file.durationMs ? { duration: file.durationMs / 1000 } : {}),
+    ...(file.w && file.h ? { w: file.w, h: file.h } : {}),
+  }];
+}

package/skill/assets/upstream/apps/desktop/chat/src/lib/unprompted.ts

@@ -0,0 +1,27 @@
+/**
+ * Turns the agent starts by itself: a background task of its own came back after its turn (a command it ran in the
+ * background, a subagent), and it takes it up, as in its own chat (lib/local-agent-run onUnpromptedTurn).
+ *
+ * Pure: no React, no bridge, so `node --test` runs it (src/unprompted.test.mjs).
+ */
+
+/**
+ * The updates that mean the agent has gone on working: it writes, thinks, starts a tool or plans. Not an update of a
+ * call (`tool_call_update`): that is the rest of a call already shown, such as a command still running as its turn
+ * ended (it was stopped, or ended without waiting), whose output and exit come after.
+ */
+const OPENS_A_TURN = new Set(['agent_message_chunk', 'agent_thought_chunk', 'tool_call', 'plan']);
+
+/** Whether this update, with no turn open, is the agent working by itself. */
+export function opensUnprompted(update: { sessionUpdate?: unknown }): boolean {
+  return typeof update.sessionUpdate === 'string' && OPENS_A_TURN.has(update.sessionUpdate);
+}
+
+/** A turn the agent started by itself that ended with nothing in it: not shown, a line with nothing under it. */
+export function isEmptyBackgroundTurn(
+  turn: { origin?: unknown; status?: unknown; error?: unknown },
+  items: readonly unknown[],
+): boolean {
+  const settled = turn.status === 'ready' || turn.status === 'cancelled';
+  return turn.origin === 'background' && settled && !turn.error && items.length === 0;
+}

package/skill/assets/upstream/apps/desktop/chat/src/lib/upload-limits.ts

@@ -0,0 +1,53 @@
+/**
+ * Attachment formats.
+ *
+ * The composer doesn't filter by format. Files are sorted only by how they reach the model:
+ *   · images go into the message (a multimodal model sees the pixels) and are also saved, with a path;
+ *   · everything else goes as a path only. The model can't read the bytes of a pdf or mp4; a path it can read,
+ *     open with Python or put in the film is more honest, and more useful, than pretending to send the file.
+ */
+
+/*
+ * No size limits here: each file is imported into the project folder and the agent gets its path.
+ */
+
+/**
+ * Two sets rather than one audio-video set: the UI must pick a tile's icon and open it in `<video>` or `<audio>`;
+ * an mp3 in a video player is a screen that stays black.
+ */
+export const VIDEO_UPLOAD_EXTENSIONS = new Set(['mp4', 'mov', 'webm', 'm4v', 'avi', 'mkv']);
+export const AUDIO_UPLOAD_EXTENSIONS = new Set([
+  'mp3', 'wav', 'm4a', 'aac', 'ogg', 'oga', 'opus', 'flac',
+]);
+
+/**
+ * Documents whose mediaType is known. Not an allow-list: the composer takes anything (see the header). The table
+ * only supplies a MIME type when the browser reports none.
+ */
+export const DOCUMENT_EXTENSIONS = new Set([
+  'csv', 'xlsx', 'pptx', 'docx', 'pdf',
+  'txt', 'md', 'markdown',
+  'doc', 'xls', 'ppt', 'rtf', 'odt', 'ods', 'odp',
+]);
+
+export const DOCUMENT_MEDIA_TYPES: Record<string, string> = {
+  csv: 'text/csv',
+  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  pdf: 'application/pdf',
+  txt: 'text/plain',
+  md: 'text/markdown',
+  markdown: 'text/markdown',
+  doc: 'application/msword',
+  xls: 'application/vnd.ms-excel',
+  ppt: 'application/vnd.ms-powerpoint',
+  rtf: 'application/rtf',
+  odt: 'application/vnd.oasis.opendocument.text',
+  ods: 'application/vnd.oasis.opendocument.spreadsheet',
+  odp: 'application/vnd.oasis.opendocument.presentation',
+};
+
+
+/** Extensions recognized as images, for reference pictures. */
+export const IMAGE_EXTENSIONS = ['png', 'jpg', 'jpeg', 'webp', 'gif', 'svg'] as const;

package/skill/assets/upstream/apps/desktop/chat/src/mount.tsx

@@ -0,0 +1,19 @@
+/**
+ * The chat, mounted in Studio's page (apps/desktop/shell): its column beside Studio, under the top bar. The theme is
+ * the page's (`<html data-theme>`, Studio's), so there is nothing to follow; the language is Studio's too, and the
+ * chat's own words follow it.
+ */
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import { App } from './App';
+import { app } from './app-bridge';
+import { setLanguage } from './i18n';
+
+export async function mountChat(root: HTMLElement) {
+  const hello = await app.hello();
+  setLanguage(hello.language);
+  app.onLanguage(setLanguage);
+  createRoot(root).render(
+    <StrictMode><App initialProject={hello.project} initialSelection={hello.selection} initialFfmpeg={hello.ffmpeg} /></StrictMode>,
+  );
+}

package/skill/assets/upstream/apps/desktop/chat/src/state/local-agent-store.ts

@@ -0,0 +1,296 @@
+/**
+ * The chat's agent and its options, for the composer's agent menu (ModelPopover).
+ *
+ * Which agents there are, whether each is connected and whether the person switched it on for the chat, is the app's
+ * roster (apps/desktop/src/agent-roster.mjs; Settings → Agents changes it): the menu lists the agents switched on,
+ * and the chat uses the one picked while it is on and ready, else the first one that is.
+ *
+ * Kept here, on this computer: which agent was picked, the options picked for each (model, reasoning effort, speed:
+ * ACP configOption ids) and the option list each last reported, so the menu shows "6 Astra · Medium" before the
+ * first message (the list only comes with a session).
+ */
+import { create } from 'zustand';
+import { isAgentId as isAgent } from '../../../src/agent-definitions.mjs';
+import {
+  desktopBridge,
+  type LocalAgentId,
+  type LocalAgentSessionInfo,
+  type RosterAgent,
+} from '@/lib/desktop-bridge';
+import { forgetLocalAgentSessions, keepCommands, readCommands } from '@/lib/local-agent-run';
+
+export type AgentPick = LocalAgentId;
+
+type ConfigOptions = NonNullable<LocalAgentSessionInfo['configOptions']>;
+
+interface Persisted {
+  picked: LocalAgentId;
+  prefs: Partial<Record<LocalAgentId, Record<string, unknown>>>;
+  options: Partial<Record<LocalAgentId, ConfigOptions>>;
+}
+
+interface LocalAgentStore extends Persisted {
+  hydrated: boolean;
+  /** The roster as the app last told it; null = not told yet (or not in the app). */
+  roster: RosterAgent[] | null;
+  /**
+   * Asking an agent for its option list failed (its adapter would not start): the menu says so, with what it said
+   * (`text`) and why, when known (`code`: 'outdated', a Codex older than the chat needs).
+   */
+  optionsError: Partial<Record<LocalAgentId, { text: string; code?: string }>>;
+  hydrate(): void;
+  refresh(): Promise<void>;
+  pick(agent: LocalAgentId): void;
+  setPref(agent: LocalAgentId, configId: string, value: unknown): void;
+  /** The option list a session reported, kept for the menu. */
+  noteOptions(agent: LocalAgentId, options: ConfigOptions | null): void;
+  /** No option list yet: ask for one (a session opened and closed, nothing said, nothing spent). */
+  /** Ask the agent for its options once; one that failed is asked again only on `retry` (the menu opened, Retry). */
+  ensureOptions(agent: LocalAgentId, opts?: { retry?: boolean }): Promise<void>;
+}
+
+const probing = new Set<LocalAgentId>();
+/** the agents asked for their options since the app started: the ones kept from before are shown until then, but an
+    agent updated since (Claude Code with new models) has other options, so each is asked once a launch */
+const askedThisLaunch = new Set<LocalAgentId>();
+
+const KEY = 'openfilm.local-agents.v2';
+
+function load(): Persisted {
+  const empty: Persisted = { picked: 'claude', prefs: {}, options: {} };
+  if (typeof window === 'undefined') return empty;
+  try {
+    const raw = JSON.parse(window.localStorage.getItem(KEY) ?? window.localStorage.getItem('openfilm.local-agents.v1') ?? 'null') as Partial<Persisted> | null;
+    if (!raw) return empty;
+    return {
+      picked: isAgent(raw.picked) ? raw.picked : 'claude',
+      prefs: raw.prefs && typeof raw.prefs === 'object' ? raw.prefs : {},
+      options: raw.options && typeof raw.options === 'object' ? raw.options : {},
+    };
+  } catch {
+    return empty;
+  }
+}
+
+function save(s: Persisted): void {
+  try {
+    window.localStorage.setItem(KEY, JSON.stringify({ picked: s.picked, prefs: s.prefs, options: s.options }));
+  } catch { /* private mode */ }
+}
+
+type OwnModel = NonNullable<RosterAgent['byok']>['models'][number];
+
+/** The own key's models, as Settings sets them up (the first one to begin with). */
+function byokModels(roster: RosterAgent[] | null): OwnModel[] {
+  return roster?.find((a) => a.id === 'byok')?.byok?.models ?? [];
+}
+
+/**
+ * Which own model a pick is: its id, or, picked before each model was set up on its own, the model's name at the
+ * service (that model kept its name there). Null for one no longer set up.
+ */
+function ownModelPicked(models: OwnModel[], picked: unknown): OwnModel | null {
+  const value = String(picked ?? '');
+  return models.find((m) => m.id === value) ?? models.find((m) => m.model === value) ?? null;
+}
+
+const EFFORT_NAMES: Record<string, string> = { auto: 'Auto', off: 'Off', minimal: 'Minimal', low: 'Low', medium: 'Medium', high: 'High', xhigh: 'Extra high', max: 'Max' };
+
+/**
+ * An agent's option list, for the menu. The own key's is its models, and the efforts of the one picked when it offers
+ * more than one, from Settings: no session has to start to know them (the app's own agent reports the same `model` and
+ * `effort` options, apps/desktop/src/pi-config.mjs). The person's own agents' is the one a session last reported.
+ */
+export function agentOptions(state: Pick<LocalAgentStore, 'options' | 'roster'> & Partial<Pick<LocalAgentStore, 'prefs'>>, agent: LocalAgentId): ConfigOptions | undefined {
+  if (agent !== 'byok') return state.options[agent];
+  const models = byokModels(state.roster);
+  if (!models.length) return undefined;
+  const model = ownModelPicked(models, state.prefs?.byok?.model) ?? models[0]!;
+  const options: ConfigOptions = [{ id: 'model', name: 'Model', category: 'model', type: 'select', currentValue: model.id, options: models.map((m) => ({ value: m.id, name: m.name })) }];
+  if (model.levels.length > 1) {
+    options.push({ id: 'effort', name: 'Effort', category: 'thought_level', type: 'select', currentValue: model.effort,
+      options: model.levels.map((l) => ({ value: l, name: EFFORT_NAMES[l] ?? l })) });
+  }
+  return options;
+}
+
+/** Which of an agent's options the menu offers. The app's own agent offers its models and their efforts, and no OpenAI fast mode. */
+export function offeredOption(agent: LocalAgentId, _roster: RosterAgent[] | null, option: { id: string; category?: string; name: string }): boolean {
+  if (agent !== 'byok') return true;
+  return !(/^(fast|fast-mode|speed)$/i.test(option.id) || option.category === 'speed');
+}
+
+/* Claude Code's own model picker shows four above its line, the newest of each family; the ones it lists after them
+   are older models */
+const CLAUDE_MODELS_OFFERED = 4;
+
+/**
+ * The choices a menu row offers, in the agent's order, without a "Default" row (a default is one of the others). Of
+ * Claude Code's models, the first four it lists, as its own picker shows them, and the one in use if it is further down.
+ */
+export function offeredChoices<T extends { value: unknown }>(agent: LocalAgentId, option: { id: string; category?: string; options?: T[] }, chosen: unknown): T[] {
+  const choices = (option.options ?? []).filter((choice) => choice.value !== 'default');
+  if (agent !== 'claude' || (option.category !== 'model' && option.id !== 'model')) return choices;
+  return choices.filter((choice, i) => i < CLAUDE_MODELS_OFFERED || choice.value === chosen);
+}
+
+/** The agents the menu lists: the ones switched on in Settings, in the roster's order. */
+export function shownAgents(roster: RosterAgent[] | null): RosterAgent[] {
+  return (roster ?? []).filter((a) => a.shown);
+}
+
+/** The agent the chat uses: the one picked while it is shown and ready, else the first shown one that is ready. */
+export function currentAgent(state: Pick<LocalAgentStore, 'picked' | 'roster'>): LocalAgentId {
+  const shown = shownAgents(state.roster);
+  const picked = shown.find((a) => a.id === state.picked);
+  if (picked?.status === 'ready' || !state.roster) return state.picked;
+  return shown.find((a) => a.status === 'ready')?.id ?? picked?.id ?? shown[0]?.id ?? state.picked;
+}
+
+let listening = false;
+
+export const useLocalAgents = create<LocalAgentStore>((set, get) => ({
+  picked: 'claude',
+  prefs: {},
+  options: {},
+  hydrated: false,
+  roster: null,
+  optionsError: {},
+  hydrate() {
+    if (get().hydrated) return;
+    set({ ...load(), hydrated: true });
+    const api = desktopBridge()?.agents;
+    if (api && !listening) {
+      listening = true;
+      api.onChange((roster) => {
+        /* an agent that stopped being ready: what its sessions held goes (it may be another account next time) */
+        for (const before of get().roster ?? []) {
+          const now = roster.find((a) => a.id === before.id);
+          if (before.status === 'ready' && now?.status !== 'ready') forgetLocalAgentSessions(before.id);
+          /* other models (the own key's): its sessions were closed for the next ones to use them */
+          else if (JSON.stringify(byokModels([before])) !== JSON.stringify(byokModels(now ? [now] : []))) forgetLocalAgentSessions(before.id);
+        }
+        set({ roster });
+      });
+    }
+    void get().refresh();
+  },
+  async refresh() {
+    const roster = await desktopBridge()?.agents?.list().catch(() => null);
+    if (roster) set({ roster });
+  },
+  pick(picked) {
+    set({ picked });
+    save(get());
+  },
+  setPref(agent, configId, value) {
+    const prefs = { ...get().prefs, [agent]: { ...(get().prefs[agent] ?? {}), [configId]: value } };
+    set({ prefs });
+    save(get());
+  },
+  noteOptions(agent, options) {
+    if (!options) return;
+    set({ options: { ...get().options, [agent]: options } });
+    save(get());
+  },
+  async ensureOptions(agent, { retry = false } = {}) {
+    /* the own key's are known from Settings (agentOptions); a failed probe is not tried again on every render, each
+       try being a whole session of the agent's */
+    if (agent === 'byok' || probing.has(agent)) return;
+    const kept = Boolean(get().options[agent]);
+    if (kept && askedThisLaunch.has(agent)) return;
+    if (get().optionsError[agent] && !retry) return;
+    const api = desktopBridge()?.localAgents;
+    if (!api) return;
+    probing.add(agent);
+    askedThisLaunch.add(agent);
+    set({ optionsError: { ...get().optionsError, [agent]: undefined } });
+    try {
+      const r = await api.probe(agent).catch((e: unknown) => ({ ok: false as const, error: e instanceof Error ? e.message : String(e), code: undefined }));
+      if (r.ok && r.info.commands?.length) keepCommands(agent, readCommands({ availableCommands: r.info.commands }));
+      if (r.ok && r.info.configOptions?.length) get().noteOptions(agent, r.info.configOptions);
+      /* the ones kept from before stay when this launch's ask fails */
+      else if (!kept) set({ optionsError: { ...get().optionsError, [agent]: r.ok ? { text: 'no options' } : { text: r.error, ...(r.code ? { code: r.code } : {}) } } });
+    } finally {
+      probing.delete(agent);
+    }
+  },
+}));
+
+/**
+ * What the app sets for every agent and the menu does not offer: full access (it works in the person's own project
+ * folder, every step is in the edit and version history and can be undone; clicking "Allow" a dozen times a turn
+ * protects nothing). Ids differ between the adapters; an option a session does not have is skipped. The other agents
+ * are started with it (their own flags, apps/desktop/src/agents.mjs), except Kimi and MiniMax Code, whose ACP servers
+ * take no flag.
+ */
+const AGENT_FORCED_PREFS: Partial<Record<LocalAgentId, Record<string, unknown>>> = {
+  claude: { mode: 'bypassPermissions' },
+  codex: { mode: 'agent-full-access' },
+  kimi: { mode: 'yolo' },
+  minimax: { permissionMode: 'bypassPermissions' },
+  byok: { mode: 'agent-full-access' },
+};
+
+/** picks the menu no longer offers: plan mode (Claude Code's `plan`, Codex's collaboration mode) */
+const DROPPED_PREFS = new Set(['plan', 'collaboration_mode']);
+
+/**
+ * The options in effect for an agent: the person's picks, then the ones the app sets. What the person never picked
+ * here is the agent's own, as their config has it: the same model and effort as in their terminal. The own key's model
+ * picked by its name at the service (before each model was set up on its own) is its id now.
+ */
+export function effectivePrefs(prefs: Persisted['prefs'], agent: LocalAgentId, roster?: RosterAgent[] | null, options?: ConfigOptions): Record<string, unknown> {
+  /* "default" was a row the menu no longer offers (the agents name their default for what it is): the agent's own
+     current value stands instead. A mode picked once (plan mode, offered for a while) is not kept: every agent works
+     with full access. A pick the agent no longer offers (a model gone in its update, one the own key no longer names)
+     is not kept either: the agent's own stands instead */
+  const offers = (id: string, value: unknown) => {
+    const option = options?.find((o) => o.id === id);
+    return !option?.options?.length || option.options.some((o) => o.value === value);
+  };
+  const models = agent === 'byok' ? byokModels(roster ?? null) : null;
+  const own = Object.entries(prefs[agent] ?? {}).map(([id, value]): [string, unknown] => (models && id === 'model' ? [id, ownModelPicked(models, value)?.id ?? null] : [id, value]));
+  const kept = Object.fromEntries(own
+    .filter(([id, value]) => value !== 'default' && value !== null && !DROPPED_PREFS.has(id) && offers(id, value)));
+  return { ...kept, ...(AGENT_FORCED_PREFS[agent] ?? {}) };
+}
+
+/** An option's current value (the person's pick first, else the value the session reports). */
+export function optionValue(options: ConfigOptions | undefined, prefs: Record<string, unknown> | undefined, id: string): unknown {
+  if (prefs && id in prefs) return prefs[id];
+  return options?.find((o) => o.id === id)?.currentValue;
+}
+
+/** Option value → display name. */
+export function optionLabel(options: ConfigOptions | undefined, id: string, value: unknown): string | null {
+  const option = options?.find((o) => o.id === id);
+  const hit = option?.options?.find((o) => o.value === value);
+  return hit?.name ?? (typeof value === 'string' ? value : null);
+}
+
+/**
+ * The agent's current model and effort as a short phrase (for the composer button and the turn footer).
+ *
+ * Claude Code names its default model "Default (recommended)" and its default effort "Default"; shown as is, that
+ * truncates to "Default (recommended) Defa…" and says nothing. For the default, the model name from its
+ * description is used ("Opus (1M context)" → "Opus"), without the parenthesis; a default effort is left out.
+ */
+export function agentModelSummary(
+  options: ConfigOptions | undefined,
+  prefs: Record<string, unknown> | undefined,
+): { model: string | null; effort: string | null } {
+  const byCategory = (category: string) => options?.find((o) => o.category === category || o.id === category);
+  const modelOpt = byCategory('model');
+  const effortOpt = byCategory('thought_level');
+  let model: string | null = null;
+  if (modelOpt) {
+    const value = optionValue(options, prefs, modelOpt.id);
+    const choice = modelOpt.options?.find((o) => o.value === value);
+    const raw = value === 'default' && choice?.description ? choice.description : optionLabel(options, modelOpt.id, value);
+    model = raw ? (raw.split('·')[0]!.replace(/\s*\([^)]*\)/g, '').trim() || raw) : null;
+  }
+  const effortValue = effortOpt ? optionValue(options, prefs, effortOpt.id) : undefined;
+  const effort = effortOpt && effortValue !== 'default' ? optionLabel(options, effortOpt.id, effortValue) : null;
+  return { model, effort };
+}