@aryacode/dsh-engineering 0.0.0-stage → 0.3.0

package/vendor/ftview/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: factorytalk-view
+description: Design and support FactoryTalk View ME and PanelView Plus applications from documented text exports: displays, HMI tags, structural checks and export comparison.
+whenToUse: Use when the user asks about FactoryTalk View ME, PanelView Plus, ME display exports, HMI tags, or comparing ME exports. Route FactoryTalk View SE and Optix to their own surfaces.
+---
+
+# FactoryTalk View ME engineering
+
+## Boundary
+
+This surface reads and stages changes to documented text exports: display XML and the HMI tag CSV.
+A staged edit is written to a NEW export folder; the source is never modified. The Studio entry plans
+a manual import for a human; it does not drive Studio, contact a terminal, or decode MER or MED
+databases.
+
+## Start
+
+1. Call `ftview_open` with the export folder. Keep the returned `view_id`.
+2. Later calls may omit `view_id` when exactly one export is open.
+3. Ask only for the exports the task needs: display XML for display work, the tag CSV for tag work,
+   L5X only when PLC binding matters.
+
+## Inspect
+
+- `ftview_list` enumerates displays or tags, with a name filter and paging.
+- `ftview_get` reads one display (its named objects) or one tag row.
+- `ftview_find` searches displays, object names, object attribute values and tags.
+
+## Check and compare
+
+- `ftview_check` reports structural findings: tag CSV integrity, duplicate display/object/tag names,
+  and files that did not parse. It is not vendor schema validation and says nothing about PLC
+  binding.
+- `ftview_compare` compares two opened exports by display name, tag name and file hash.
+
+## Editing
+
+The `ftview-edit` entry stages changes; it may be disabled in this profile. If a draft tool is
+unavailable, say editing is not enabled here rather than trying another tool.
+
+- `ftview_draft_display_set` stages one attribute change on a display or one of its named objects.
+- `ftview_draft_display_add` stages a new display by copying an existing display file.
+- `ftview_draft_tag_upsert` stages one HMI tag description/type change or a new tag row.
+- One operation per call. Each returns the draft id and the operation count; nothing is written yet.
+- `ftview_validate` applies the staged edits to a re-parsed copy and reports the changed files.
+- `ftview_apply` writes a NEW export folder. It never modifies the source.
+
+After applying, reopen the written folder with `ftview_open` and compare it with the source using
+`ftview_compare`.
+
+## Studio
+
+The `ftview-studio` entry plans a manual import; it may be disabled.
+
+- `ftview_studio_status` discovers installed ME tooling, schemas and help files.
+- `ftview_studio_preflight` checks the files that differ between two exports for Studio import
+  problems, including name restrictions.
+- `ftview_studio_handoff` returns the ordered manual import plan for a human in FactoryTalk View
+  Studio. No vendor utility runs and no file is written.
+
+## Reporting
+
+- Every result carries `summary`, `data`, `next` and `coverage`. Read `coverage` before claiming
+  completeness.
+- State what the export cannot prove: XSD validity, PLC binding, runtime behavior, visual rendering,
+  and anything absent from the supplied export.
+- Quote the display file and object name for a finding.
+- Do not call a tag unused from the absence of references in displays; other consumers are invisible
+  here.
+
+## Out of scope
+
+FactoryTalk View SE and FactoryTalk Optix are different products and are not analyzed here. MER/MED
+databases are not decoded, and no tool contacts a PanelView terminal or changes runtime data.

package/vendor/ftview/lib/checks.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Structural checks shared by the read and editing entries.
+ *
+ * @module dsh-engineering-ftview/checks
+ */
+import type { DisplayFile, TagRow } from './model.ts';
+/** One finding the check reports. */
+export interface Finding {
+    readonly rule: string;
+    readonly severity: 'error' | 'warning' | 'info';
+    readonly message: string;
+    readonly evidence: unknown;
+}
+/** The application parts the checks read. */
+export interface Checkable {
+    readonly displays: readonly DisplayFile[];
+    readonly tags: readonly TagRow[];
+    readonly tagErrors: readonly string[];
+    readonly diagnostics: readonly string[];
+}
+/**
+ * Run the structural checks.
+ *
+ * @param app - Displays, tags and the diagnostics from scanning.
+ * @returns Findings in rule order.
+ */
+export declare function findingsOf(app: Checkable): Finding[];

package/vendor/ftview/lib/checks.js

@@ -0,0 +1,39 @@
+/**
+ * Structural checks shared by the read and editing entries.
+ *
+ * @module dsh-engineering-ftview/checks
+ */
+/**
+ * Run the structural checks.
+ *
+ * @param app - Displays, tags and the diagnostics from scanning.
+ * @returns Findings in rule order.
+ */
+export function findingsOf(app) {
+    const findings = [];
+    for (const error of app.tagErrors)
+        findings.push({ rule: 'TAG_CSV', severity: 'warning', message: error, evidence: { file: 'tag CSV' } });
+    for (const diagnostic of app.diagnostics)
+        findings.push({ rule: 'UNPARSED_FILE', severity: 'warning', message: diagnostic, evidence: { file: diagnostic.split(':')[0] } });
+    const displayNames = new Set();
+    for (const display of app.displays) {
+        if (displayNames.has(display.name))
+            findings.push({ rule: 'DUPLICATE_DISPLAY_NAME', severity: 'warning', message: `Two displays are named ${JSON.stringify(display.name)}.`, evidence: { display: display.name, file: display.file } });
+        displayNames.add(display.name);
+        const objectNames = new Set();
+        for (const object of display.objects) {
+            if (object.name === undefined)
+                continue;
+            if (objectNames.has(object.name))
+                findings.push({ rule: 'DUPLICATE_OBJECT_NAME', severity: 'warning', message: `Display ${JSON.stringify(display.name)} has more than one object named ${JSON.stringify(object.name)}.`, evidence: { display: display.name, object: object.name } });
+            objectNames.add(object.name);
+        }
+    }
+    const tagNames = new Set();
+    for (const tag of app.tags) {
+        if (tagNames.has(tag.name))
+            findings.push({ rule: 'DUPLICATE_TAG_NAME', severity: 'error', message: `The tag CSV declares ${JSON.stringify(tag.name)} more than once.`, evidence: { tag: tag.name } });
+        tagNames.add(tag.name);
+    }
+    return findings;
+}

package/vendor/ftview/lib/core.d.ts

@@ -0,0 +1,208 @@
+/**
+ * Shared result, error and parameter conventions for the engineering bundle.
+ *
+ * Every tool answers with `summary`, `data`, `next` and `coverage`, and every
+ * parameter is described at the point of declaration. Failures carry a stable
+ * code, a message in the reader's terms, and the fix that unblocks the caller.
+ *
+ * @module dsh-engineering-ftview/core
+ */
+/** How completely an answer covers the request. */
+export interface Coverage {
+    readonly complete: boolean;
+    readonly unverified: readonly string[];
+}
+/** One suggested follow-up call. */
+export interface NextStep {
+    readonly tool: string;
+    readonly args?: Readonly<Record<string, unknown>>;
+    readonly why: string;
+}
+/** The success document every tool returns. */
+export interface Success {
+    readonly summary: string;
+    readonly data: unknown;
+    readonly next: readonly NextStep[];
+    readonly coverage: Coverage;
+}
+/** A failure the caller can usually repair. */
+export declare class EngineeringError extends Error {
+    readonly code: string;
+    readonly fix: string;
+    readonly candidates: readonly string[];
+    /**
+     * @param code - Stable identifier for tests and logs.
+     * @param message - What failed, in the reader's terms.
+     * @param fix - The next call or check.
+     * @param candidates - Known names the caller probably meant.
+     */
+    constructor(code: string, message: string, fix: string, candidates?: readonly string[]);
+}
+/**
+ * Convert any thrown value into the error envelope.
+ *
+ * @param error - The thrown value.
+ * @returns The envelope the tool registry reports.
+ */
+export declare function errorEnvelope(error: unknown): {
+    error: {
+        code: string;
+        message: string;
+        fix: string;
+        candidates: readonly string[];
+    };
+};
+/** Build one success document. */
+export declare function success(summary: string, data: unknown, next: readonly NextStep[], coverage: Coverage): Success;
+/** One JSON Schema property, always described. */
+export interface ParameterSchema {
+    readonly type: 'string' | 'integer' | 'number' | 'boolean' | 'array' | 'object';
+    readonly description: string;
+    readonly enum?: readonly string[];
+    readonly items?: ParameterSchema;
+    readonly default?: unknown;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly properties?: Readonly<Record<string, ParameterSchema>>;
+    readonly required?: readonly string[];
+    readonly additionalProperties?: boolean;
+}
+/** A described string parameter. */
+export declare function string(description: string, extra?: Partial<ParameterSchema>): ParameterSchema;
+/** A described integer parameter with an optional range. */
+export declare function integer(description: string, extra?: Partial<ParameterSchema>): ParameterSchema;
+/** A described enum parameter. */
+export declare function choice(description: string, values: readonly string[], extra?: Partial<ParameterSchema>): ParameterSchema;
+/** One object element of an array parameter. */
+export declare function objectItem(description: string, properties: Readonly<Record<string, ParameterSchema>>, required?: readonly string[]): ParameterSchema;
+/** An array of one parameter type. */
+export declare function list(description: string, items: ParameterSchema, extra?: Partial<ParameterSchema>): ParameterSchema;
+/** The `parameters` object of one tool. */
+export interface Parameters {
+    readonly type: 'object';
+    readonly properties: Readonly<Record<string, ParameterSchema>>;
+    readonly required: readonly string[];
+    readonly additionalProperties: false;
+}
+/**
+ * Build a parameter object.
+ *
+ * @param properties - Named parameters, each already described.
+ * @param required - Names the caller must supply.
+ * @returns The schema a tool definition declares.
+ */
+export declare function object(properties: Readonly<Record<string, ParameterSchema>>, required?: readonly string[]): Parameters;
+/** One directory entry the filesystem provider reports. */
+export interface DirEntry {
+    readonly name: string;
+    readonly type: string;
+}
+/** The filesystem operations this package uses. */
+export interface FsService {
+    resolve(path: string, options?: {
+        readonly signal?: AbortSignal;
+        readonly cwd?: string;
+    }): Promise<string>;
+    stat(path: string, signal?: AbortSignal): Promise<{
+        readonly type: string;
+    } | undefined>;
+    readBytes(path: string, signal: AbortSignal | undefined, maxBytes?: number): Promise<Uint8Array>;
+    listDir?(path: string, signal?: AbortSignal): Promise<readonly DirEntry[]>;
+    writeText?(path: string, text: string, options?: {
+        readonly kind?: 'createIfAbsent' | 'overwrite';
+    }, signal?: AbortSignal): Promise<void>;
+}
+/** A path resolved by the harness filesystem into its backend identity. */
+export interface FsTarget {
+    /** Opaque key for stale guards and target lookup. */
+    readonly targetKey: unknown;
+    /** Path for model- and UI-facing output. */
+    readonly displayPath: string;
+}
+/** The harness filesystem as it is actually provided: operations take resolved targets. */
+export interface RawFsService {
+    resolve(path: string, options?: {
+        readonly signal?: AbortSignal;
+        readonly cwd?: string;
+    }): Promise<FsTarget | string>;
+    stat(target: FsTarget | string, signal?: AbortSignal): Promise<{
+        readonly type: string;
+    } | undefined>;
+    readBytes(target: FsTarget | string, signal: AbortSignal | undefined, maxBytes?: number): Promise<Uint8Array>;
+    listDir?(target: FsTarget | string, signal?: AbortSignal): Promise<readonly DirEntry[]>;
+    writeText?(target: FsTarget | string, text: string, options?: {
+        readonly kind?: 'createIfAbsent' | 'overwrite';
+    }, signal?: AbortSignal): Promise<void>;
+}
+/**
+ * Present the harness filesystem with string paths.
+ *
+ * The model, edits and discovery compose paths (`${root}/${file}`); the harness
+ * service takes opaque targets. This adapter resolves each path before calling
+ * the service and returns display strings, so path composition stays readable.
+ * A provider that already returns strings, such as a test double, passes through.
+ *
+ * @param service - The harness filesystem service.
+ * @returns The same operations addressed by path strings.
+ */
+export declare function stringFs(service: RawFsService): FsService;
+/** The tool registry the plugin registers into. */
+export interface ToolRegistry {
+    register(definition: ToolDefinition): void;
+}
+/** The services a composition must provide before this plugin loads. */
+export interface PluginContext {
+    readonly tools: ToolRegistry;
+    readonly fs: RawFsService;
+    provide?(name: string, value: unknown): void;
+    get?(name: string): unknown;
+}
+/** The context a tool body receives. */
+export interface ExecContext {
+    readonly signal?: AbortSignal;
+    readonly cwd?: string;
+    readonly chat?: object;
+}
+/** One text block the transcript renders. */
+export interface TextBlock {
+    readonly type: 'text';
+    readonly text: string;
+}
+/** The output declaration every registered tool carries. */
+export interface ToolOutput {
+    readonly schema: {
+        readonly type: 'object';
+        readonly additionalProperties: boolean;
+    };
+    render(args: unknown, value: unknown): readonly TextBlock[];
+}
+/** One registered tool. */
+export interface ToolDefinition {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: Parameters;
+    readonly output: ToolOutput;
+    execute(args: Readonly<Record<string, unknown>>, exec: ExecContext): Promise<unknown>;
+}
+/** One tool body before the shared envelope and error handling are attached. */
+export interface ToolSpec {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: Parameters;
+    run(args: Readonly<Record<string, unknown>>, exec: ExecContext): Promise<unknown>;
+}
+/**
+ * Wrap one tool body in the shared envelope and error handling.
+ *
+ * @param spec - Tool identity and body.
+ * @returns The definition the registry accepts.
+ */
+export declare function tool(spec: ToolSpec): ToolDefinition;
+/** A required string argument. */
+export declare function requiredString(args: Readonly<Record<string, unknown>>, name: string): string;
+/** An optional string argument. */
+export declare function optionalString(args: Readonly<Record<string, unknown>>, name: string): string | undefined;
+/** An optional integer argument. */
+export declare function optionalInteger(args: Readonly<Record<string, unknown>>, name: string): number | undefined;

package/vendor/ftview/lib/core.js

@@ -0,0 +1,160 @@
+/**
+ * Shared result, error and parameter conventions for the engineering bundle.
+ *
+ * Every tool answers with `summary`, `data`, `next` and `coverage`, and every
+ * parameter is described at the point of declaration. Failures carry a stable
+ * code, a message in the reader's terms, and the fix that unblocks the caller.
+ *
+ * @module dsh-engineering-ftview/core
+ */
+/** A failure the caller can usually repair. */
+export class EngineeringError extends Error {
+    code;
+    fix;
+    candidates;
+    /**
+     * @param code - Stable identifier for tests and logs.
+     * @param message - What failed, in the reader's terms.
+     * @param fix - The next call or check.
+     * @param candidates - Known names the caller probably meant.
+     */
+    constructor(code, message, fix, candidates = []) {
+        super(message);
+        this.name = 'EngineeringError';
+        this.code = code;
+        this.fix = fix;
+        this.candidates = candidates;
+    }
+}
+/**
+ * Convert any thrown value into the error envelope.
+ *
+ * @param error - The thrown value.
+ * @returns The envelope the tool registry reports.
+ */
+export function errorEnvelope(error) {
+    if (error instanceof EngineeringError) {
+        return { error: { code: error.code, message: error.message, fix: error.fix, candidates: error.candidates } };
+    }
+    return {
+        error: {
+            code: 'INTERNAL',
+            message: error instanceof Error ? error.message : String(error),
+            fix: 'Retry the call; if it fails the same way, report the message and the arguments used.',
+            candidates: [],
+        },
+    };
+}
+/** Build one success document. */
+export function success(summary, data, next, coverage) {
+    return { summary, data, next, coverage };
+}
+/** A described string parameter. */
+export function string(description, extra = {}) {
+    return { type: 'string', description, ...extra };
+}
+/** A described integer parameter with an optional range. */
+export function integer(description, extra = {}) {
+    return { type: 'integer', description, ...extra };
+}
+/** A described enum parameter. */
+export function choice(description, values, extra = {}) {
+    return { type: 'string', description, enum: values, ...extra };
+}
+/** One object element of an array parameter. */
+export function objectItem(description, properties, required = []) {
+    return { type: 'object', description, properties, required, additionalProperties: false };
+}
+/** An array of one parameter type. */
+export function list(description, items, extra = {}) {
+    return { type: 'array', description, items, ...extra };
+}
+/**
+ * Build a parameter object.
+ *
+ * @param properties - Named parameters, each already described.
+ * @param required - Names the caller must supply.
+ * @returns The schema a tool definition declares.
+ */
+export function object(properties, required = []) {
+    return { type: 'object', properties, required, additionalProperties: false };
+}
+/**
+ * Present the harness filesystem with string paths.
+ *
+ * The model, edits and discovery compose paths (`${root}/${file}`); the harness
+ * service takes opaque targets. This adapter resolves each path before calling
+ * the service and returns display strings, so path composition stays readable.
+ * A provider that already returns strings, such as a test double, passes through.
+ *
+ * @param service - The harness filesystem service.
+ * @returns The same operations addressed by path strings.
+ */
+export function stringFs(service) {
+    const targetOf = async (path, signal) => await service.resolve(path, signal === undefined ? {} : { signal });
+    const fs = {
+        async resolve(path, options) {
+            const value = await service.resolve(path, options);
+            return typeof value === 'string' ? value : value.displayPath;
+        },
+        async stat(path, signal) {
+            return await service.stat(await targetOf(path, signal), signal);
+        },
+        async readBytes(path, signal, maxBytes) {
+            return await service.readBytes(await targetOf(path, signal), signal, maxBytes);
+        },
+    };
+    if (service.listDir !== undefined) {
+        fs.listDir = async (path, signal) => await service.listDir(await targetOf(path, signal), signal);
+    }
+    if (service.writeText !== undefined) {
+        fs.writeText = async (path, text, options, signal) => {
+            await service.writeText(await targetOf(path, signal), text, options, signal);
+        };
+    }
+    return fs;
+}
+/** Render one tool answer as JSON text for the transcript. */
+function jsonText(_args, value) {
+    return [{ type: 'text', text: JSON.stringify(value, null, 2) }];
+}
+/**
+ * Wrap one tool body in the shared envelope and error handling.
+ *
+ * @param spec - Tool identity and body.
+ * @returns The definition the registry accepts.
+ */
+export function tool(spec) {
+    return {
+        name: spec.name,
+        description: spec.description,
+        parameters: spec.parameters,
+        output: { schema: { type: 'object', additionalProperties: true }, render: jsonText },
+        async execute(args, exec) {
+            try {
+                return await spec.run(args, exec);
+            }
+            catch (error) {
+                return errorEnvelope(error);
+            }
+        },
+    };
+}
+/** A required string argument. */
+export function requiredString(args, name) {
+    const value = args[name];
+    if (typeof value !== 'string' || value === '') {
+        throw new EngineeringError('INVALID_ARGUMENT', `${name} is required and must be a non-empty string.`, `Pass ${name}, for example "${name}".`);
+    }
+    return value;
+}
+/** An optional string argument. */
+export function optionalString(args, name) {
+    const value = args[name];
+    return typeof value === 'string' && value !== '' ? value : undefined;
+}
+/** An optional integer argument. */
+export function optionalInteger(args, name) {
+    const value = args[name];
+    return typeof value === 'number' && Number.isInteger(value) ? value : undefined;
+}

package/vendor/ftview/lib/edit/drafts.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Drafts for staged ME edits.
+ *
+ * One draft per opened export per chat. Operations accumulate until validate or
+ * apply; nothing here reads or writes export files.
+ *
+ * @module dsh-engineering-ftview/edit/drafts
+ */
+import { type ExecContext } from '../core.ts';
+import type { EditOperation } from './operations.ts';
+/** One accumulated edit list. */
+export interface EditDraft {
+    readonly id: string;
+    readonly viewId: string;
+    readonly operations: readonly EditOperation[];
+    readonly createdAt: string;
+}
+/** Drafts, scoped to the chat that created them. */
+export declare class EditDrafts {
+    private readonly chats;
+    private readonly detached;
+    /**
+     * Append one operation to the draft for a view, creating it on first use.
+     *
+     * @param exec - Calling context.
+     * @param viewId - View the draft edits.
+     * @param operation - Operation to append.
+     * @param maxOperations - Inclusive cap for one draft.
+     * @returns The updated draft.
+     */
+    append(exec: ExecContext | undefined, viewId: string, operation: EditOperation, maxOperations: number): EditDraft;
+    /**
+     * Resolve one draft by handle.
+     *
+     * @param exec - Calling context.
+     * @param id - Draft handle; empty selects the chat's only draft.
+     * @returns The draft.
+     */
+    get(exec: ExecContext | undefined, id: string | undefined): EditDraft;
+    /**
+     * Drop one draft after it is applied.
+     *
+     * @param exec - Calling context.
+     * @param id - Draft handle.
+     */
+    remove(exec: ExecContext | undefined, id: string): void;
+    /** The draft map for one calling chat. */
+    private draftsOf;
+}

package/vendor/ftview/lib/edit/drafts.js

@@ -0,0 +1,84 @@
+/**
+ * Drafts for staged ME edits.
+ *
+ * One draft per opened export per chat. Operations accumulate until validate or
+ * apply; nothing here reads or writes export files.
+ *
+ * @module dsh-engineering-ftview/edit/drafts
+ */
+import { randomUUID } from 'node:crypto';
+import { EngineeringError } from "../core.js";
+/** Drafts, scoped to the chat that created them. */
+export class EditDrafts {
+    chats = new WeakMap();
+    detached = new Map();
+    /**
+     * Append one operation to the draft for a view, creating it on first use.
+     *
+     * @param exec - Calling context.
+     * @param viewId - View the draft edits.
+     * @param operation - Operation to append.
+     * @param maxOperations - Inclusive cap for one draft.
+     * @returns The updated draft.
+     */
+    append(exec, viewId, operation, maxOperations) {
+        const drafts = this.draftsOf(exec);
+        const current = [...drafts.values()].find(draft => draft.viewId === viewId);
+        if (current === undefined) {
+            const created = { id: randomUUID(), viewId, operations: [operation], createdAt: new Date().toISOString() };
+            drafts.set(created.id, created);
+            return created;
+        }
+        if (current.operations.length >= maxOperations) {
+            throw new EngineeringError('DRAFT_TOO_LARGE', `This draft already holds ${current.operations.length} operations, the configured maximum.`, 'Validate and apply this draft, then start another for the remaining edits.');
+        }
+        const updated = { ...current, operations: [...current.operations, operation] };
+        drafts.set(updated.id, updated);
+        return updated;
+    }
+    /**
+     * Resolve one draft by handle.
+     *
+     * @param exec - Calling context.
+     * @param id - Draft handle; empty selects the chat's only draft.
+     * @returns The draft.
+     */
+    get(exec, id) {
+        const drafts = this.draftsOf(exec);
+        const ids = [...drafts.keys()];
+        if (id === undefined || id === '') {
+            const only = ids[0];
+            if (only === undefined)
+                throw new EngineeringError('NO_DRAFT', 'No edit draft exists in this chat.', 'Add an operation with an ftview_draft_* tool first.');
+            if (ids.length > 1)
+                throw new EngineeringError('AMBIGUOUS_DRAFT', `${ids.length} drafts exist in this chat, so draft_id is required.`, `Pass one of: ${ids.join(', ')}.`, ids);
+            return drafts.get(only);
+        }
+        const draft = drafts.get(id);
+        if (draft === undefined) {
+            throw new EngineeringError('UNKNOWN_DRAFT', `No draft exists with draft_id ${JSON.stringify(id)} in this chat.`, ids.length === 0 ? 'Add an operation with an ftview_draft_* tool first.' : `Pass one of this chat's draft ids: ${ids.join(', ')}.`, ids);
+        }
+        return draft;
+    }
+    /**
+     * Drop one draft after it is applied.
+     *
+     * @param exec - Calling context.
+     * @param id - Draft handle.
+     */
+    remove(exec, id) {
+        this.draftsOf(exec).delete(id);
+    }
+    /** The draft map for one calling chat. */
+    draftsOf(exec) {
+        const chat = exec?.chat;
+        if (chat === undefined)
+            return this.detached;
+        const existing = this.chats.get(chat);
+        if (existing !== undefined)
+            return existing;
+        const created = new Map();
+        this.chats.set(chat, created);
+        return created;
+    }
+}