@onefl666/dsh-great-plan 0.5.0 → 0.6.0

package/{client.preset.js → lib/client.preset.js}

@@ -6,18 +6,11 @@ window.__ModuleLoader__.load({
     const h = React.createElement;
     const ui = require('@onefl666/dsh-great-plan/client.ui.js');
 
-    const BUILTIN_NAMES = {
-      standard: 'preset.standard',
-      ptc: 'preset.ptc',
-      minimal: 'preset.minimal',
-      cordis: 'preset.cordis',
-    };
-
-    const BUILTIN_DESCRIPTIONS = {
-      standard: 'preset.standardDescription',
-      ptc: 'preset.ptcDescription',
-      minimal: 'preset.minimalDescription',
-      cordis: 'preset.cordisDescription',
+    const BUILTINS = {
+      standard: { name: 'preset.standard', description: 'preset.standardDescription' },
+      ptc: { name: 'preset.ptc', description: 'preset.ptcDescription' },
+      minimal: { name: 'preset.minimal', description: 'preset.minimalDescription' },
+      cordis: { name: 'preset.cordis', description: 'preset.cordisDescription' },
     };
 
     function createPresetStore(ctx) {
@@ -64,19 +57,15 @@ window.__ModuleLoader__.load({
       return { store, load };
     }
 
-    function usePresetState(store) {
-      return ui.useStore(store);
-    }
-
     function presetDisplay(option, t) {
       if (option?.name !== undefined && option.name !== '') return option.name;
-      const key = option === undefined ? undefined : BUILTIN_NAMES[option.id];
+      const key = option === undefined ? undefined : BUILTINS[option.id]?.name;
       return key === undefined ? (option?.id ?? '') : t(key);
     }
 
     function presetDescription(option, t) {
       if (option?.description !== undefined && option.description !== '') return option.description;
-      const key = option === undefined ? undefined : BUILTIN_DESCRIPTIONS[option.id];
+      const key = option === undefined ? undefined : BUILTINS[option.id]?.description;
       return key === undefined ? undefined : t(key);
     }
 
@@ -117,7 +106,6 @@ window.__ModuleLoader__.load({
 
     return {
       createPresetStore,
-      usePresetState,
       presetDisplay,
       presetDescription,
       defaultPresetId,

package/{client.settings.js → lib/client.settings.js}

@@ -14,7 +14,6 @@ window.__ModuleLoader__.load({
       minimalContext: 'includeMinimalRuntimeContext',
     };
 
-    /** Settings rows, in display order. */
     const ROWS = [
       { field: FIELDS.brainstorming, title: 'settings.brainstorm.title', description: 'settings.brainstorm.description' },
       { field: FIELDS.budget, title: 'settings.budget.title', description: 'settings.budget.description' },
@@ -27,26 +26,6 @@ window.__ModuleLoader__.load({
       return snapshot?.value?.[field] !== false;
     }
 
-    /** Read the brainstorming switch value from a configuration form snapshot. */
-    function readBrainstormingValue(snapshot) {
-      return readSwitchValue(snapshot, FIELDS.brainstorming);
-    }
-
-    /** Read the unlimited-budget switch value from a configuration form snapshot. */
-    function readBudgetValue(snapshot) {
-      return readSwitchValue(snapshot, FIELDS.budget);
-    }
-
-    /** Read the original-instruction switch value from a configuration form snapshot. */
-    function readOriginalInstructionsValue(snapshot) {
-      return readSwitchValue(snapshot, FIELDS.originalInstructions);
-    }
-
-    /** Read the minimal-runtime-context switch value from a configuration form snapshot. */
-    function readMinimalContextValue(snapshot) {
-      return readSwitchValue(snapshot, FIELDS.minimalContext);
-    }
-
     /** Read the shared settings form snapshot, or undefined when the capability is unavailable. */
     function readFormSnapshot(configForms) {
       if (configForms === undefined || configForms === null || typeof configForms.get !== 'function') return undefined;
@@ -55,36 +34,6 @@ window.__ModuleLoader__.load({
       return form.getSnapshot();
     }
 
-    /**
-     * Read one switch through the shared configuration mirror.
-     *
-     * A missing settings capability, an unreadable form, or an unready snapshot
-     * keeps the Host default (enabled) so execution never fails because of
-     * configuration.
-     */
-    function readSwitch(configForms, field) {
-      try {
-        return readSwitchValue(readFormSnapshot(configForms), field);
-      } catch {
-        return true;
-      }
-    }
-
-    /** Read the unlimited-budget switch; defaults to enabled. */
-    function readBudgetSwitch(configForms) {
-      return readSwitch(configForms, FIELDS.budget);
-    }
-
-    /** Read the original-instruction switch; defaults to enabled. */
-    function readOriginalInstructionsSwitch(configForms) {
-      return readSwitch(configForms, FIELDS.originalInstructions);
-    }
-
-    /** Read the minimal-runtime-context switch; defaults to enabled. */
-    function readMinimalContextSwitch(configForms) {
-      return readSwitch(configForms, FIELDS.minimalContext);
-    }
-
     /**
      * Read every fresh-session prompt switch from one snapshot.
      *
@@ -96,9 +45,9 @@ window.__ModuleLoader__.load({
       try {
         const snapshot = readFormSnapshot(configForms);
         return {
-          unlimitedBudget: readBudgetValue(snapshot),
-          includeOriginalInstructions: readOriginalInstructionsValue(snapshot),
-          includeMinimalContext: readMinimalContextValue(snapshot),
+          unlimitedBudget: readSwitchValue(snapshot, FIELDS.budget),
+          includeOriginalInstructions: readSwitchValue(snapshot, FIELDS.originalInstructions),
+          includeMinimalContext: readSwitchValue(snapshot, FIELDS.minimalContext),
         };
       } catch {
         return { unlimitedBudget: true, includeOriginalInstructions: true, includeMinimalContext: true };
@@ -211,13 +160,6 @@ window.__ModuleLoader__.load({
       FIELDS,
       ROWS,
       readSwitchValue,
-      readBrainstormingValue,
-      readBudgetValue,
-      readOriginalInstructionsValue,
-      readMinimalContextValue,
-      readBudgetSwitch,
-      readOriginalInstructionsSwitch,
-      readMinimalContextSwitch,
       readFreshPromptSwitches,
       GreatPlanSection,
       GreatPlanForm,

package/{client.ui.js → lib/client.ui.js}

@@ -323,7 +323,6 @@ window.__ModuleLoader__.load({
       },
       h('input', {
         type: 'checkbox',
-        className: 'gp-check-input',
         checked: checked === true,
         disabled,
         onChange: (event) => {
@@ -331,7 +330,7 @@ window.__ModuleLoader__.load({
         },
       }),
       h('span', { className: 'gp-check-copy' },
-        h('span', { className: 'gp-check-label' }, label),
+        h('span', null, label),
         hint === undefined || hint === null ? null : h('span', { className: 'gp-check-hint' }, hint),
       ),
       );
@@ -406,7 +405,6 @@ window.__ModuleLoader__.load({
       }, [open, anchorRef, panelRef, setPosition]);
     }
 
-    /** Collect the panel's focusable elements in DOM order. */
     function focusableIn(panel) {
       if (panel === null || panel === undefined || typeof panel.querySelectorAll !== 'function') return [];
       return [...panel.querySelectorAll('button:not([disabled]),input:not([disabled]),textarea:not([disabled]),[tabindex]:not([tabindex="-1"])')]
@@ -504,15 +502,12 @@ window.__ModuleLoader__.load({
       useStore,
       createStore,
       IconSliders,
-      IconChevronRight,
       IconChevronDown,
       IconChevronLeft,
       IconClose,
-      IconCheck,
       IconPlay,
       IconCompress,
       IconNewSession,
-      IconWarning,
       IconButton,
       Button,
       ActionRow,
@@ -526,7 +521,6 @@ window.__ModuleLoader__.load({
       WarningText,
       WarningBox,
       Loading,
-      focusableIn,
       handleDialogKeyDown,
       Dialog,
     };

package/{host → lib/host}/apply.js

@@ -5,7 +5,8 @@ export function apply(ctx, config) {
   ctx.inject(['commands'], (scope) => {
     return scope.commands.register(createCompactCommand({
       getProjections: () => ctx.get('sessionProjections'),
-      getCompaction: () => ctx.get('compaction'),
+      getCompaction: (agent) => ctx.get('compaction'),
+      getAgentPresets: () => ctx.get('agentPresets'),
       getBalancedAfter: async () => (await import('@deepseek-ai/dsh-compaction')).toolPairingBalancedAfter,
     }));
   });

package/{host → lib/host}/plan-compaction.js

@@ -1,7 +1,7 @@
-import { selectPlanCompactionRange } from './plan-range.js';
+import { EXIT_PLAN_MODE_TOOL, selectPlanCompactionRange } from './plan-range.js';
 
-/** The plan-review tool call that marks the pending plan review surface node. */
-export const EXIT_PLAN_MODE_TOOL = 'exit_plan_mode';
+// The canonical name lives in plan-range.js; re-exported for existing importers.
+export { EXIT_PLAN_MODE_TOOL };
 
 /** The command accepts no arguments; this is its user-visible usage line. */
 export const USAGE = 'Usage: /great-plan-compact (no arguments)';
@@ -38,20 +38,59 @@ function messageOf(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-export function createCompactCommand({ getProjections, getCompaction, getBalancedAfter }) {
+/**
+ * Resolve the composed compaction service for one agent.
+ *
+ * Presets isolate their mounted services, so the agent's preset group owns its
+ * `compaction` instance while the host-plane read only sees globally mounted
+ * compositions. The agent-scoped context is the middle step; the preset
+ * registry is the authoritative source when it exposes the service.
+ *
+ * @param {object | undefined} agent the agent executing the command.
+ * @param {object} [accessors] service readers supplied by the composition.
+ * @param {() => object | undefined} [accessors.getAgentPresets] host-plane preset registry reader.
+ * @param {(agent: object | undefined) => object | undefined} [accessors.getCompaction] host-plane compaction reader.
+ * @returns {object | undefined} the first service that exposes `compactRegion`.
+ */
+export function resolveCompactionService(agent, { getAgentPresets, getCompaction } = {}) {
+  if (agent !== undefined && agent !== null) {
+    // 1. The service mounted in the agent's preset group.
+    try {
+      const scoped = typeof getAgentPresets === 'function'
+        ? getAgentPresets()?.serviceFor?.(agent, 'compaction')
+        : undefined;
+      if (scoped?.compactRegion !== undefined) return scoped;
+    } catch {
+      // An absent or unreadable preset registry falls through.
+    }
+    // 2. The service mounted in the agent's scoped context.
+    try {
+      const scoped = agent?.ctx?.get?.('compaction');
+      if (scoped?.compactRegion !== undefined) return scoped;
+    } catch {
+      // An unreadable scoped context falls through.
+    }
+  }
+  // 3. The host-plane service; a throwing read stays visible to the caller.
+  const fallback = typeof getCompaction === 'function' ? getCompaction(agent) : undefined;
+  return fallback?.compactRegion !== undefined ? fallback : undefined;
+}
+
+export function createCompactCommand({ getProjections, getCompaction, getBalancedAfter, getAgentPresets }) {
   return {
     name: 'great-plan-compact',
     description: 'Compact older plan history before executing (used by Great Plan).',
     async handler(invocation) {
-      const rawInput = typeof invocation?.rawInput === 'string' ? invocation.rawInput.trim() : '';
+      const args = invocation ?? {};
+      const rawInput = typeof args.rawInput === 'string' ? args.rawInput.trim() : '';
       if (rawInput !== '') return { kind: 'error', text: USAGE };
-      const { agent, signal } = invocation ?? {};
+      const { agent, signal } = args;
 
       let plan;
       try {
         const projections = getProjections();
-        if (projections?.stateOf === undefined) return { kind: 'error', text: MESSAGES.planStateUnavailable };
-        plan = projections.stateOf(agent.session, 'plan');
+        if (typeof projections?.snapshot !== 'function') return { kind: 'error', text: MESSAGES.planStateUnavailable };
+        plan = projections.snapshot(agent.session, ['plan'])?.values?.plan;
       } catch (error) {
         return { kind: 'error', text: `Plan state is unavailable: ${messageOf(error)}` };
       }
@@ -59,7 +98,7 @@ export function createCompactCommand({ getProjections, getCompaction, getBalance
 
       let compaction;
       try {
-        compaction = getCompaction();
+        compaction = resolveCompactionService(agent, { getAgentPresets, getCompaction });
       } catch (error) {
         return { kind: 'error', text: `Compaction is unavailable: ${messageOf(error)}` };
       }
@@ -89,7 +128,7 @@ export function createCompactCommand({ getProjections, getCompaction, getBalance
       } catch (error) {
         if (signal?.aborted) return { kind: 'error', text: FAILURES.cancelled };
         const code = typeof error?.code === 'string' ? error.code : undefined;
-        return { kind: 'error', text: (code !== undefined && FAILURES[code]) || messageOf(error) };
+        return { kind: 'error', text: Object.hasOwn(FAILURES, code) ? FAILURES[code] : messageOf(error) };
       }
     },
   };

package/lib/host/plan-evidence.js

@@ -0,0 +1,195 @@
+/**
+ * Evidence-first plan handoff prompt section.
+ *
+ * Plan mode already renders the deployment's native `plan:policy` guidance.
+ * This plugin adds one independent section immediately after it, asking the
+ * planner to hand over its investigation together with the plan. It also carries
+ * an optional unlimited-token-budget reminder and a brainstorming paragraph,
+ * each independently switchable from the Settings page. The native policy text
+ * is never replaced or duplicated.
+ */
+
+/** Prompt section name; unique in the global prompt layer. */
+export const PLAN_EVIDENCE_SECTION = 'great-plan:plan-evidence';
+
+/** Used when the instance cannot resolve the centrally owned PLAN_POLICY order. */
+export const PLAN_EVIDENCE_ORDER_FALLBACK = 501;
+
+/** Model-facing collaborative-discovery and Team-Lead guidance; the Settings page can switch it off. */
+export const PLAN_BRAINSTORMING_GUIDANCE = `Discovery and delegation:
+- Assess the goal, success criteria, constraints, and current state; do not quiz the user with a checklist.
+- If an answer could materially change scope or approach, ask one concise question per turn and wait. If the request is clear or the user delegates the choice, proceed.
+- You are the Team Lead. Use \`spawn_teammate\` to start at least 2 exploration teammates in parallel, each with one distinct, concrete scope, and require concise findings cited as path:line-range. Do not investigate their scopes yourself; collect all results and resolve conflicts.
+- Then spawn 1 separate planning teammate to draft a candidate plan from the consolidated evidence. Verify the evidence and the draft yourself before submitting.
+- If \`spawn_teammate\` is unavailable or fails, say so in the plan and continue alone; never invent teammate work.
+- Show alternatives and tradeoffs only when they help the user decide; state the key reason for your recommendation.
+- Separate user requirements from your recommendations, assumptions, and unverified points. Give a brief rationale, not step-by-step chain-of-thought.`;
+
+/** Model-facing unlimited-token-budget reminder; the Settings page can switch it off. */
+export const PLAN_UNLIMITED_BUDGET_GUIDANCE = 'Token budget: unlimited. Never cut investigation, tool calls, or needed questions to save tokens; keep the final plan concise.';
+
+/** Model-facing evidence and executor handoff guidance; always rendered in plan mode. */
+export const PLAN_HANDOFF_GUIDANCE = `Plan as handoff (the executor may get only this plan or a compacted history, so make it self-contained):
+- Background: request, current behavior, constraints, assumptions.
+- Evidence: files/symbols with line ranges (e.g. path/file.js:12-30), searches and commands with key results, docs/skills/URLs used, and how conflicts were resolved. Cite evidence for each design claim; mark anything unverified as an assumption or open question.
+- Handoff: what is settled and must not be re-investigated; which unknowns to verify first.
+Never present a guess as fact or invent paths, APIs, command output, or test results. Re-check citations before submitting. Keep evidence compact: precise pointers, not raw logs or whole files.`;
+
+/** Default guidance (every switch on) appended while plan mode is active. */
+export const PLAN_EVIDENCE_GUIDANCE = `${PLAN_UNLIMITED_BUDGET_GUIDANCE}\n\n${PLAN_BRAINSTORMING_GUIDANCE}\n\n${PLAN_HANDOFF_GUIDANCE}`;
+
+/**
+ * Compose the plan-mode guidance from its independently switchable parts.
+ *
+ * The budget reminder comes first as a general instruction, then the optional
+ * brainstorming guidance, and the evidence/handoff guidance always closes the
+ * section. Disabled parts are omitted entirely, never replaced by placeholders.
+ * With every switch on the precomputed `PLAN_EVIDENCE_GUIDANCE` constant is
+ * returned so the common path allocates nothing per prompt assembly.
+ */
+export function composePlanGuidance({ brainstorming = true, unlimitedBudget = true } = {}) {
+  if (brainstorming !== false && unlimitedBudget !== false) return PLAN_EVIDENCE_GUIDANCE;
+  const parts = [];
+  if (unlimitedBudget !== false) parts.push(PLAN_UNLIMITED_BUDGET_GUIDANCE);
+  if (brainstorming !== false) parts.push(PLAN_BRAINSTORMING_GUIDANCE);
+  parts.push(PLAN_HANDOFF_GUIDANCE);
+  return parts.join('\n\n');
+}
+
+/**
+ * Read one switch from the plugin config.
+ *
+ * A volatile field arrives as a reference object; plain booleans are accepted
+ * for tests and hand-written rows. Every missing, malformed, or unreadable
+ * value keeps the fallback so prompt assembly never fails.
+ */
+function readConfigSwitch(config, field, fallback) {
+  if (config === undefined || config === null || typeof config !== 'object') return fallback;
+  let value;
+  try {
+    value = config[field];
+  } catch {
+    return fallback;
+  }
+  if (value === undefined || value === null) return fallback;
+  if (typeof value === 'boolean') return value;
+  if (typeof value.get === 'function') {
+    try {
+      const live = value.get();
+      return typeof live === 'boolean' ? live : fallback;
+    } catch {
+      return fallback;
+    }
+  }
+  return fallback;
+}
+
+/** Read the brainstorming switch; defaults to enabled. */
+export function readBrainstormingEnabled(config) {
+  return readConfigSwitch(config, 'injectBrainstormingPrompt', true);
+}
+
+/** Read the unlimited-token-budget switch; defaults to enabled. */
+export function readUnlimitedBudgetEnabled(config) {
+  return readConfigSwitch(config, 'injectUnlimitedBudgetPrompt', true);
+}
+
+/**
+ * Resolve one boolean-validated plan-mode state from a planMode-like service.
+ *
+ * A usable state exposes a boolean `active`; a pending selection overrides the
+ * logged state. Missing, malformed, or throwing reads return `undefined` so the
+ * caller can try its next source.
+ */
+function readPlanModeState(readService, agent) {
+  try {
+    const service = readService();
+    if (service === undefined || service === null || typeof service.get !== 'function') return undefined;
+    const state = service.get(agent);
+    if (state !== undefined && state !== null && typeof state === 'object' && typeof state.active === 'boolean') {
+      return state.pending === undefined ? state.active : state.pending === true;
+    }
+  } catch {
+    return undefined;
+  }
+  return undefined;
+}
+
+/**
+ * Decide whether plan mode is active for the step being assembled.
+ *
+ * The Host plane cannot rely on its own `planMode` instance: agent presets
+ * commonly mount the plan-mode plugin in an isolated group, so the host-plane
+ * instance does not see the state that the preset drives. The agent's own
+ * scoped context (`agent.ctx`) carries the instance that owns the session's
+ * plan state and the pending selection's direction — the same data source the
+ * native `plan:policy` section reads. The host-plane instance is the fallback
+ * for compositions where plan mode is host-owned, and the shared `plan`
+ * session projection (the unit the compaction command also reads) is the final
+ * synchronous fallback. Every source degrades to inactive instead of throwing.
+ */
+export function readPlanModeActive(agent, getPlanMode, getSessionProjections) {
+  if (agent === undefined || agent === null) return false;
+  // 1. The agent-scoped planMode instance: `get()` returns the logged state
+  //    plus a pending selection whose boolean is the selected direction.
+  const scoped = readPlanModeState(() => agent.ctx?.get?.('planMode'), agent);
+  if (scoped !== undefined) return scoped;
+  // 2. The host-plane planMode instance.
+  const host = readPlanModeState(() => (typeof getPlanMode === 'function' ? getPlanMode() : undefined), agent);
+  if (host !== undefined) return host;
+  // 3. The shared `plan` projection's cropped view { active, pending }. The
+  //    pending direction is not exposed here, so a pending selection counts as
+  //    active; by assembly time the pre-step has already applied pending
+  //    selections, which makes this equivalent to the native section's gate.
+  try {
+    const projections = typeof getSessionProjections === 'function' ? getSessionProjections() : undefined;
+    const session = agent?.session;
+    if (projections !== undefined && projections !== null && session !== undefined && typeof projections.snapshot === 'function') {
+      const state = projections.snapshot(session, ['plan'])?.values?.plan;
+      if (state !== undefined && state !== null && typeof state === 'object' && typeof state.active === 'boolean') {
+        return state.active === true || state.pending === true;
+      }
+    }
+  } catch {
+    // No usable plan state anywhere; treat the step as outside plan mode.
+  }
+  return false;
+}
+
+/**
+ * Register the section right after the native plan policy.
+ *
+ * @param {object} options
+ * @param {object} options.systemPrompt the Host `systemPrompt` service.
+ * @param {() => object | undefined} options.getPlanMode optional host-plane `planMode` reader.
+ * @param {() => object | undefined} [options.getSessionProjections] optional projection service reader.
+ * @param {() => object | undefined} options.getConfig optional live plugin config reader.
+ */
+export function registerPlanEvidenceSection({ systemPrompt, getPlanMode, getSessionProjections, getConfig }) {
+  let order = PLAN_EVIDENCE_ORDER_FALLBACK;
+  try {
+    const resolved = typeof systemPrompt.getSectionOrder === 'function'
+      ? systemPrompt.getSectionOrder('PLAN_POLICY')
+      : undefined;
+    if (Number.isFinite(resolved)) order = resolved + 1;
+  } catch {
+    // Keep the fallback order; an unavailable central table must not break the plugin.
+  }
+  return systemPrompt.section({
+    name: PLAN_EVIDENCE_SECTION,
+    order,
+    text: (context) => {
+      let config;
+      try {
+        config = typeof getConfig === 'function' ? getConfig() : undefined;
+      } catch {
+        config = undefined;
+      }
+      if (!readPlanModeActive(context?.agent, getPlanMode, getSessionProjections)) return '';
+      return composePlanGuidance({
+        brainstorming: readBrainstormingEnabled(config),
+        unlimitedBudget: readUnlimitedBudgetEnabled(config),
+      });
+    },
+  });
+}

package/{host → lib/host}/plan-range.js

@@ -1,3 +1,6 @@
+/** The plan-review tool call that marks the pending plan review surface node. */
+export const EXIT_PLAN_MODE_TOOL = 'exit_plan_mode';
+
 /**
  * Pure plan-compaction range selection.
  *
@@ -7,9 +10,9 @@
  * node before that review, snapping backwards until the tool pairing holds.
  */
 export function selectPlanCompactionRange(session, balancedAfter, options = {}) {
-  const planReviewTool = typeof options?.planReviewTool === 'string'
+  const planReviewTool = typeof options.planReviewTool === 'string'
     ? options.planReviewTool
-    : 'exit_plan_mode';
+    : EXIT_PLAN_MODE_TOOL;
   const nodes = session.surface.nodes;
   if (nodes.length === 0) return { error: 'empty' };
   const last = session.eventAt(nodes[nodes.length - 1]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onefl666/dsh-great-plan",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "license": "MIT",
   "author": "onefl666",
   "keywords": [
@@ -24,20 +24,21 @@
     "url": "https://github.com/onefl666/dsh-great-plan/issues"
   },
   "type": "module",
+  "main": "lib/index.js",
   "description": "Choose the model and reasoning effort, then execute, compact-and-execute, or start fresh with a reviewed plan.",
   "icon": "./icon.svg",
   "exports": {
-    ".": "./index.js",
-    "./client": "./client.js",
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
     "./locale/*.json": "./locale/*.json",
     "./icon": "./icon.svg",
     "./package.json": "./package.json"
   },
   "files": [
-    "index.js",
-    "host/*.js",
-    "client.js",
-    "client.*.js",
+    "lib/index.js",
+    "lib/host/*.js",
+    "lib/client.js",
+    "lib/client.*.js",
     "cordis.patch.yml",
     "locale/*.json",
     "icon.svg",