@codemation/core 0.0.1

package/src/workflow/graph/DefaultWorkflowGraphFactory.ts

@@ -0,0 +1,8 @@
+import type { WorkflowDefinition, WorkflowGraph, WorkflowGraphFactory } from "../../types";
+import { ExecutableGraph } from "./ExecutableGraph";
+
+export class DefaultWorkflowGraphFactory implements WorkflowGraphFactory {
+  create(def: WorkflowDefinition): WorkflowGraph {
+    return new ExecutableGraph(def);
+  }
+}

package/src/workflow/graph/ExecutableGraph.ts

@@ -0,0 +1,24 @@
+import type { InputPortKey, NodeId, OutputPortKey, WorkflowDefinition, WorkflowGraph } from "../../types";
+
+export class ExecutableGraph implements WorkflowGraph {
+  private readonly outgoingByNodeAndPort = new Map<
+    NodeId,
+    Map<OutputPortKey, Array<Readonly<{ nodeId: NodeId; input: InputPortKey }>>>
+  >();
+
+  constructor(def: WorkflowDefinition) {
+    for (const e of def.edges) {
+      const byPort =
+        this.outgoingByNodeAndPort.get(e.from.nodeId) ??
+        new Map<OutputPortKey, Array<Readonly<{ nodeId: NodeId; input: InputPortKey }>>>();
+      const next = byPort.get(e.from.output) ?? [];
+      next.push({ nodeId: e.to.nodeId, input: e.to.input });
+      byPort.set(e.from.output, next);
+      this.outgoingByNodeAndPort.set(e.from.nodeId, byPort);
+    }
+  }
+
+  next(nodeId: NodeId, output: OutputPortKey): Array<Readonly<{ nodeId: NodeId; input: InputPortKey }>> {
+    return this.outgoingByNodeAndPort.get(nodeId)?.get(output) ?? [];
+  }
+}

package/src/workflow/index.ts

@@ -0,0 +1,11 @@
+export { WorkflowBuilder } from "./dsl/WorkflowBuilder";
+export { ChainCursor } from "./dsl/ChainCursorResolver";
+export { WhenBuilder } from "./dsl/WhenBuilder";
+export * from "./dsl/workflowBuilderTypes";
+
+export { ConnectionInvocationIdFactory } from "./definition/ConnectionInvocationIdFactory";
+export { ConnectionNodeIdFactory } from "./definition/ConnectionNodeIdFactory";
+export { WorkflowExecutableNodeClassifier } from "./definition/WorkflowExecutableNodeClassifier";
+export * from "./definition/WorkflowExecutableNodeClassifierFactory";
+
+export { DefaultWorkflowGraphFactory } from "./graph/DefaultWorkflowGraphFactory";

package/src/workflowSnapshots/MissingRuntimeExecutionMarker.ts

@@ -0,0 +1,5 @@
+export class MissingRuntimeExecutionMarker {
+  isMarked(config: unknown): boolean {
+    return Boolean((config as Partial<{ missingRuntime: boolean }> | undefined)?.missingRuntime);
+  }
+}

package/src/workflowSnapshots/MissingRuntimeFallbacksFactory.ts

@@ -0,0 +1,27 @@
+import type { NodeDefinition, PersistedWorkflowSnapshotNode } from "../types";
+
+import { MissingRuntimeNodeConfig } from "./MissingRuntimeNodeConfig";
+import { MissingRuntimeNodeToken } from "./MissingRuntimeNodeToken";
+import { MissingRuntimeTriggerConfig } from "./MissingRuntimeTriggerConfig";
+import { MissingRuntimeTriggerToken } from "./MissingRuntimeTriggerToken";
+
+export class MissingRuntimeFallbacks {
+  createDefinition(snapshotNode: PersistedWorkflowSnapshotNode): NodeDefinition {
+    if (snapshotNode.kind === "trigger") {
+      return {
+        id: snapshotNode.id,
+        kind: "trigger",
+        name: snapshotNode.name,
+        type: MissingRuntimeTriggerToken,
+        config: new MissingRuntimeTriggerConfig(snapshotNode.name ?? snapshotNode.id, snapshotNode.nodeTokenId),
+      };
+    }
+    return {
+      id: snapshotNode.id,
+      kind: "node",
+      name: snapshotNode.name,
+      type: MissingRuntimeNodeToken,
+      config: new MissingRuntimeNodeConfig(snapshotNode.name ?? snapshotNode.id, snapshotNode.nodeTokenId),
+    };
+  }
+}

package/src/workflowSnapshots/MissingRuntimeNode.ts

@@ -0,0 +1,12 @@
+import type { Items, Node, NodeOutputs } from "../types";
+
+import { MissingRuntimeNodeConfig } from "./MissingRuntimeNodeConfig";
+
+export class MissingRuntimeNode implements Node<MissingRuntimeNodeConfig> {
+  readonly kind = "node" as const;
+  readonly outputPorts = ["main"] as const;
+
+  async execute(items: Items): Promise<NodeOutputs> {
+    return { main: items };
+  }
+}

package/src/workflowSnapshots/MissingRuntimeNodeConfig.ts

@@ -0,0 +1,14 @@
+import type { NodeConfigBase } from "../types";
+
+import { MissingRuntimeNodeToken } from "./MissingRuntimeNodeToken";
+
+export class MissingRuntimeNodeConfig implements NodeConfigBase {
+  readonly kind = "node" as const;
+  readonly type = MissingRuntimeNodeToken;
+
+  constructor(
+    public readonly name: string,
+    public readonly missingTokenId?: string,
+    public readonly missingRuntime = true,
+  ) {}
+}

package/src/workflowSnapshots/MissingRuntimeNodeToken.ts

@@ -0,0 +1 @@
+export class MissingRuntimeNodeToken {}

package/src/workflowSnapshots/MissingRuntimeTrigger.ts

@@ -0,0 +1,16 @@
+import type { ExecutableTriggerNode, Items, NodeOutputs, TriggerSetupContext } from "../types";
+
+import { MissingRuntimeTriggerConfig } from "./MissingRuntimeTriggerConfig";
+
+export class MissingRuntimeTrigger implements ExecutableTriggerNode<MissingRuntimeTriggerConfig> {
+  readonly kind = "trigger" as const;
+  readonly outputPorts = ["main"] as const;
+
+  async setup(_ctx: TriggerSetupContext<MissingRuntimeTriggerConfig>): Promise<undefined> {
+    return undefined;
+  }
+
+  async execute(items: Items): Promise<NodeOutputs> {
+    return { main: items };
+  }
+}

package/src/workflowSnapshots/MissingRuntimeTriggerConfig.ts

@@ -0,0 +1,14 @@
+import type { NodeConfigBase } from "../types";
+
+import { MissingRuntimeTriggerToken } from "./MissingRuntimeTriggerToken";
+
+export class MissingRuntimeTriggerConfig implements NodeConfigBase {
+  readonly kind = "trigger" as const;
+  readonly type = MissingRuntimeTriggerToken;
+
+  constructor(
+    public readonly name: string,
+    public readonly missingTokenId?: string,
+    public readonly missingRuntime = true,
+  ) {}
+}

package/src/workflowSnapshots/MissingRuntimeTriggerToken.ts

@@ -0,0 +1 @@
+export class MissingRuntimeTriggerToken {}

package/src/workflowSnapshots/PersistedRuntimeTypeIdFactory.ts

@@ -0,0 +1,19 @@
+import type { TypeToken } from "../di";
+
+import { getPersistedRuntimeTypeMetadata } from "../runtime-types/runtimeTypeDecorators.types";
+
+import type { PersistedTokenId } from "../types";
+
+export class PersistedRuntimeTypeIdFactory {
+  static fromMetadata(args: Readonly<{ type: TypeToken<unknown> }>): PersistedTokenId | undefined {
+    const metadata = getPersistedRuntimeTypeMetadata(args.type);
+    if (!metadata) {
+      return undefined;
+    }
+    const packageName = metadata.packageName;
+    if (!packageName) {
+      return undefined;
+    }
+    return `${packageName}::${metadata.persistedName}` as PersistedTokenId;
+  }
+}

package/src/workflowSnapshots/PersistedWorkflowTokenRegistry.ts

@@ -0,0 +1,89 @@
+import type { TypeToken } from "../di";
+
+import type { PersistedTokenId, WorkflowDefinition } from "../types";
+
+import { PersistedRuntimeTypeIdFactory } from "./PersistedRuntimeTypeIdFactory";
+
+export class PersistedWorkflowTokenRegistry {
+  private readonly tokensById = new Map<PersistedTokenId, TypeToken<unknown>>();
+  private readonly tokenIdsByToken = new Map<TypeToken<unknown>, PersistedTokenId>();
+
+  /**
+   * Register a token with its package ID. Token ID is inferred as `packageId::tokenName`.
+   */
+  register(type: TypeToken<unknown>, packageId: string, persistedNameOverride?: string): PersistedTokenId {
+    const tokenName = persistedNameOverride ?? this.displayNameForTypeToken(type);
+    const tokenId = `${packageId}::${tokenName}` as PersistedTokenId;
+    this.tokensById.set(tokenId, type);
+    this.tokenIdsByToken.set(type, tokenId);
+    return tokenId;
+  }
+
+  /**
+   * Register all decorated runtime types discovered in workflows.
+   */
+  registerFromWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void {
+    for (const workflow of workflows) {
+      for (const node of workflow.nodes) {
+        this.registerDecoratedType(node.type);
+        this.registerDecoratedType(node.config.type);
+        this.registerNestedTypes(node.config);
+      }
+    }
+  }
+
+  private registerDecoratedType(type: TypeToken<unknown>): void {
+    if (this.tokenIdsByToken.has(type)) {
+      return;
+    }
+    const tokenId = PersistedRuntimeTypeIdFactory.fromMetadata({ type });
+    if (!tokenId) {
+      return;
+    }
+    this.tokensById.set(tokenId, type);
+    this.tokenIdsByToken.set(type, tokenId);
+  }
+
+  private registerNestedTypes(value: unknown): void {
+    if (Array.isArray(value)) {
+      for (const entry of value) this.registerNestedTypes(entry);
+      return;
+    }
+    if (!value || typeof value !== "object") return;
+    const record = value as Record<string, unknown>;
+    const type = this.asTypeToken(record.type);
+    if (type) this.registerDecoratedType(type);
+    for (const v of Object.values(record)) this.registerNestedTypes(v);
+  }
+
+  private displayNameForTypeToken(token: TypeToken<unknown>): string {
+    if (typeof token === "function" && token.name) return token.name;
+    if (typeof token === "string") return token;
+    return "";
+  }
+
+  private asTypeToken(value: unknown): TypeToken<unknown> | undefined {
+    if (typeof value === "function" || typeof value === "string" || typeof value === "symbol") {
+      return value as TypeToken<unknown>;
+    }
+    return undefined;
+  }
+
+  getTokenId(token: TypeToken<unknown>): PersistedTokenId | undefined {
+    const existing = this.tokenIdsByToken.get(token);
+    if (existing) {
+      return existing;
+    }
+    const tokenId = PersistedRuntimeTypeIdFactory.fromMetadata({ type: token });
+    if (!tokenId) {
+      return undefined;
+    }
+    this.tokensById.set(tokenId, token);
+    this.tokenIdsByToken.set(token, tokenId);
+    return tokenId;
+  }
+
+  resolve(tokenId: PersistedTokenId): TypeToken<unknown> | undefined {
+    return this.tokensById.get(tokenId);
+  }
+}

package/src/workflowSnapshots/PersistedWorkflowTokenRegistryFactory.ts

@@ -0,0 +1,2 @@
+export { PersistedRuntimeTypeIdFactory } from "./PersistedRuntimeTypeIdFactory";
+export { PersistedWorkflowTokenRegistry } from "./PersistedWorkflowTokenRegistry";

package/src/workflowSnapshots/WorkflowSnapshotCodec.ts

@@ -0,0 +1,177 @@
+import type { TypeToken } from "../di";
+import type {
+  NodeConfigBase,
+  PersistedTokenId,
+  PersistedWorkflowSnapshot,
+  PersistedWorkflowSnapshotNode,
+  PersistedWorkflowTokenRegistryLike,
+  WorkflowDefinition,
+} from "../types";
+
+export class WorkflowSnapshotCodec {
+  constructor(private readonly tokenRegistry: PersistedWorkflowTokenRegistryLike) {}
+
+  create(workflow: WorkflowDefinition): PersistedWorkflowSnapshot {
+    return {
+      id: workflow.id,
+      name: workflow.name,
+      workflowErrorHandlerConfigured: workflow.workflowErrorHandler !== undefined,
+      ...(workflow.connections !== undefined && workflow.connections.length > 0
+        ? { connections: workflow.connections }
+        : {}),
+      nodes: workflow.nodes.map((node) => ({
+        id: node.id,
+        kind: node.kind,
+        name: node.name,
+        nodeTokenId: this.resolveTokenId(node.type),
+        configTokenId: this.resolveTokenId(node.config.type),
+        tokenName: this.resolveTokenName(node.type),
+        configTokenName: this.resolveTokenName(node.config.type),
+        config: this.serializeConfig(node.config),
+      })),
+      edges: workflow.edges.map((edge) => ({
+        from: { nodeId: edge.from.nodeId, output: edge.from.output },
+        to: { nodeId: edge.to.nodeId, input: edge.to.input },
+      })),
+    };
+  }
+
+  hydrate(snapshotNode: PersistedWorkflowSnapshotNode, liveConfig: NodeConfigBase): NodeConfigBase {
+    const hydrated = this.mergeValue(liveConfig, snapshotNode.config);
+    const configToken = this.tokenRegistry.resolve(snapshotNode.configTokenId);
+    Object.assign(hydrated, {
+      type: configToken ?? liveConfig.type,
+      kind: snapshotNode.kind,
+    });
+    if (snapshotNode.name && !("name" in hydrated && hydrated.name)) {
+      Object.assign(hydrated, { name: snapshotNode.name });
+    }
+    return hydrated as unknown as NodeConfigBase;
+  }
+
+  private serializeConfig(config: NodeConfigBase): unknown {
+    try {
+      const cloned = JSON.parse(JSON.stringify(config)) as Record<string, unknown>;
+      this.injectTokenIds(cloned, config as unknown as Record<string, unknown>);
+      return cloned;
+    } catch {
+      const fallback: Record<string, unknown> = {
+        kind: config.kind,
+        name: config.name,
+        id: config.id,
+        icon: config.icon,
+        execution: config.execution,
+      };
+      this.injectTokenIds(fallback, config as unknown as Record<string, unknown>);
+      return fallback;
+    }
+  }
+
+  private injectTokenIds(target: Record<string, unknown>, source: Record<string, unknown>): void {
+    const type = this.asTypeToken(source.type);
+    if (type) {
+      target.tokenId = this.tokenRegistry.getTokenId(type) ?? this.resolveTokenName(type) ?? "unknown";
+    }
+    for (const [key, value] of Object.entries(source)) {
+      if (key === "type" || value == null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        const targetArray = target[key];
+        if (Array.isArray(targetArray)) {
+          value.forEach((item, index) => {
+            if (item && typeof item === "object" && targetArray[index] && typeof targetArray[index] === "object") {
+              this.injectTokenIds(targetArray[index] as Record<string, unknown>, item as Record<string, unknown>);
+            }
+          });
+        }
+        continue;
+      }
+      if (typeof value === "object") {
+        const targetValue = target[key];
+        if (targetValue && typeof targetValue === "object") {
+          this.injectTokenIds(targetValue as Record<string, unknown>, value as Record<string, unknown>);
+        }
+      }
+    }
+  }
+
+  private mergeValue(liveValue: unknown, snapshotValue: unknown): Record<string, unknown> {
+    const liveRecord = this.asRecord(liveValue);
+    const snapshotRecord = this.asRecord(snapshotValue);
+    const hydrated = Object.create(
+      liveValue && typeof liveValue === "object"
+        ? (Object.getPrototypeOf(liveValue) ?? Object.prototype)
+        : Object.prototype,
+    ) as Record<string, unknown>;
+
+    for (const [key, value] of Object.entries(snapshotRecord)) {
+      hydrated[key] = this.mergeNestedValue(liveRecord[key], value);
+    }
+
+    this.restoreNonSerializableProperties(liveRecord, hydrated);
+    this.restoreTypeProperty(hydrated);
+    return hydrated;
+  }
+
+  private mergeNestedValue(liveValue: unknown, snapshotValue: unknown): unknown {
+    if (Array.isArray(snapshotValue)) {
+      const liveArray = Array.isArray(liveValue) ? liveValue : [];
+      return snapshotValue.map((entry, index) => this.mergeNestedValue(liveArray[index], entry));
+    }
+    if (snapshotValue && typeof snapshotValue === "object") {
+      return this.mergeValue(liveValue, snapshotValue);
+    }
+    return snapshotValue;
+  }
+
+  private restoreNonSerializableProperties(
+    liveRecord: Record<string, unknown>,
+    hydrated: Record<string, unknown>,
+  ): void {
+    for (const [key, value] of Object.entries(liveRecord)) {
+      if (typeof value === "function" || typeof value === "symbol") {
+        hydrated[key] = value;
+      }
+    }
+  }
+
+  private restoreTypeProperty(record: Record<string, unknown>): void {
+    const tokenId = typeof record.tokenId === "string" ? record.tokenId : undefined;
+    if (!tokenId) {
+      return;
+    }
+    const type = this.tokenRegistry.resolve(tokenId as PersistedTokenId);
+    if (type) {
+      record.type = type;
+    }
+  }
+
+  private resolveTokenId(token: TypeToken<unknown>): PersistedTokenId {
+    return (this.tokenRegistry.getTokenId(token) ?? this.resolveTokenName(token) ?? "unknown") as PersistedTokenId;
+  }
+
+  private resolveTokenName(token: TypeToken<unknown>): string | undefined {
+    if (typeof token === "function" && token.name) {
+      return token.name;
+    }
+    if (typeof token === "string") {
+      return token;
+    }
+    return undefined;
+  }
+
+  private asTypeToken(value: unknown): TypeToken<unknown> | undefined {
+    if (typeof value === "function" || typeof value === "string" || typeof value === "symbol") {
+      return value as TypeToken<unknown>;
+    }
+    return undefined;
+  }
+
+  private asRecord(value: unknown): Record<string, unknown> {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return {};
+    }
+    return { ...(value as Record<string, unknown>) };
+  }
+}

package/src/workflowSnapshots/WorkflowSnapshotResolver.ts

@@ -0,0 +1,102 @@
+import type { TypeToken } from "../di";
+import type {
+  NodeDefinition,
+  PersistedWorkflowSnapshot,
+  PersistedWorkflowTokenRegistryLike,
+  WorkflowDefinition,
+  WorkflowId,
+  WorkflowRepository,
+} from "../types";
+
+import { MissingRuntimeFallbacks } from "./MissingRuntimeFallbacksFactory";
+import { WorkflowSnapshotCodec } from "./WorkflowSnapshotCodec";
+
+export class WorkflowSnapshotResolver {
+  constructor(
+    private readonly workflowRepository: WorkflowRepository,
+    private readonly tokenRegistry: PersistedWorkflowTokenRegistryLike,
+    private readonly codec: WorkflowSnapshotCodec,
+    private readonly missingRuntimeFallbacks: MissingRuntimeFallbacks,
+  ) {}
+
+  resolve(args: {
+    workflowId: WorkflowId;
+    workflowSnapshot?: PersistedWorkflowSnapshot;
+  }): WorkflowDefinition | undefined {
+    const liveWorkflow = this.workflowRepository.get(args.workflowId);
+    if (!args.workflowSnapshot) {
+      return liveWorkflow;
+    }
+    if (!liveWorkflow) {
+      return this.rebuildWorkflow(args.workflowSnapshot, undefined);
+    }
+    return this.rebuildWorkflow(args.workflowSnapshot, liveWorkflow);
+  }
+
+  private rebuildWorkflow(
+    snapshot: PersistedWorkflowSnapshot,
+    liveWorkflow: WorkflowDefinition | undefined,
+  ): WorkflowDefinition {
+    const liveNodesById = new Map((liveWorkflow?.nodes ?? []).map((node) => [node.id, node] as const));
+    const nodes = snapshot.nodes.map((snapshotNode) => {
+      const liveNode = liveNodesById.get(snapshotNode.id);
+      if (!this.isCompatibleLiveNode(liveNode, snapshotNode)) {
+        return this.missingRuntimeFallbacks.createDefinition(snapshotNode);
+      }
+      return {
+        id: snapshotNode.id,
+        kind: snapshotNode.kind,
+        name: snapshotNode.name ?? liveNode.name,
+        type: liveNode.type,
+        config: this.codec.hydrate(snapshotNode, liveNode.config),
+      } satisfies NodeDefinition;
+    });
+    const nodeIds = new Set(nodes.map((node) => node.id));
+    const connectionsFromSnapshot =
+      snapshot.connections
+        ?.map((connection) => ({
+          ...connection,
+          childNodeIds: connection.childNodeIds.filter((childId) => nodeIds.has(childId)),
+        }))
+        .filter((connection) => connection.childNodeIds.length > 0) ?? [];
+    return {
+      id: snapshot.id,
+      name: snapshot.name,
+      nodes,
+      edges: snapshot.edges.filter((edge) => nodeIds.has(edge.from.nodeId) && nodeIds.has(edge.to.nodeId)),
+      ...(connectionsFromSnapshot.length > 0 ? { connections: connectionsFromSnapshot } : {}),
+      ...(liveWorkflow?.discoveryPathSegments !== undefined
+        ? { discoveryPathSegments: liveWorkflow.discoveryPathSegments }
+        : {}),
+    };
+  }
+
+  private isCompatibleLiveNode(
+    liveNode: WorkflowDefinition["nodes"][number] | undefined,
+    snapshotNode: PersistedWorkflowSnapshot["nodes"][number],
+  ): liveNode is WorkflowDefinition["nodes"][number] {
+    if (!liveNode || liveNode.kind !== snapshotNode.kind) {
+      return false;
+    }
+    if (!snapshotNode.nodeTokenId || !snapshotNode.configTokenId) {
+      throw new Error(`Persisted workflow snapshot node "${snapshotNode.id}" is missing stable token ids.`);
+    }
+    const liveNodeTokenId = this.resolveLiveTokenId(liveNode.type);
+    const liveConfigTokenId = this.resolveLiveTokenId(liveNode.config.type);
+    return liveNodeTokenId === snapshotNode.nodeTokenId && liveConfigTokenId === snapshotNode.configTokenId;
+  }
+
+  private resolveLiveTokenId(type: TypeToken<unknown>): string | undefined {
+    const registeredTokenId = this.tokenRegistry.getTokenId(type);
+    if (registeredTokenId) {
+      return registeredTokenId;
+    }
+    if (typeof type === "function" && type.name) {
+      return type.name;
+    }
+    if (typeof type === "string") {
+      return type;
+    }
+    return undefined;
+  }
+}

package/src/workflowSnapshots/index.ts

@@ -0,0 +1,12 @@
+export { MissingRuntimeExecutionMarker } from "./MissingRuntimeExecutionMarker";
+export { MissingRuntimeFallbacks } from "./MissingRuntimeFallbacksFactory";
+export { MissingRuntimeNode } from "./MissingRuntimeNode";
+export { MissingRuntimeNodeConfig } from "./MissingRuntimeNodeConfig";
+export { MissingRuntimeNodeToken } from "./MissingRuntimeNodeToken";
+export { MissingRuntimeTrigger } from "./MissingRuntimeTrigger";
+export { MissingRuntimeTriggerConfig } from "./MissingRuntimeTriggerConfig";
+export { MissingRuntimeTriggerToken } from "./MissingRuntimeTriggerToken";
+export { PersistedRuntimeTypeIdFactory } from "./PersistedRuntimeTypeIdFactory";
+export { PersistedWorkflowTokenRegistry } from "./PersistedWorkflowTokenRegistryFactory";
+export { WorkflowSnapshotCodec } from "./WorkflowSnapshotCodec";
+export { WorkflowSnapshotResolver } from "./WorkflowSnapshotResolver";

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "lib": ["ES2022"],
+    "types": ["node"],
+    "noEmit": true
+  },
+  "include": ["src/**/*.ts"]
+}

package/tsdown.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: ["src/index.ts", "src/testing.ts", "src/bootstrap/index.ts"],
+  outDir: "dist",
+  clean: false,
+  dts: true,
+  format: ["esm", "cjs"],
+  sourcemap: true,
+});