dsh-cursor-dev 0.0.0-stage → 0.11.0

package/lib/models.js

@@ -0,0 +1,314 @@
+/**
+ * The one place that knows how a Cursor model choice is named.
+ *
+ * There are two name spaces in play, and mixing them is what made every model
+ * switch fail:
+ *
+ * 1. The CLI's own listing (`cursor-agent --list-models`) answers with SHORT
+ *    ALIASES — `auto`, `composer-2.5`, `composer-2.5-fast`, `glm-5.2-high`.
+ *    This is what the panel stores and what a caller writes by hand.
+ * 2. The ACP session roster answers with PARAMETERISED IDS — the alias, its
+ *    variant options in brackets, and the empty option set spelled `[]`:
+ *    `default[]`, `composer-2.5[fast=true]`, `kimi-k3[reasoning=max]`.
+ *    `session/set_config_option` accepts ONLY these; sending the alias is
+ *    rejected with `-32602 Invalid params: Invalid model value: auto`.
+ *
+ * So a choice is normalized (alias → the id the protocol speaks) before it is
+ * handed to the CLI, and resolved against the live roster so a name the account
+ * cannot use is reported before the child is touched.
+ *
+ * Only ACP's `session/set_config_option` takes these names. The `--model` SPAWN
+ * flag is the CLI's own option parser, which wants the bare alias without the
+ * bracket suffix — use {@link cliModelArg} for that.
+ */
+
+/** Fallback shown when a name cannot be resolved and no roster is known. */
+export const ALLOWED_FALLBACK_MODEL = 'default[]';
+
+/**
+ * The bare name part of a model id, e.g. `composer-2.5[fast=true]` → `composer-2.5`.
+ * @param value - any candidate id.
+ */
+export function baseName(value) {
+    if (typeof value !== 'string')
+        return '';
+    const trimmed = value.trim();
+    const bracket = trimmed.indexOf('[');
+    return (bracket === -1 ? trimmed : trimmed.slice(0, bracket)).trim();
+}
+
+/**
+ * Normalize a model choice into the id the ACP `model` config option speaks.
+ *
+ * `auto` and the empty string mean "whatever the CLI defaults to", which the
+ * roster spells `default[]` — an id no listing ever prints, so it is mapped
+ * here rather than looked up.
+ *
+ * @param value - a panel value, a caller-supplied id, or a configured default.
+ */
+export function normalizeModelId(value) {
+    if (typeof value !== 'string')
+        return '';
+    const trimmed = value.trim();
+    if (trimmed === '' || trimmed.toLowerCase() === 'auto')
+        return ALLOWED_FALLBACK_MODEL;
+    return trimmed;
+}
+
+/**
+ * The value for the `--model` SPAWN flag, or `''` to omit the flag.
+ *
+ * The spawn flag takes the alias the CLI itself lists; the bracket suffix and
+ * the protocol-only `default[]` alias are both meaningless to it, and the flag
+ * is only a startup preference anyway (the session roster decides what a
+ * `set_config_option` will accept).
+ *
+ * @param value - a panel value, a caller-supplied id, or a configured default.
+ */
+export function cliModelArg(value) {
+    if (typeof value !== 'string')
+        return '';
+    const trimmed = value.trim();
+    const name = baseName(trimmed);
+    if (name === '' || name === 'default' || name.toLowerCase() === 'auto')
+        return '';
+    return name;
+}
+
+/**
+ * Turn the ACP `configOptions` array into the roster shape the pool already
+ * reads (`{currentModelId, availableModels: [{modelId, name}]}`).
+ *
+ * A CLI build that reports models in the legacy `models` shape instead of
+ * `configOptions` keeps working: both are reduced to this one shape.
+ *
+ * @param configOptions - the `configOptions` array of a `session/new` or
+ *   `session/load` response, or of a `config_option_update` notification.
+ * @param current - the id to report as current when the option does not carry one.
+ * @returns the roster, or `undefined` when nothing usable was found.
+ */
+export function rosterFromConfigOptions(configOptions, current) {
+    if (!Array.isArray(configOptions))
+        return undefined;
+    const option = configOptions.find(entry => entry !== null && typeof entry === 'object' && entry.id === 'model');
+    if (option === undefined)
+        return undefined;
+    const available = Array.isArray(option.options)
+        ? option.options
+            .filter(entry => entry !== null && typeof entry === 'object' && typeof entry.value === 'string' && entry.value !== '')
+            .map(entry => ({
+                modelId: entry.value,
+                name: typeof entry.name === 'string' && entry.name !== '' ? entry.name : entry.value,
+            }))
+        : [];
+    const currentModelId = typeof option.currentValue === 'string' && option.currentValue !== ''
+        ? option.currentValue
+        : (typeof current === 'string' ? current : undefined);
+    if (available.length === 0 && currentModelId === undefined)
+        return undefined;
+    return {
+        ...(currentModelId === undefined ? {} : { currentModelId }),
+        ...(available.length === 0 ? {} : { availableModels: available }),
+    };
+}
+
+/**
+ * Fold any roster shape (legacy `models`, ACP `configOptions`) into one shape.
+ *
+ * @param session - a `session/new` / `session/load` response or a pool record.
+ * @param fallbackCurrent - id to keep as current when the response omits one.
+ */
+export function rosterFromSession(session, fallbackCurrent) {
+    if (session === null || typeof session !== 'object')
+        return undefined;
+    const fromConfig = rosterFromConfigOptions(session.configOptions, fallbackCurrent);
+    const legacy = session.models;
+    if (legacy === null || typeof legacy !== 'object') {
+        return fromConfig;
+    }
+    const current = typeof legacy.currentModelId === 'string' && legacy.currentModelId !== ''
+        ? legacy.currentModelId
+        : (fromConfig?.currentModelId ?? fallbackCurrent);
+    const fromLegacy = Array.isArray(legacy.availableModels)
+        ? legacy.availableModels
+            .filter(entry => entry !== null && typeof entry === 'object' && typeof entry.modelId === 'string' && entry.modelId !== '')
+            .map(entry => ({
+                modelId: entry.modelId,
+                name: typeof entry.name === 'string' && entry.name !== '' ? entry.name : entry.modelId,
+            }))
+        : [];
+    const available = fromLegacy.length > 0 ? fromLegacy : (fromConfig?.availableModels ?? []);
+    if (current === undefined && available.length === 0)
+        return fromConfig;
+    return {
+        ...(current === undefined ? {} : { currentModelId: current }),
+        ...(available.length === 0 ? {} : { availableModels: available }),
+    };
+}
+
+/** The available ids of a roster, in roster order. */
+function availableIds(roster) {
+    const list = roster?.availableModels;
+    return Array.isArray(list) ? list.map(entry => entry.modelId).filter(id => typeof id === 'string') : [];
+}
+
+/**
+ * Find the id a roster would accept for a requested choice.
+ *
+ * @param modelId - the requested choice (alias, parameterised id, or empty).
+ * @param roster - `{currentModelId, availableModels}`, or `undefined` when the
+ *   build does not report a roster at all.
+ * @returns `{ok: true, id, exact, aliased, listed}` with the id to send, or
+ *   `{ok: false, error, id}` where `id` is the never-listed fallback. `listed`
+ *   is FALSE only for the no-roster branch below, where the returned `id` is
+ *   the requested name rather than an id the roster accepts — a caller that
+ *   compares ids (rather than sending one) must not read those as a match.
+ */
+export function resolveModelId(modelId, roster) {
+    const wanted = normalizeModelId(modelId);
+    const available = availableIds(roster);
+    if (available.length === 0) {
+        // No roster to check against: the normalized name is the best guess a
+        // caller can make, and the CLI's own rejection carries the real message.
+        return { ok: true, id: wanted, exact: true, aliased: false, listed: false };
+    }
+    if (available.includes(wanted))
+        return { ok: true, id: wanted, exact: true, aliased: false, listed: true };
+
+    const name = baseName(wanted);
+    const byName = available.find(id => baseName(id) === name);
+    if (byName !== undefined)
+        return { ok: true, id: byName, exact: false, aliased: false, listed: true };
+
+    // The CLI's own listing prefixes its aliases with the workspace vendor
+    // (`cursor-grok-4.5-high`) while the session roster publishes the bare family
+    // (`grok-4.5[…]`). The prefix is dropped for FAMILY MATCHING ONLY: an exact
+    // id is matched verbatim above, so a build that really offers `cursor-…` ids
+    // is unaffected, and the id handed back is always a roster id. Both spellings
+    // are searched, the roster's own first, so a forked build that publishes
+    // `cursor-foo` is matched before its bare `foo` is considered.
+    const stripped = name.toLowerCase().startsWith('cursor-') ? name.slice('cursor-'.length) : name;
+    const familyNames = stripped === name ? [name] : [name, stripped];
+
+    // A short alias whose variants are all fully parameterised in the roster.
+    // This CLI lists `grok-4.7-xhigh` and `glm-5.2-high` while its session
+    // roster offers `grok-4.7[context=256k,…,fast=true]` and
+    // `glm-5.2[reasoning=high]` — the alias names a variant the roster spells
+    // with brackets, so the two name spaces only meet through the alias's
+    // family name (`grok-4.7`). Ambiguity is resolved by the roster's own order
+    // (its first entry is the vendor's recommendation) and two candidate
+    // families are never guessed between.
+    //
+    // Only VERSIONED families are tried. A family that has collapsed all the
+    // way to the bare vendor (`grok-4.6-xhigh` → `grok`) would match any model
+    // of that vendor, quietly turning an alias this account does not offer into
+    // one it does; requiring the version segment keeps the match honest.
+    const families = familyNames
+        .flatMap(familyName => familiesOf(familyName))
+        .filter(family => /\d/.test(family));
+
+    for (const family of families) {
+        const under = available.filter(id => id.toLowerCase().startsWith(`${family}[`));
+        if (under.length > 0)
+            return { ok: true, id: under[0], exact: false, aliased: true, listed: true };
+    }
+
+    for (const family of families) {
+        const dashed = available.filter(id => baseName(id).toLowerCase().startsWith(`${family}-`));
+        if (dashed.length === 1)
+            return { ok: true, id: dashed[0], exact: false, aliased: true, listed: true };
+    }
+
+    return {
+        ok: false,
+        id: wanted,
+        error: `model "${modelId}" is not offered by this Cursor account; available: ${shortList(available)}`,
+    };
+}
+
+/**
+ * The progressively shorter family names of a CLI alias.
+ *
+ * `grok-4.7-xhigh` → `['grok-4.7-xhigh', 'grok-4.7']`, so a roster entry named
+ * `grok-4.7[…]` can still be found by the alias that pins one of its variants.
+ *
+ * The walk stops once the next candidate would drop the version: collapsing
+ * past `grok-4.7` to `grok` would let an unrelated alias (`cursor-grok-9.9-x`)
+ * match this account's `grok-4.7` through nothing but the shared vendor name.
+ *
+ * @param name - a bare model name.
+ */
+function familiesOf(name) {
+    if (name === '')
+        return [];
+    const families = [name];
+    let candidate = name;
+    for (let index = candidate.lastIndexOf('-'); index > 0; index = candidate.lastIndexOf('-')) {
+        candidate = candidate.slice(0, index);
+        if (/^\d/.test(candidate))
+            break;
+        families.push(candidate);
+    }
+    return families;
+}
+
+/**
+ * Resolve a choice against a roster, returning the flat pieces a caller needs.
+ *
+ * @param modelId - the requested choice.
+ * @param roster - the session roster, or `undefined`.
+ */
+export function resolveModel(modelId, roster) {
+    if (typeof modelId !== 'string' || modelId.trim() === '')
+        return { id: '', ok: true, exact: true, aliased: false };
+    const resolved = resolveModelId(modelId, roster);
+    return {
+        id: resolved.id,
+        ok: resolved.ok,
+        exact: resolved.exact,
+        aliased: resolved.aliased,
+        listed: resolved.listed === true,
+        ...(resolved.error === undefined ? {} : { error: resolved.error }),
+    };
+}
+
+/** Whether two choices name the same model, ignoring alias spelling. */
+export function sameModel(left, right) {
+    // An absent choice is not a model: `undefined` (no choice) and `''` (an
+    // empty choice) are the same non-decision, but neither equals a real model.
+    if (!isChoice(left) || !isChoice(right))
+        return !isChoice(left) && !isChoice(right);
+    const a = normalizeModelId(left);
+    const b = normalizeModelId(right);
+    if (a === b)
+        return true;
+    return baseName(a).toLowerCase() === baseName(b).toLowerCase();
+}
+
+/** Whether a value names a model at all (as opposed to no choice). */
+function isChoice(value) {
+    return typeof value === 'string' && value.trim() !== '';
+}
+
+/**
+ * The panel-facing list of a roster, so an unpublished option can be shown as
+ * unavailable instead of failing a whole run.
+ *
+ * @param roster - the session roster.
+ */
+export function listRosterModels(roster) {
+    const available = availableIds(roster);
+    const current = roster?.currentModelId;
+    return available.map(id => ({
+        id,
+        name: id === ALLOWED_FALLBACK_MODEL ? 'Auto' : baseName(id),
+        current: id === current,
+        isDefault: id === ALLOWED_FALLBACK_MODEL,
+    }));
+}
+
+/** A comma-separated, bounded rendering of an id list for an error message. */
+function shortList(ids) {
+    const head = ids.slice(0, 8).join(', ');
+    return ids.length > 8 ? `${head}, … (${ids.length} total)` : head;
+}

package/lib/native-provider.js

@@ -0,0 +1,224 @@
+/** Native DSH provider and the cursor_code adapter. The Cursor pool owns idle
+ * processes; each published run owns its cancellation and mirrored child lease. */
+import { randomUUID } from 'node:crypto';
+import { isAbsolute } from 'node:path';
+import { stat } from 'node:fs/promises';
+import { renderCursorReport } from './tool.js';
+import { resolveChildDepth } from './mirror.js';
+
+export const CURSOR_PROVIDER = 'cursor';
+
+export function cursorStopReason(reason, aborted = false) {
+    if (aborted) return 'aborted';
+    switch (reason) {
+        case 'end_turn': return 'completed';
+        case 'cancelled': return 'aborted';
+        case 'max_tokens': return 'max-tokens';
+        case 'refusal': return 'refusal';
+        default: return 'error';
+    }
+}
+
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
+    return { promise, resolve, reject };
+}
+
+function failure(error, cancelled = false) {
+    return { ok: false, sessionKey: 'native-start', stopReason: cancelled ? 'cancelled' : 'error',
+        durationMs: 0, error: error instanceof Error ? error.message : String(error), steps: [], changes: [] };
+}
+
+/** Generic native calls use the panel settings and get their own conversation.
+ * The cursor_code adapter supplies provider-private arguments for rich controls. */
+export function createCursorProvider({ execute, mirrors, maxChildDepth }) {
+    const active = new Set();
+    let closed = false;
+    return {
+        name: CURSOR_PROVIDER,
+        inheritsParentContext: false,
+        capabilities: Object.freeze({ agentOptions: false, outputSchema: false, depthLimit: false }),
+        async start(request) {
+            if (closed) throw new Error('cursor: provider is unloading');
+            request.signal?.throwIfAborted();
+            for (const key of ['agentOptions', 'outputSchema', 'maxDepth', 'toolFilter', 'persona']) {
+                if (request[key] !== undefined)
+                    throw new Error(`cursor: unsupported native capability ${key}`);
+            }
+            if (!Array.isArray(request.prompt) || request.prompt.length === 0
+                || request.prompt.some(block => block?.type !== 'text' || typeof block.text !== 'string'))
+                throw new Error('cursor: native prompts must contain text blocks only');
+            const task = request.prompt.map(block => block.text).join('\n\n').trim();
+            if (!task) throw new Error('cursor: native prompt must not be empty');
+            const originalParent = request.parent;
+            // The recursion budget is the plugin's own now that the host leaves it
+            // to the provider (`maxDepth: provider-managed`); refuse before any
+            // process, child row, or lifecycle event exists.
+            if (typeof maxChildDepth === 'number') resolveChildDepth(originalParent, maxChildDepth);
+            // dsh >= 0.2.1 starts native providers through the subagents service.
+            // That service only accepts an unregistered child id and models such a
+            // child as an external row without a local transcript, so the mirror
+            // belongs to the cursor_code bridge, which starts the provider directly.
+            const viaService = request.cursor === undefined;
+            const args = request.cursor?.args ?? { task, sessionLabel: `native-${randomUUID()}` };
+            const requestedCwd = typeof request.cwd === 'string' && request.cwd !== ''
+                ? request.cwd : args.workspaceRoot;
+            const cwd = typeof requestedCwd === 'string' && requestedCwd.trim() !== ''
+                ? requestedCwd.trim() : originalParent?.session?.header?.cwd;
+            if (typeof cwd !== 'string' || !isAbsolute(cwd) || !(await stat(cwd)).isDirectory())
+                throw new Error('cursor: an accessible absolute parent workspace is required');
+            request.signal?.throwIfAborted();
+            if (closed) throw new Error('cursor: provider is unloading');
+
+            const abort = new AbortController();
+            const onAbort = () => abort.abort(request.signal?.reason);
+            request.signal?.addEventListener('abort', onAbort, { once: true });
+            if (request.signal?.aborted) onAbort();
+            const ready = deferred();
+            let opened;
+            let leasedSession;
+            let settled = false;
+            let disposal;
+            const cursorLifecycle = {
+                descriptor: request.descriptor,
+                label: request.label,
+                acquired(session) { leasedSession = session; },
+                ...(viaService ? { mirror: false } : {
+                    opened(entry, key) {
+                        opened = { entry, key };
+                        ready.resolve();
+                    },
+                }),
+            };
+            const execution = Promise.resolve().then(() => execute({ ...args, workspaceRoot: cwd }, {
+                agent: originalParent,
+                signal: abort.signal,
+                cursorLifecycle,
+            })).catch(error => failure(error, abort.signal.aborted));
+            const cursorReport = execution.then(report => {
+                settled = true;
+                request.signal?.removeEventListener('abort', onAbort);
+                if (!viaService && opened === undefined)
+                    ready.reject(new Error(report.error ?? 'cursor: no child agent was created'));
+                return report;
+            });
+            const result = cursorReport.then(report => {
+                const stopReason = cursorStopReason(report.stopReason, abort.signal.aborted);
+                return {
+                    output: renderCursorReport(report),
+                    stopReason,
+                    ...(stopReason === 'error' || (report.error && stopReason !== 'aborted')
+                        ? { diagnostic: String(report.error ?? `Cursor stopped: ${report.stopReason ?? 'unknown'}`).slice(0, 1000) } : {}),
+                };
+            });
+            const dispose = () => disposal ??= (async () => {
+                if (!settled) abort.abort();
+                await cursorReport;
+                try {
+                    if (abort.signal.aborted) await leasedSession?.disposeAndWait();
+                }
+                finally {
+                    if (opened !== undefined)
+                        await mirrors.release(opened.key, { entry: opened.entry, strict: true });
+                }
+            })().finally(() => active.delete(dispose));
+            active.add(dispose);
+            // The service owns the child row for external runs; hand it a fresh id
+            // and let it observe `result`, without waiting for a mirror child.
+            if (viaService)
+                return { id: `cursor-${randomUUID()}`, result, cursorReport, dispose };
+            try {
+                await ready.promise;
+                announceMirror(originalParent, opened.entry.child, request.label);
+            }
+            catch (error) {
+                try { await dispose(); }
+                catch (cleanupError) {
+                    throw new AggregateError([error, cleanupError], `${String(error)}; Cursor cleanup failed: ${String(cleanupError)}`);
+                }
+                throw error;
+            }
+            return { id: opened.entry.child.id ?? opened.entry.child.session.header.id,
+                localAgent: undefined, result, cursorReport, dispose };
+        },
+        async dispose() {
+            closed = true;
+            const outcomes = await Promise.allSettled([...active].map(dispose => dispose()));
+            const errors = outcomes.filter(outcome => outcome.status === 'rejected').map(outcome => outcome.reason);
+            if (errors.length) throw new AggregateError(errors, 'cursor: native run disposal failed');
+        },
+    };
+}
+
+/** Cursor executes out of process; the local child is its transcript mirror.
+ * The provider owns mirror discovery so continuation has one catalog row. Never
+ * proxy the parent: DSH scopeTarget routes events by exact object identity. */
+function announceMirror(parent, child, label) {
+    const session = parent.session;
+    const header = child.session.header;
+    const exists = session.snapshotEvents?.().some(event => event.type === 'subagent/catalog'
+        && event.data?.childId === header.id && event.data?.mode === 'one-shot');
+    if (exists) return;
+    session.append('subagent/catalog', {
+        version: 0, childId: header.id, childCreatedAt: header.createdAt, mode: 'one-shot',
+        ...(label === undefined ? {} : { label }),
+    });
+}
+
+/** Late-bound native service; absence preserves the existing standalone tool. */
+export function createNativeCursorBridge({ execute, mirrors, maxChildDepth }) {
+    let binding;
+    return {
+        bind(ctx) {
+            const runtime = ctx.get?.('subagents');
+            if (typeof runtime?.registerProvider !== 'function') return;
+            const provider = createCursorProvider({ execute, mirrors, maxChildDepth });
+            const unregister = runtime.registerProvider(provider);
+            const current = { runtime, provider };
+            binding = current;
+            ctx.effect(() => async () => {
+                if (binding === current) binding = undefined;
+                unregister?.();
+                await provider.dispose();
+            });
+        },
+        async execute(args, exec) {
+            const current = binding;
+            if (current === undefined) return execute(args, exec);
+            let run;
+            let report;
+            try {
+                // dsh >= 0.2.1 moved creation to `startActivation` on the service,
+                // which only models external children; the bridge owns its mirrored
+                // child instead, so it starts the provider directly.
+                run = await current.provider.start({
+                    parent: exec.agent,
+                    prompt: [{ type: 'text', text: typeof args?.task === 'string' ? args.task : '' }],
+                    label: args?.sessionLabel || 'Cursor',
+                    signal: exec.signal,
+                    cursor: { args },
+                });
+                await run.result;
+                report = await run.cursorReport;
+            }
+            catch (error) {
+                report = failure(error, exec.signal?.aborted);
+            }
+            try {
+                await run?.dispose();
+            }
+            catch (error) {
+                report = { ...report, ok: false, stopReason: 'error',
+                    error: `${report.error ? `${report.error}; ` : ''}Cursor cleanup failed: ${String(error)}` };
+            }
+            return report;
+        },
+        async dispose() {
+            const current = binding;
+            binding = undefined;
+            await current?.provider.dispose();
+        },
+    };
+}

package/lib/prompt.js

@@ -0,0 +1,59 @@
+/**
+ * Prompt composition for a Cursor turn.
+ *
+ * The parent model writes the task; this module adds only the scaffolding a
+ * coding subagent needs to work autonomously — the workspace it is bound to, a
+ * nudge toward its real tools, and the rule that it must finish rather than ask
+ * questions (there is no human on the child's end of the pipe).
+ *
+ * Deliberately NOT done here: no persona override, no hidden system prompt. The
+ * parent's task text is passed through verbatim so the parent stays in control
+ * of what the child does.
+ */
+
+/**
+ * Build the prompt sent to the Cursor child.
+ *
+ * @param task - the parent-authored task text (verbatim).
+ * @param options - workspace and context attachments.
+ */
+export function buildPrompt(task, options) {
+    const parts = [];
+    parts.push(`You are working in this workspace: ${options.cwd}`);
+    parts.push('');
+    parts.push('## Task');
+    parts.push(task.trim());
+
+    if (options.acceptance !== undefined && options.acceptance.trim() !== '') {
+        parts.push('');
+        parts.push('## Acceptance criteria');
+        parts.push(options.acceptance.trim());
+    }
+
+    if (options.contextFiles !== undefined && options.contextFiles.length > 0) {
+        parts.push('');
+        parts.push('## Files to read first');
+        for (const path of options.contextFiles)
+            parts.push(`- ${path}`);
+    }
+
+    parts.push('');
+    parts.push('## How to work');
+    parts.push('- Use your own file-editing and shell tools to make the changes on disk. Do not just describe them.');
+    parts.push('- Read the surrounding code before editing so the change matches local conventions.');
+    parts.push('- You cannot ask questions: nobody is available to answer. Make the most reasonable choice, do the work, and state any assumption in your final message.');
+    parts.push('- When you are done, reply with a concise report: what you changed (file paths), what you verified, and anything left undone.');
+
+    return parts.join('\n');
+}
+
+/**
+ * One-line label for the child run, used in status output.
+ *
+ * @param task - parent task text.
+ * @param maxLength - truncation length.
+ */
+export function summarizeTask(task, maxLength = 60) {
+    const flat = task.replace(/\s+/g, ' ').trim();
+    return flat.length <= maxLength ? flat : `${flat.slice(0, maxLength - 1)}…`;
+}