@platforma-sdk/model 1.57.2 → 1.58.1

package/src/block_model_legacy.ts

@@ -452,6 +452,7 @@ export class BlockModel<
               },
             ]),
           ),
+          pluginIds: [],
         },
       };
   }

package/src/block_storage.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from "vitest";
 import {
   BLOCK_STORAGE_KEY,
   BLOCK_STORAGE_SCHEMA_VERSION,
-  DATA_MODEL_DEFAULT_VERSION,
+  DATA_MODEL_LEGACY_VERSION,
   createBlockStorage,
   getPluginData,
   getStorageData,
@@ -14,6 +14,7 @@ import {
   type PluginName,
   type PluginRegistry,
 } from "./block_storage";
+import type { PluginHandle } from "./plugin_handle";
 
 describe("BlockStorage", () => {
   describe("BLOCK_STORAGE_KEY and BLOCK_STORAGE_SCHEMA_VERSION", () => {
@@ -71,7 +72,7 @@ describe("BlockStorage", () => {
     it("should create storage with discriminator key and default values", () => {
       const storage = createBlockStorage();
       expect(storage[BLOCK_STORAGE_KEY]).toBe(BLOCK_STORAGE_SCHEMA_VERSION);
-      expect(storage.__dataVersion).toBe(DATA_MODEL_DEFAULT_VERSION);
+      expect(storage.__dataVersion).toBe(DATA_MODEL_LEGACY_VERSION);
       expect(storage.__data).toEqual({});
     });
 
@@ -79,7 +80,7 @@ describe("BlockStorage", () => {
       const data = { numbers: [1, 2, 3] };
       const storage = createBlockStorage(data);
       expect(storage[BLOCK_STORAGE_KEY]).toBe(BLOCK_STORAGE_SCHEMA_VERSION);
-      expect(storage.__dataVersion).toBe(DATA_MODEL_DEFAULT_VERSION);
+      expect(storage.__dataVersion).toBe(DATA_MODEL_LEGACY_VERSION);
       expect(storage.__data).toEqual(data);
     });
 
@@ -135,7 +136,7 @@ describe("BlockStorage", () => {
       const legacyData = { numbers: [1, 2, 3], name: "test" };
       const normalized = normalizeBlockStorage(legacyData);
       expect(normalized[BLOCK_STORAGE_KEY]).toBe(BLOCK_STORAGE_SCHEMA_VERSION);
-      expect(normalized.__dataVersion).toBe(DATA_MODEL_DEFAULT_VERSION);
+      expect(normalized.__dataVersion).toBe(DATA_MODEL_LEGACY_VERSION);
       expect(normalized.__data).toEqual(legacyData);
       expect(normalized.__pluginRegistry).toEqual({});
       expect(normalized.__plugins).toEqual({});
@@ -144,14 +145,14 @@ describe("BlockStorage", () => {
     it("should wrap primitive legacy data", () => {
       const normalized = normalizeBlockStorage("simple string");
       expect(normalized[BLOCK_STORAGE_KEY]).toBe(BLOCK_STORAGE_SCHEMA_VERSION);
-      expect(normalized.__dataVersion).toBe(DATA_MODEL_DEFAULT_VERSION);
+      expect(normalized.__dataVersion).toBe(DATA_MODEL_LEGACY_VERSION);
       expect(normalized.__data).toBe("simple string");
     });
 
     it("should wrap null legacy data", () => {
       const normalized = normalizeBlockStorage(null);
       expect(normalized[BLOCK_STORAGE_KEY]).toBe(BLOCK_STORAGE_SCHEMA_VERSION);
-      expect(normalized.__dataVersion).toBe(DATA_MODEL_DEFAULT_VERSION);
+      expect(normalized.__dataVersion).toBe(DATA_MODEL_LEGACY_VERSION);
       expect(normalized.__data).toBeNull();
     });
   });
@@ -187,7 +188,7 @@ describe("BlockStorage", () => {
       });
       expect(storage.__plugins).toEqual({
         table1: {
-          __dataVersion: DATA_MODEL_DEFAULT_VERSION,
+          __dataVersion: DATA_MODEL_LEGACY_VERSION,
           __data: { columns: ["a", "b"] },
         },
       });
@@ -215,11 +216,11 @@ describe("BlockStorage", () => {
         pluginId: "chart1",
         value: { type: "bar" },
       });
-      expect(getPluginData(storage, "chart1")).toEqual({ type: "bar" });
+      expect(getPluginData(storage, "chart1" as PluginHandle)).toEqual({ type: "bar" });
     });
 
     it("getPluginData should throw for missing plugin", () => {
-      expect(() => getPluginData(baseStorage, "nonexistent")).toThrow(
+      expect(() => getPluginData(baseStorage, "nonexistent" as PluginHandle)).toThrow(
         "Plugin 'nonexistent' not found in block storage",
       );
     });
@@ -253,7 +254,7 @@ describe("BlockStorage", () => {
         value: { foo: "bar" },
       });
       expect(updated.__plugins?.plugin1).toEqual({
-        __dataVersion: DATA_MODEL_DEFAULT_VERSION,
+        __dataVersion: DATA_MODEL_LEGACY_VERSION,
         __data: { foo: "bar" },
       });
     });

package/src/block_storage.ts

@@ -10,7 +10,8 @@
  */
 
 import type { Branded } from "@milaboratories/pl-model-common";
-import type { DataMigrationResult, DataVersioned } from "./block_migrations";
+import type { DataVersioned } from "./block_migrations";
+import type { PluginHandle, PluginFactoryLike, InferFactoryData } from "./plugin_handle";
 
 // =============================================================================
 // Core Types
@@ -32,7 +33,7 @@ export const BLOCK_STORAGE_SCHEMA_VERSION = "v1";
  * Default data version for new blocks without migrations.
  * Unique identifier ensures blocks are created via DataModel API.
  */
-export const DATA_MODEL_DEFAULT_VERSION = "__pl_v1_d4e8f2a1__";
+export const DATA_MODEL_LEGACY_VERSION = "__pl_v1_d4e8f2a1__";
 
 /**
  * Type for valid schema versions
@@ -50,7 +51,7 @@ export type PluginName = Branded<string, "PluginName">;
  * Plugin registry - maps pluginId (unique within a block) to pluginName (globally unique plugin type).
  * Using a Record highlights that pluginIds must be unique within a block.
  */
-export type PluginRegistry = Record<string, PluginName>;
+export type PluginRegistry = Record<PluginHandle, PluginName>;
 
 /**
  * Versioned data - used for both block data and plugin data
@@ -75,8 +76,8 @@ export type BlockStorage<TState = unknown> = {
   readonly [BLOCK_STORAGE_KEY]: BlockStorageSchemaVersion;
   /** Registry of plugins: pluginId -> pluginName */
   __pluginRegistry?: PluginRegistry;
-  /** Plugin-specific data, keyed by pluginId */
-  __plugins?: Record<string, VersionedData<unknown>>;
+  /** Plugin-specific data, keyed by plugin handle */
+  __plugins?: Record<PluginHandle, VersionedData<unknown>>;
 } & VersionedData<TState>;
 
 /**
@@ -99,12 +100,12 @@ export function isBlockStorage(value: unknown): value is BlockStorage {
  * Creates a BlockStorage with the given initial data
  *
  * @param initialData - The initial data value (defaults to empty object)
- * @param version - The initial data version key (defaults to DATA_MODEL_DEFAULT_VERSION)
+ * @param version - The initial data version key (defaults to DATA_MODEL_LEGACY_VERSION)
  * @returns A new BlockStorage instance with discriminator key
  */
 export function createBlockStorage<TState = unknown>(
   initialData: TState = {} as TState,
-  version: string = DATA_MODEL_DEFAULT_VERSION,
+  version: string = DATA_MODEL_LEGACY_VERSION,
 ): BlockStorage<TState> {
   return {
     [BLOCK_STORAGE_KEY]: BLOCK_STORAGE_SCHEMA_VERSION,
@@ -131,7 +132,7 @@ export function normalizeBlockStorage<TState = unknown>(raw: unknown): BlockStor
       // Fix for early released version where __dataVersion was a number
       __dataVersion:
         typeof storage.__dataVersion === "number"
-          ? DATA_MODEL_DEFAULT_VERSION
+          ? DATA_MODEL_LEGACY_VERSION
           : storage.__dataVersion,
       // Ensure plugin fields have defaults
       __pluginRegistry: storage.__pluginRegistry ?? {},
@@ -176,7 +177,7 @@ export function deriveDataFromStorage<TData = unknown>(rawStorage: unknown): TDa
 /** Payload for storage mutation operations. SDK defines specific operations. */
 export type MutateStoragePayload<T = unknown> =
   | { operation: "update-block-data"; value: T }
-  | { operation: "update-plugin-data"; pluginId: string; value: unknown };
+  | { operation: "update-plugin-data"; pluginId: PluginHandle; value: unknown };
 
 /**
  * Updates the data in BlockStorage (immutable)
@@ -196,7 +197,7 @@ export function updateStorageData<TValue = unknown>(
       const { pluginId, value } = payload;
       const currentPlugins = storage.__plugins ?? {};
       const existingEntry = currentPlugins[pluginId];
-      const version = existingEntry?.__dataVersion ?? DATA_MODEL_DEFAULT_VERSION;
+      const version = existingEntry?.__dataVersion ?? DATA_MODEL_LEGACY_VERSION;
       return {
         ...storage,
         __plugins: {
@@ -257,17 +258,17 @@ export type MigrationResult<TState> = MigrationSuccess<TState> | MigrationFailur
  * Conversion to internal VersionedData format is handled by migrateBlockStorage().
  */
 export interface MigrateBlockStorageConfig {
-  /** Migrate block data from any version to latest */
-  migrateBlockData: (versioned: DataVersioned<unknown>) => DataMigrationResult<unknown>;
-  /** Migrate each plugin's data. Return undefined to remove the plugin. */
+  /** Migrate block data from any version to latest. Throws on failure. */
+  migrateBlockData: (versioned: DataVersioned<unknown>) => DataVersioned<unknown>;
+  /** Migrate each plugin's data. Return undefined to remove the plugin. Throws on failure. */
   migratePluginData: (
-    pluginId: string,
+    handle: PluginHandle,
     versioned: DataVersioned<unknown>,
-  ) => DataMigrationResult<unknown> | undefined;
+  ) => DataVersioned<unknown> | undefined;
   /** The new plugin registry after migration (pluginId -> pluginName) */
   newPluginRegistry: PluginRegistry;
   /** Factory to create initial data for new plugins */
-  createPluginData: (pluginId: string) => DataVersioned<unknown>;
+  createPluginData: (handle: PluginHandle) => DataVersioned<unknown>;
 }
 
 /**
@@ -334,33 +335,34 @@ export function migrateBlockStorage(
   // Step 2: Migrate plugins
   const oldPlugins = storage.__plugins ?? {};
   const oldRegistry = storage.__pluginRegistry ?? {};
-  const newPlugins: Record<string, VersionedData<unknown>> = {};
+  const newPlugins: Record<PluginHandle, VersionedData<unknown>> = {};
 
-  for (const [pluginId, pluginName] of Object.entries(newPluginRegistry)) {
-    const existingEntry = oldPlugins[pluginId];
-    const existingName = oldRegistry[pluginId];
+  for (const [key, pluginName] of Object.entries(newPluginRegistry)) {
+    const handle = key as PluginHandle;
+    const existingEntry = oldPlugins[handle];
+    const existingName = oldRegistry[handle];
 
     try {
       if (existingEntry && existingName === pluginName) {
         // Plugin exists with same type - migrate its data
-        const migrated = migratePluginData(pluginId, {
+        const migrated = migratePluginData(handle, {
           version: existingEntry.__dataVersion,
           data: existingEntry.__data,
         });
         if (migrated) {
-          newPlugins[pluginId] = { __dataVersion: migrated.version, __data: migrated.data };
+          newPlugins[handle] = { __dataVersion: migrated.version, __data: migrated.data };
         }
         // If undefined returned, plugin is intentionally removed
       } else {
         // New plugin or type changed - create with initial data
-        const initial = createPluginData(pluginId);
-        newPlugins[pluginId] = { __dataVersion: initial.version, __data: initial.data };
+        const initial = createPluginData(handle);
+        newPlugins[handle] = { __dataVersion: initial.version, __data: initial.data };
       }
     } catch (error) {
       return {
         success: false,
         error: error instanceof Error ? error.message : String(error),
-        failedAt: pluginId,
+        failedAt: handle,
       };
     }
   }
@@ -384,14 +386,20 @@ export function migrateBlockStorage(
  * Gets plugin-specific data from block storage.
  * Accepts raw storage (any format) and normalizes internally.
  *
+ * When called with a typed PluginHandle<F>, the return type is automatically
+ * inferred from the factory's phantom `__types.data` field.
+ *
  * @param rawStorage - Raw block storage (may be legacy format or BlockStorage)
- * @param pluginId - The plugin instance id
- * @returns The plugin data
- * @throws If pluginId is not found in storage
+ * @param handle - The plugin handle (branded plugin instance id)
+ * @returns The plugin data, typed via factory inference
+ * @throws If plugin is not found in storage
  */
-export function getPluginData<TData = unknown>(rawStorage: unknown, pluginId: string): TData {
+export function getPluginData<F extends PluginFactoryLike>(
+  rawStorage: unknown,
+  handle: PluginHandle<F>,
+): InferFactoryData<F> {
   const storage = normalizeBlockStorage(rawStorage);
-  const pluginEntry = storage.__plugins?.[pluginId];
-  if (!pluginEntry) throw new Error(`Plugin '${pluginId}' not found in block storage`);
-  return pluginEntry.__data as TData;
+  const pluginEntry = storage.__plugins?.[handle];
+  if (!pluginEntry) throw new Error(`Plugin '${handle}' not found in block storage`);
+  return pluginEntry.__data as InferFactoryData<F>;
 }

package/src/block_storage_callbacks.ts

@@ -24,9 +24,10 @@ import {
   normalizeBlockStorage,
   updateStorageData,
 } from "./block_storage";
+import type { PluginHandle } from "./plugin_handle";
 
 import { stringifyJson, type StringifiedJson } from "@milaboratories/pl-model-common";
-import type { DataMigrationResult, DataVersioned } from "./block_migrations";
+import type { DataVersioned } from "./block_migrations";
 
 // =============================================================================
 // Hook interfaces for dependency injection
@@ -34,20 +35,20 @@ import type { DataMigrationResult, DataVersioned } from "./block_migrations";
 
 /** Dependencies for storage migration */
 export interface MigrationHooks {
-  migrateBlockData: (versioned: DataVersioned<unknown>) => DataMigrationResult<unknown>;
+  migrateBlockData: (versioned: DataVersioned<unknown>) => DataVersioned<unknown>;
   getPluginRegistry: () => PluginRegistry;
   migratePluginData: (
-    pluginId: string,
+    handle: PluginHandle,
     versioned: DataVersioned<unknown>,
-  ) => DataMigrationResult<unknown> | undefined;
-  createPluginData: (pluginId: string) => DataVersioned<unknown>;
+  ) => DataVersioned<unknown> | undefined;
+  createPluginData: (handle: PluginHandle) => DataVersioned<unknown>;
 }
 
 /** Dependencies for initial storage creation */
 export interface InitialStorageHooks {
   getDefaultBlockData: () => DataVersioned<unknown>;
   getPluginRegistry: () => PluginRegistry;
-  createPluginData: (pluginId: string) => DataVersioned<unknown>;
+  createPluginData: (handle: PluginHandle) => DataVersioned<unknown>;
 }
 
 /**
@@ -228,15 +229,16 @@ export function migrateStorage(
  *
  * @param hooks - Dependencies for creating initial block and plugin data
  * @returns Initial storage as branded JSON string
+ * @throws If initialDataFn or createPluginData throws
  */
 export function createInitialStorage(hooks: InitialStorageHooks): StringifiedJson<BlockStorage> {
   const blockDefault = hooks.getDefaultBlockData();
   const pluginRegistry = hooks.getPluginRegistry();
 
-  const plugins: Record<string, VersionedData<unknown>> = {};
-  for (const pluginId of Object.keys(pluginRegistry)) {
-    const initial = hooks.createPluginData(pluginId);
-    plugins[pluginId] = { __dataVersion: initial.version, __data: initial.data };
+  const plugins: Record<PluginHandle, VersionedData<unknown>> = {};
+  for (const handle of Object.keys(pluginRegistry) as PluginHandle[]) {
+    const initial = hooks.createPluginData(handle);
+    plugins[handle] = { __dataVersion: initial.version, __data: initial.data };
   }
 
   const storage: BlockStorage = {

package/src/components/PFrameForGraphs.ts

@@ -1,55 +1,9 @@
-import type {
-  AxisId,
-  AxisSpecNormalized,
-  CanonicalizedJson,
-  PColumn,
-  PColumnSpec,
-  PFrameHandle,
-  PObjectId,
-} from "@milaboratories/pl-model-common";
-import {
-  Annotation,
-  canonicalizeJson,
-  getAxisId,
-  getColumnIdAndSpec,
-  LinkerMap,
-  matchAxisId,
-  readAnnotation,
-  readAnnotationJson,
-  stringifyJson,
-} from "@milaboratories/pl-model-common";
+import type { PColumn, PColumnSpec, PFrameHandle } from "@milaboratories/pl-model-common";
+import { Annotation, readAnnotationJson } from "@milaboratories/pl-model-common";
 import type { PColumnDataUniversal, RenderCtxBase } from "../render";
 import { getAllRelatedColumns, getRelatedColumns } from "../pframe_utils/columns";
-
-/** Create id for column copy with added keys in axes domains */
-const colId = (id: PObjectId, domains: (Record<string, string> | undefined)[]) => {
-  let wid = id.toString();
-  domains?.forEach((domain) => {
-    if (domain) {
-      for (const [k, v] of Object.entries(domain)) {
-        wid += k;
-        wid += v;
-      }
-    }
-  });
-  return wid;
-};
-
-/** All combinations with 1 key from each list */
-function getKeysCombinations(idsLists: AxisId[][]) {
-  if (!idsLists.length) {
-    return [];
-  }
-  let result: AxisId[][] = [[]];
-  idsLists.forEach((list) => {
-    const nextResult: AxisId[][] = [];
-    list.forEach((key) => {
-      nextResult.push(...result.map((resultItem) => [...resultItem, key]));
-    });
-    result = nextResult;
-  });
-  return result;
-}
+export type { AxesVault } from "../pframe_utils/axes";
+export { enrichCompatible, getAvailableWithLinkersAxes } from "../pframe_utils/axes";
 
 export function isHiddenFromGraphColumn(column: PColumnSpec): boolean {
   return !!readAnnotationJson(column, Annotation.HideDataFromGraphs);
@@ -59,123 +13,6 @@ export function isHiddenFromUIColumn(column: PColumnSpec): boolean {
   return !!readAnnotationJson(column, Annotation.HideDataFromUi);
 }
 
-export type AxesVault = Map<CanonicalizedJson<AxisId>, AxisSpecNormalized>;
-
-export function getAvailableWithLinkersAxes(
-  linkerColumns: PColumn<PColumnDataUniversal>[],
-  blockAxes: AxesVault,
-): AxesVault {
-  const linkerMap = LinkerMap.fromColumns(linkerColumns.map(getColumnIdAndSpec));
-  const availableAxes = linkerMap.getReachableByLinkersAxesFromAxesNormalized(
-    [...blockAxes.values()],
-    (linkerKeyId, sourceAxisId) => matchAxisId(sourceAxisId, linkerKeyId),
-  );
-
-  return new Map(
-    availableAxes.map((axisSpec) => {
-      const id = getAxisId(axisSpec);
-      return [canonicalizeJson(id), axisSpec];
-    }),
-  );
-}
-/** Add columns with fully compatible axes created from partial compatible ones */
-export function enrichCompatible<T extends Omit<PColumn<PColumnDataUniversal>, "data">>(
-  blockAxes: AxesVault,
-  columns: T[],
-): T[] {
-  return columns.flatMap((column) => getAdditionalColumnsForColumn(blockAxes, column));
-}
-
-function getAdditionalColumnsForColumn<T extends Omit<PColumn<PColumnDataUniversal>, "data">>(
-  blockAxes: AxesVault,
-  column: T,
-): T[] {
-  const columnAxesIds = column.spec.axesSpec.map(getAxisId);
-
-  if (columnAxesIds.every((id) => blockAxes.has(canonicalizeJson(id)))) {
-    return [column]; // the column is compatible with its own domains without modifications
-  }
-
-  // options with different possible domains for every axis of secondary column
-  const secondaryIdsOptions = columnAxesIds.map((id) => {
-    const result = [];
-    for (const [_, mainId] of blockAxes) {
-      if (matchAxisId(mainId, id) && !matchAxisId(id, mainId)) {
-        result.push(mainId);
-      }
-    }
-    return result;
-  });
-  // all possible combinations of axes with added domains
-  const secondaryIdsVariants = getKeysCombinations(secondaryIdsOptions);
-
-  // sets of added to column domain fields
-  const allAddedDomainValues = new Set<string>();
-  const addedNotToAllVariantsDomainValues = new Set<string>();
-  const addedByVariantsDomainValues = secondaryIdsVariants.map((idsList) => {
-    const addedSet = new Set<string>();
-    idsList.map((axisId, idx) => {
-      const d1 = column.spec.axesSpec[idx].domain;
-      const d2 = axisId.domain;
-      Object.entries(d2 ?? {}).forEach(([key, value]) => {
-        if (d1?.[key] === undefined) {
-          const item = JSON.stringify([key, value]);
-          addedSet.add(item);
-          allAddedDomainValues.add(item);
-        }
-      });
-      return {
-        ...axisId,
-        annotations: column.spec.axesSpec[idx].annotations,
-      };
-    });
-    return addedSet;
-  });
-  [...allAddedDomainValues].forEach((addedPart) => {
-    if (addedByVariantsDomainValues.some((s) => !s.has(addedPart))) {
-      addedNotToAllVariantsDomainValues.add(addedPart);
-    }
-  });
-
-  const additionalColumns = secondaryIdsVariants.map((idsList, idx) => {
-    const id = colId(
-      column.id,
-      idsList.map((id) => id.domain),
-    );
-
-    const label = readAnnotation(column.spec, Annotation.Label) ?? "";
-    const labelDomainPart = [...addedByVariantsDomainValues[idx]]
-      .filter((str) => addedNotToAllVariantsDomainValues.has(str))
-      .sort()
-      .map((v) => JSON.parse(v)?.[1]) // use in labels only domain values, but sort them by key to save the same order in all column variants
-      .join(" / ");
-
-    const annotations: Annotation = {
-      ...column.spec.annotations,
-      [Annotation.Graph.IsVirtual]: stringifyJson(true),
-    };
-    if (label || labelDomainPart) {
-      annotations[Annotation.Label] =
-        label && labelDomainPart ? label + " / " + labelDomainPart : label + labelDomainPart;
-    }
-
-    return {
-      ...column,
-      id: id as PObjectId,
-      spec: {
-        ...column.spec,
-        axesSpec: idsList.map((axisId, idx) => ({
-          ...axisId,
-          annotations: column.spec.axesSpec[idx].annotations,
-        })),
-        annotations,
-      },
-    };
-  });
-
-  return [column, ...additionalColumns];
-}
-
 /**
  The aim of createPFrameForGraphs: to create pframe with block’s columns and all compatible columns from result pool
  (including linker columns and all label columns).

package/src/index.ts

@@ -1,6 +1,27 @@
 export * from "./block_state_patch";
 export * from "./block_state_util";
-export * from "./block_storage";
+export * from "./plugin_handle";
+export {
+  type BlockStorageSchemaVersion,
+  type PluginName,
+  type PluginRegistry,
+  type VersionedData,
+  type BlockStorage,
+  isBlockStorage,
+  createBlockStorage,
+  normalizeBlockStorage,
+  getStorageData,
+  deriveDataFromStorage,
+  type MutateStoragePayload,
+  updateStorageData,
+  type StorageDebugView,
+  type MigrationSuccess,
+  type MigrationFailure,
+  type MigrationResult,
+  type MigrateBlockStorageConfig,
+  migrateBlockStorage,
+  getPluginData,
+} from "./block_storage";
 export * from "./block_storage_facade";
 export * from "./block_model_legacy";
 export { BlockModelV3 } from "./block_model";
@@ -8,13 +29,14 @@ export type { PluginInstance, ParamsInput } from "./block_model";
 export {
   DataModel,
   DataModelBuilder,
+  DataMigrationError,
   DataUnrecoverableError,
   isDataUnrecoverableError,
   defaultRecover,
   makeDataVersioned,
 } from "./block_migrations";
 export type { LegacyV1State } from "./block_migrations";
-export { PluginModel } from "./plugin_model";
+export * from "./plugin_model";
 export * from "./bconfig";
 export * from "./components";
 export * from "./config";