pi-vault-mind 0.16.9 → 0.16.11

package/CHANGELOG.md

@@ -1,15 +1,35 @@
 # Changelog
 
-## 0.16.9 / 0.6.13 — 2026-07-19
+## 0.16.11 / 0.6.15 — 2026-07-20
 
 ### Fixed
 
-- **Setup Auto-start persistence.** The setup wizard now forwards its Auto-start choice to `POST /vm/setup`; the runtime persists it on `vaultMind.vaults.default` without overwriting existing vault configuration siblings.
-- **Vault Mind Settings pane utilization.** The plugin-owned Settings view now fills its available Obsidian settings pane rather than remaining constrained to an internal narrow column.
+- **Panel recovery after bridge startup.** A later panel reconciliation now rehydrates the same Queue, Activity, session, collection, pending-edit, and Git metadata that initial controller startup loads, so a bridge that becomes available after the panel mounted no longer leaves those surfaces permanently stale.
+- **Deterministic ReturnVape reset.** `reset-test-vault.sh` verifies the PID and port registered in `.vault-mind/server.json` serve the target vault before terminating and waiting for that runtime. A stale registry cannot signal an unrelated PID. The reset no longer copies local plugin artifacts; BRAT is the only test-vault update path.
 
-### Tests
+### Verification
+
+- Added focused regressions for panel metadata recovery after an initial bridge outage, verified runtime termination, and stale-registry safety.
+
+
+## 0.16.10 / 0.6.14 — 2026-07-20
+
+### Added
+
+- **First-run retry with notes.** After cancellation or a terminal personalization failure, the Personalize card retains an optional draft. A blank draft retries with `/vm personalize`; a nonblank trimmed draft is sent as explicit `@agent-personalize:` input and clears only after durable personalization completes.
+- **Typed collection and injector management.** Vault Mind Settings now exposes authenticated collection and injector CRUD controls with validation for vault-relative paths, collection schemas, regex patterns, and referenced targets.
+
+### Fixed
+
+- **First-run chat lifecycle.** The onboarding surface remains stable through configuration and personalization transitions. The standard message feed is deferred until a durable personalized state and is instantiated at most once, preventing duplicate first-run cards from reactive remounts.
+- **Long diff readability.** Diff cards collapse long proposal sides by default while retaining access to the full edit.
+- **Settings persistence and layout.** The setup wizard forwards Auto-start to `POST /vm/setup`; Settings categories write the canonical nested configuration shape, and the plugin Settings pane uses the available Obsidian width.
+- **Tool-card escaped text.** JSON-decoded multiline tool output renders actual line breaks and indentation instead of literal escape sequences.
+
+### Verification
 
-- Added REST coverage for persisting Auto-start and preserving existing default-vault siblings; added adapter coverage for forwarding setup preferences.
+- Added focused coverage for retry-note dispatch, cancellation/failure retention, durable-success clearing, one-card first-run lifecycle transitions, long diff collapse, Settings persistence, and collection/injector contracts.
+- The collection/injector CRUD and first-run retry flows remain pending published-artifact ReturnVape walkthroughs.
 
 
 ## 0.6.12 — 2026-07-19

package/dist/packages/obsidian/src/client.js

@@ -6,6 +6,14 @@ const encodeWebSocketAuthProtocol = (token) => {
     const encoded = btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
     return `pvm-auth.${encoded}`;
 };
+export class HttpStatusError extends Error {
+    status;
+    constructor(status, message) {
+        super(`${status} ${message}`);
+        this.name = "HttpStatusError";
+        this.status = status;
+    }
+}
 /**
  * HTTP + WebSocket client for the pi-vault-mind extension.
  *
@@ -142,7 +150,7 @@ export class VaultMindClient {
                 // keep raw text as the server message
             }
             // Never echo the request body or secret material in the thrown error.
-            throw new Error(`${res.status} ${serverMessage}`);
+            throw new HttpStatusError(res.status, serverMessage);
         }
         return text ? JSON.parse(text) : undefined;
     }
@@ -285,6 +293,30 @@ export class VaultMindClient {
     async vmStats() {
         return (await this.httpJson("GET", "/vm/stats"));
     }
+    async listManagedCollections() {
+        return (await this.httpJson("GET", "/vm/collections"));
+    }
+    async upsertManagedCollection(name, input) {
+        return (await this.httpJson("PUT", `/vm/collections/${encodeURIComponent(name)}`, input));
+    }
+    async patchManagedCollection(name, input) {
+        return (await this.httpJson("PATCH", `/vm/collections/${encodeURIComponent(name)}`, input));
+    }
+    async deleteManagedCollection(name) {
+        await this.httpJson("DELETE", `/vm/collections/${encodeURIComponent(name)}`);
+    }
+    async listManagedInjectors() {
+        return (await this.httpJson("GET", "/vm/injectors"));
+    }
+    async upsertManagedInjector(name, input) {
+        return (await this.httpJson("PUT", `/vm/injectors/${encodeURIComponent(name)}`, input));
+    }
+    async patchManagedInjector(name, input) {
+        return (await this.httpJson("PATCH", `/vm/injectors/${encodeURIComponent(name)}`, input));
+    }
+    async deleteManagedInjector(name) {
+        await this.httpJson("DELETE", `/vm/injectors/${encodeURIComponent(name)}`);
+    }
     /** GET /vault-mind/config — full config + hasToken + remote block */
     async getConfig() {
         return (await this.httpJson("GET", "/vault-mind/config"));

package/dist/src/collection-injector-manager.d.ts

@@ -0,0 +1,32 @@
+export interface CollectionConfig {
+    name: string;
+    path: string;
+    schema: string[];
+    dedupField?: string;
+    dedupMode?: "exact" | "fuzzy";
+    dedupThreshold?: number;
+}
+export interface CollectionRecord extends CollectionConfig {
+    count: number;
+    malformed: number;
+}
+export interface InjectorConfig {
+    name: string;
+    regex: string;
+    collection: string;
+    captureGroup?: number;
+    filterField?: string;
+    artifactPath?: string;
+    template?: string;
+}
+export declare class CollectionInjectorManagerError extends Error {
+    readonly status: 400 | 404 | 409;
+    constructor(message: string, status: 400 | 404 | 409);
+}
+export declare function listCollections(vaultPath: string): CollectionRecord[];
+export declare function upsertCollection(vaultPath: string, request: CollectionConfig): CollectionRecord;
+export declare function patchCollection(vaultPath: string, name: string, patch: Record<string, unknown>): CollectionRecord;
+export declare function deleteCollection(vaultPath: string, name: string): void;
+export declare function listInjectors(vaultPath: string): InjectorConfig[];
+export declare function upsertInjector(vaultPath: string, request: InjectorConfig): InjectorConfig;
+export declare function deleteInjector(vaultPath: string, name: string): void;

package/dist/src/collection-injector-manager.js

@@ -0,0 +1,394 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getConfigPath } from "./utils.js";
+export class CollectionInjectorManagerError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "CollectionInjectorManagerError";
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requiredText(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new CollectionInjectorManagerError(`${label} is required.`, 400);
+    }
+    return value.trim();
+}
+function readConfig(vaultPath) {
+    const configPath = getConfigPath(vaultPath);
+    if (!fs.existsSync(configPath)) {
+        throw new CollectionInjectorManagerError("No vault configuration found. Run setup first.", 404);
+    }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        if (!isRecord(parsed))
+            throw new Error("Configuration must be an object.");
+        return { configPath, config: parsed };
+    }
+    catch (error) {
+        if (error instanceof CollectionInjectorManagerError)
+            throw error;
+        throw new CollectionInjectorManagerError(`Could not read vault configuration: ${error instanceof Error ? error.message : String(error)}`, 400);
+    }
+}
+function writeConfig(configPath, config) {
+    const temporaryPath = `${configPath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        fs.writeFileSync(temporaryPath, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+        fs.renameSync(temporaryPath, configPath);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(temporaryPath);
+        }
+        catch { }
+        throw error;
+    }
+}
+function resolveVaultCollectionPath(vaultPath, collectionPath) {
+    if (path.isAbsolute(collectionPath)) {
+        throw new CollectionInjectorManagerError("Collection paths must be relative to the vault.", 400);
+    }
+    if (path.extname(collectionPath) !== ".jsonl") {
+        throw new CollectionInjectorManagerError("Collection paths must target a .jsonl file.", 400);
+    }
+    const absolutePath = path.resolve(vaultPath, collectionPath);
+    const relativePath = path.relative(vaultPath, absolutePath);
+    if (!relativePath ||
+        relativePath === ".." ||
+        relativePath.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relativePath)) {
+        throw new CollectionInjectorManagerError("Collection path must stay inside the vault.", 400);
+    }
+    const realVaultPath = fs.realpathSync.native(vaultPath);
+    let parentPath = vaultPath;
+    for (const segment of relativePath.split(path.sep).slice(0, -1)) {
+        parentPath = path.join(parentPath, segment);
+        if (!fs.existsSync(parentPath))
+            fs.mkdirSync(parentPath);
+        const realParentPath = fs.realpathSync.native(parentPath);
+        const parentRelativePath = path.relative(realVaultPath, realParentPath);
+        if (parentRelativePath === ".." ||
+            parentRelativePath.startsWith(`..${path.sep}`) ||
+            path.isAbsolute(parentRelativePath)) {
+            throw new CollectionInjectorManagerError("Collection path cannot traverse a linked directory outside the vault.", 400);
+        }
+    }
+    if (fs.existsSync(absolutePath) && fs.lstatSync(absolutePath).isSymbolicLink()) {
+        throw new CollectionInjectorManagerError("Collection path cannot be a symbolic link.", 400);
+    }
+    return absolutePath;
+}
+function resolveSchemaAlias(name, value, collections, visited = new Set()) {
+    if (!isRecord(value)) {
+        throw new CollectionInjectorManagerError(`Collection "${name}" has an invalid definition.`, 400);
+    }
+    if (Array.isArray(value.schema)) {
+        return value.schema.map((field) => requiredText(field, `Collection "${name}" schema field`));
+    }
+    if (typeof value.schema !== "string" || !value.schema.trim()) {
+        throw new CollectionInjectorManagerError(`Collection "${name}" requires a schema.`, 400);
+    }
+    const alias = value.schema.trim();
+    if (visited.has(alias)) {
+        throw new CollectionInjectorManagerError(`Collection "${name}" has a circular schema alias.`, 400);
+    }
+    const target = collections[alias];
+    if (target === undefined) {
+        throw new CollectionInjectorManagerError(`Collection "${name}" references missing schema alias "${alias}".`, 400);
+    }
+    visited.add(alias);
+    return resolveSchemaAlias(alias, target, collections, visited);
+}
+function collectionRecord(name, value, vaultPath, collections) {
+    if (!isRecord(value)) {
+        throw new CollectionInjectorManagerError(`Collection "${name}" has an invalid definition.`, 400);
+    }
+    const collectionPath = requiredText(value.path, `Collection "${name}" path`);
+    const schema = collections
+        ? resolveSchemaAlias(name, value, collections, new Set([name]))
+        : Array.isArray(value.schema)
+            ? value.schema.map((field) => requiredText(field, `Collection "${name}" schema field`))
+            : [];
+    if (schema.length === 0) {
+        throw new CollectionInjectorManagerError(`Collection "${name}" requires at least one schema field.`, 400);
+    }
+    const absolutePath = path.isAbsolute(collectionPath)
+        ? collectionPath
+        : path.join(vaultPath, collectionPath);
+    let count = 0;
+    let malformed = 0;
+    if (fs.existsSync(absolutePath)) {
+        for (const line of fs.readFileSync(absolutePath, "utf-8").split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                JSON.parse(line);
+                count += 1;
+            }
+            catch {
+                malformed += 1;
+            }
+        }
+    }
+    const dedupMode = value.dedupMode;
+    const dedupThreshold = value.dedupThreshold;
+    return {
+        name,
+        path: collectionPath,
+        schema,
+        ...(typeof value.dedupField === "string" && value.dedupField.trim()
+            ? { dedupField: value.dedupField.trim() }
+            : {}),
+        ...(dedupMode === "exact" || dedupMode === "fuzzy" ? { dedupMode } : {}),
+        ...(typeof dedupThreshold === "number" && Number.isFinite(dedupThreshold)
+            ? { dedupThreshold }
+            : {}),
+        count,
+        malformed,
+    };
+}
+function assertVaultArtifactPath(vaultPath, artifactPath) {
+    if (path.isAbsolute(artifactPath)) {
+        throw new CollectionInjectorManagerError("Injector artifact paths must be relative to the vault.", 400);
+    }
+    const absolutePath = path.resolve(vaultPath, artifactPath);
+    const relativePath = path.relative(vaultPath, absolutePath);
+    if (!relativePath ||
+        relativePath === ".." ||
+        relativePath.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relativePath)) {
+        throw new CollectionInjectorManagerError("Injector artifact path must stay inside the vault.", 400);
+    }
+    let existingParentPath = path.dirname(absolutePath);
+    while (!fs.existsSync(existingParentPath)) {
+        const nextParentPath = path.dirname(existingParentPath);
+        if (nextParentPath === existingParentPath)
+            break;
+        existingParentPath = nextParentPath;
+    }
+    const realVaultPath = fs.realpathSync.native(vaultPath);
+    const realParentPath = fs.realpathSync.native(existingParentPath);
+    const parentRelativePath = path.relative(realVaultPath, realParentPath);
+    if (parentRelativePath === ".." ||
+        parentRelativePath.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(parentRelativePath)) {
+        throw new CollectionInjectorManagerError("Injector artifact path cannot traverse a linked directory outside the vault.", 400);
+    }
+    if (fs.existsSync(absolutePath) && fs.lstatSync(absolutePath).isSymbolicLink()) {
+        throw new CollectionInjectorManagerError("Injector artifact path cannot be a symbolic link.", 400);
+    }
+}
+function injectorRecord(value) {
+    if (!isRecord(value))
+        throw new CollectionInjectorManagerError("Injector has an invalid definition.", 400);
+    return {
+        name: requiredText(value.name, "Injector name"),
+        regex: requiredText(value.regex, "Injector regex"),
+        collection: requiredText(value.collection, "Injector collection"),
+        ...(typeof value.captureGroup === "number" ? { captureGroup: value.captureGroup } : {}),
+        ...(typeof value.filterField === "string" && value.filterField.trim()
+            ? { filterField: value.filterField.trim() }
+            : {}),
+        ...(typeof value.artifactPath === "string" && value.artifactPath.trim()
+            ? { artifactPath: value.artifactPath.trim() }
+            : {}),
+        ...(typeof value.template === "string" && value.template.trim()
+            ? { template: value.template }
+            : {}),
+    };
+}
+function collectionReferences(config, name) {
+    const references = [];
+    for (const injector of config.injectors ?? []) {
+        if (isRecord(injector) && injector.collection === name) {
+            references.push(`injector "${String(injector.name ?? "unnamed")}"`);
+        }
+    }
+    for (const [collectionName, definition] of Object.entries(config.collections ?? {})) {
+        if (collectionName !== name && isRecord(definition) && definition.schema === name) {
+            references.push(`collection "${collectionName}" schema alias`);
+        }
+    }
+    const vaultMind = config.vaultMind;
+    const embedding = isRecord(vaultMind?.embedding) ? vaultMind.embedding : undefined;
+    const sync = isRecord(embedding?.sync) ? embedding.sync : undefined;
+    if (Array.isArray(sync?.collections) && sync.collections.includes(name)) {
+        references.push("embedding sync collections");
+    }
+    if (isRecord(embedding?.collectionModels) && Object.hasOwn(embedding.collectionModels, name)) {
+        references.push("embedding collection models");
+    }
+    const identities = isRecord(vaultMind?.identities) ? vaultMind.identities : undefined;
+    const roles = isRecord(identities?.roles) ? identities.roles : {};
+    for (const [role, profile] of Object.entries(roles)) {
+        if (!isRecord(profile))
+            continue;
+        for (const key of ["readCollections", "writeCollections"]) {
+            if (Array.isArray(profile[key]) && profile[key].includes(name)) {
+                references.push(`identity role "${role}" ${key}`);
+            }
+        }
+    }
+    return references;
+}
+export function listCollections(vaultPath) {
+    const { config } = readConfig(vaultPath);
+    const collections = isRecord(config.collections) ? config.collections : {};
+    return Object.entries(collections).map(([name, value]) => collectionRecord(name, value, vaultPath, collections));
+}
+export function upsertCollection(vaultPath, request) {
+    if (!isRecord(request) || !Array.isArray(request.schema)) {
+        throw new CollectionInjectorManagerError("Collection requires a schema array.", 400);
+    }
+    const name = requiredText(request.name, "Collection name");
+    const collectionPath = requiredText(request.path, "Collection path");
+    const schema = request.schema.map((field) => requiredText(field, "Collection schema field"));
+    if (schema.length === 0) {
+        throw new CollectionInjectorManagerError("Collection requires at least one schema field.", 400);
+    }
+    if (new Set(schema).size !== schema.length) {
+        throw new CollectionInjectorManagerError("Collection schema fields must be unique.", 400);
+    }
+    if (request.dedupMode && request.dedupMode !== "exact" && request.dedupMode !== "fuzzy") {
+        throw new CollectionInjectorManagerError("Dedup mode must be exact or fuzzy.", 400);
+    }
+    if (request.dedupThreshold !== undefined &&
+        (!Number.isFinite(request.dedupThreshold) ||
+            request.dedupThreshold < 0 ||
+            request.dedupThreshold > 1)) {
+        throw new CollectionInjectorManagerError("Dedup threshold must be between 0 and 1.", 400);
+    }
+    const { configPath, config } = readConfig(vaultPath);
+    const collections = isRecord(config.collections) ? config.collections : {};
+    const dedupField = typeof request.dedupField === "string" ? request.dedupField.trim() : undefined;
+    const definition = {
+        path: collectionPath,
+        schema,
+        ...(dedupField ? { dedupField } : {}),
+        ...(request.dedupMode ? { dedupMode: request.dedupMode } : {}),
+        ...(request.dedupThreshold !== undefined ? { dedupThreshold: request.dedupThreshold } : {}),
+    };
+    const absolutePath = resolveVaultCollectionPath(vaultPath, collectionPath);
+    config.collections = { ...collections, [name]: definition };
+    if (!fs.existsSync(absolutePath))
+        fs.writeFileSync(absolutePath, "", "utf-8");
+    writeConfig(configPath, config);
+    return collectionRecord(name, definition, vaultPath);
+}
+export function patchCollection(vaultPath, name, patch) {
+    const collectionName = requiredText(name, "Collection name");
+    const { configPath, config } = readConfig(vaultPath);
+    const collections = isRecord(config.collections) ? config.collections : {};
+    const current = collections[collectionName];
+    if (!isRecord(current)) {
+        throw new CollectionInjectorManagerError(`Collection "${collectionName}" was not found.`, 404);
+    }
+    const { name: _ignoredName, ...definitionPatch } = patch;
+    const definition = { ...current, ...definitionPatch };
+    if (Array.isArray(definition.schema)) {
+        return upsertCollection(vaultPath, {
+            name: collectionName,
+            path: requiredText(definition.path, "Collection path"),
+            schema: definition.schema.map((field) => requiredText(field, "Collection schema field")),
+            ...(typeof definition.dedupField === "string" ? { dedupField: definition.dedupField } : {}),
+            ...(definition.dedupMode === "exact" || definition.dedupMode === "fuzzy"
+                ? { dedupMode: definition.dedupMode }
+                : {}),
+            ...(typeof definition.dedupThreshold === "number"
+                ? { dedupThreshold: definition.dedupThreshold }
+                : {}),
+        });
+    }
+    if (typeof definition.schema !== "string" || !definition.schema.trim()) {
+        throw new CollectionInjectorManagerError("Collection requires a schema array or alias.", 400);
+    }
+    const collectionPath = requiredText(definition.path, "Collection path");
+    if (definition.dedupMode !== undefined &&
+        definition.dedupMode !== "exact" &&
+        definition.dedupMode !== "fuzzy") {
+        throw new CollectionInjectorManagerError("Dedup mode must be exact or fuzzy.", 400);
+    }
+    if (definition.dedupThreshold !== undefined &&
+        (typeof definition.dedupThreshold !== "number" ||
+            !Number.isFinite(definition.dedupThreshold) ||
+            definition.dedupThreshold < 0 ||
+            definition.dedupThreshold > 1)) {
+        throw new CollectionInjectorManagerError("Dedup threshold must be between 0 and 1.", 400);
+    }
+    const updatedCollections = { ...collections, [collectionName]: definition };
+    const schema = resolveSchemaAlias(collectionName, definition, updatedCollections, new Set([collectionName]));
+    if (schema.length === 0) {
+        throw new CollectionInjectorManagerError("Collection requires at least one schema field.", 400);
+    }
+    const absolutePath = resolveVaultCollectionPath(vaultPath, collectionPath);
+    if (!fs.existsSync(absolutePath))
+        fs.writeFileSync(absolutePath, "", "utf-8");
+    config.collections = updatedCollections;
+    writeConfig(configPath, config);
+    return collectionRecord(collectionName, definition, vaultPath, updatedCollections);
+}
+export function deleteCollection(vaultPath, name) {
+    const collectionName = requiredText(name, "Collection name");
+    const { configPath, config } = readConfig(vaultPath);
+    const collections = isRecord(config.collections) ? config.collections : {};
+    if (!Object.hasOwn(collections, collectionName)) {
+        throw new CollectionInjectorManagerError(`Collection "${collectionName}" was not found.`, 404);
+    }
+    const references = collectionReferences(config, collectionName);
+    if (references.length > 0) {
+        throw new CollectionInjectorManagerError(`Collection "${collectionName}" is referenced by ${references.join(", ")}. Remove those references before deleting it.`, 409);
+    }
+    delete collections[collectionName];
+    config.collections = collections;
+    writeConfig(configPath, config);
+}
+export function listInjectors(vaultPath) {
+    const { config } = readConfig(vaultPath);
+    return (config.injectors ?? []).map(injectorRecord);
+}
+export function upsertInjector(vaultPath, request) {
+    const injector = injectorRecord(request);
+    try {
+        new RegExp(injector.regex);
+    }
+    catch (error) {
+        throw new CollectionInjectorManagerError(`Invalid injector regex: ${error instanceof Error ? error.message : String(error)}`, 400);
+    }
+    if (injector.captureGroup !== undefined &&
+        (!Number.isInteger(injector.captureGroup) || injector.captureGroup < 0)) {
+        throw new CollectionInjectorManagerError("Capture group must be a non-negative integer.", 400);
+    }
+    if (injector.artifactPath)
+        assertVaultArtifactPath(vaultPath, injector.artifactPath);
+    const { configPath, config } = readConfig(vaultPath);
+    const collections = isRecord(config.collections) ? config.collections : {};
+    if (!Object.hasOwn(collections, injector.collection)) {
+        throw new CollectionInjectorManagerError(`Target collection "${injector.collection}" was not found.`, 400);
+    }
+    const injectors = (config.injectors ?? []).map(injectorRecord);
+    const existingIndex = injectors.findIndex((candidate) => candidate.name === injector.name);
+    if (existingIndex >= 0)
+        injectors[existingIndex] = injector;
+    else
+        injectors.push(injector);
+    config.injectors = injectors;
+    writeConfig(configPath, config);
+    return injector;
+}
+export function deleteInjector(vaultPath, name) {
+    const injectorName = requiredText(name, "Injector name");
+    const { configPath, config } = readConfig(vaultPath);
+    const injectors = (config.injectors ?? []).map(injectorRecord);
+    const remaining = injectors.filter((injector) => injector.name !== injectorName);
+    if (remaining.length === injectors.length) {
+        throw new CollectionInjectorManagerError(`Injector "${injectorName}" was not found.`, 404);
+    }
+    config.injectors = remaining;
+    writeConfig(configPath, config);
+}