agentlang 0.7.3 → 0.7.4

package/src/runtime/loader.ts

@@ -77,6 +77,7 @@ import {
   isFqName,
   makeFqName,
   maybeExtends,
+  objectAsString,
   preprocessRawConfig,
   registerInitFunction,
   rootRef,
@@ -342,6 +343,40 @@ export async function flushAllAndLoad(
   return await load(fileName, fsOptions, callback);
 }
 
+async function evaluateConfigPatterns(cfgPats: string): Promise<any> {
+  const cfgWf = `workflow createConfig{\n${cfgPats}}`;
+  const wf = await parseWorkflow(cfgWf);
+  const cfgStmts = new Array<Statement>();
+  const initInsts = new Array<Statement>();
+  for (let i = 0; i < wf.statements.length; ++i) {
+    const stmt: Statement = wf.statements[i];
+    if (stmt.pattern.crudMap) {
+      initInsts.push(await makeDeleteAllConfigStatement(stmt.pattern.crudMap));
+      initInsts.push(stmt);
+    } else {
+      cfgStmts.push(stmt);
+    }
+  }
+  if (initInsts.length > 0) {
+    registerInitFunction(async () => {
+      const env = new Environment('config.insts.env');
+      try {
+        await evaluateStatements(initInsts, env);
+        await env.commitAllTransactions();
+      } catch (reason: any) {
+        await env.rollbackAllTransactions();
+        console.error(`Failed to initialize config instances: ${reason}`);
+      }
+    });
+  }
+  if (cfgStmts.length > 0) {
+    const env = new Environment('config.env');
+    await evaluateStatements(cfgStmts, env);
+    return env.getLastResult();
+  }
+  return undefined;
+}
+
 export async function loadAppConfig(configDir: string): Promise<Config> {
   let cfgObj: any = undefined;
   const fs = await getFileSystem();
@@ -349,39 +384,12 @@ export async function loadAppConfig(configDir: string): Promise<Config> {
   if (await fs.exists(alCfgFile)) {
     const cfgPats = await fs.readFile(alCfgFile);
     if (canParse(cfgPats)) {
-      const cfgWf = `workflow createConfig{\n${cfgPats}}`;
-      const wf = await parseWorkflow(cfgWf);
-      const env = new Environment('config.env');
-      const cfgStmts = new Array<Statement>();
-      const initInsts = new Array<Statement>();
-      for (let i = 0; i < wf.statements.length; ++i) {
-        const stmt: Statement = wf.statements[i];
-        if (stmt.pattern.crudMap) {
-          initInsts.push(await makeDeleteAllConfigStatement(stmt.pattern.crudMap));
-          initInsts.push(stmt);
-        } else {
-          cfgStmts.push(stmt);
-        }
-      }
-      if (initInsts.length > 0) {
-        registerInitFunction(async () => {
-          const env = new Environment('config.insts.env');
-          try {
-            await evaluateStatements(initInsts, env);
-            await env.commitAllTransactions();
-          } catch (reason: any) {
-            await env.rollbackAllTransactions();
-            console.error(`Failed to initialize config instances: ${reason}`);
-          }
-        });
-      }
-      await evaluateStatements(cfgStmts, env);
-      cfgObj = env.getLastResult();
+      cfgObj = await evaluateConfigPatterns(cfgPats);
     }
   }
   try {
     const cfg = cfgObj
-      ? configFromObject(cfgObj)
+      ? await configFromObject(cfgObj)
       : await loadRawConfig(`${configDir}${path.sep}app.config.json`);
     return setAppConfig(cfg);
   } catch (err: any) {
@@ -1178,10 +1186,31 @@ export async function loadRawConfig(
   }
 }
 
-export function configFromObject(cfgObj: any, validate: boolean = true): any {
+function filterConfigEntityInstances(rawConfig: any): [any, Map<string, any>] {
+  const cfg = new Map<string, any>();
+  const insts = new Map<string, any>();
+  Object.entries(rawConfig).forEach(([key, value]: [string, any]) => {
+    if (isFqName(key)) {
+      insts.set(key, value);
+    } else {
+      cfg.set(key, value);
+    }
+  });
+  return [Object.fromEntries(cfg), insts];
+}
+
+async function configFromObject(cfgObj: any, validate: boolean = true): Promise<any> {
   const rawConfig = preprocessRawConfig(cfgObj);
   if (validate) {
-    return ConfigSchema.parse(rawConfig);
+    const [cfg, insts] = filterConfigEntityInstances(rawConfig);
+    const pats = new Array<string>();
+    insts.forEach((v: any, k: string) => {
+      pats.push(`{${k} ${objectAsString(v)}}`);
+    });
+    if (pats.length > 0) {
+      await evaluateConfigPatterns(pats.join('\n'));
+    }
+    return ConfigSchema.parse(cfg);
   }
   return rawConfig;
 }

package/src/runtime/logger.ts

@@ -1,4 +1,5 @@
 import { isNodeEnv } from '../utils/runtime.js';
+import { AppConfig } from './state.js';
 
 let DailyRotateFile: any;
 let winston: any;
@@ -16,34 +17,58 @@ if (isNodeEnv) {
 
 export let logger: any;
 
-if (isNodeEnv) {
-  const fileTransport = new DailyRotateFile({
-    level: 'debug',
-    filename: 'logs/app-%DATE%.log',
-    datePattern: 'YYYY-MM-DD',
-    maxSize: '20m',
-    maxFiles: '7d',
-  });
+function getLogLevel(): string {
+  if (isNodeEnv && process.env && process.env.DEBUG) {
+    return 'debug';
+  }
+  return AppConfig?.logging?.level || 'info';
+}
 
-  logger = winston.createLogger({
-    format: winston.format.combine(
-      winston.format.timestamp(),
-      winston.format.printf(({ timestamp, level, message }: any) => {
-        return `[${timestamp}] ${level}: ${message}`;
-      })
-    ),
-    transports: [fileTransport],
-  });
-} else {
-  function mkLogger(tag: string): Function {
-    return (msg: string) => {
-      console.log(`${tag}: ${msg}`);
+export function initializeLogger() {
+  const logLevel = getLogLevel();
+
+  if (isNodeEnv) {
+    const fileTransport = new DailyRotateFile({
+      level: logLevel,
+      filename: 'logs/app-%DATE%.log',
+      datePattern: 'YYYY-MM-DD',
+      maxSize: '20m',
+      maxFiles: '7d',
+    });
+
+    logger = winston.createLogger({
+      level: logLevel,
+      format: winston.format.combine(
+        winston.format.timestamp(),
+        winston.format.printf(({ timestamp, level, message }: any) => {
+          return `[${timestamp}] ${level}: ${message}`;
+        })
+      ),
+      transports: [fileTransport],
+    });
+  } else {
+    function mkLogger(tag: string): Function {
+      return (msg: string) => {
+        console.log(`${tag}: ${msg}`);
+      };
+    }
+    logger = {
+      debug: mkLogger('DEBUG'),
+      info: mkLogger('INFO'),
+      warn: mkLogger('WARN'),
+      error: mkLogger('ERROR'),
     };
   }
-  logger = {
-    debug: mkLogger('DEBUG'),
-    info: mkLogger('INFO'),
-    warn: mkLogger('WARN'),
-    error: mkLogger('ERROR'),
-  };
+}
+
+initializeLogger();
+
+export function updateLoggerFromConfig() {
+  if (isNodeEnv && logger) {
+    const logLevel = getLogLevel();
+    logger.level = logLevel;
+    if (logger.transports && logger.transports.length > 0) {
+      logger.transports[0].level = logLevel;
+    }
+  }
 }

package/src/runtime/modules/core.ts

@@ -28,14 +28,16 @@ import {
 import { logger } from '../logger.js';
 import { Statement } from '../../language/generated/ast.js';
 import { parseModule, parseStatements } from '../../language/parser.js';
-import { Resolver } from '../resolvers/interface.js';
+import { GenericResolver, Resolver } from '../resolvers/interface.js';
 import {
   FlowSuspensionTag,
   ForceReadPermFlag,
   InternDynamicModule,
+  isRuntimeMode_dev,
   PathAttributeName,
 } from '../defs.js';
 import { getMonitor, getMonitorsForEvent, Monitor } from '../monitor.js';
+import { registerResolver, setResolver } from '../resolvers/registry.js';
 
 const CoreModuleDefinition = `module ${DefaultModuleName}
 
@@ -146,11 +148,12 @@ entity Module {
   definition String
 }
 
-resolver moduleResolver [agentlang/Module] {
-    create Core.createModule,
-    update Core.updateModule,
-    delete Core.deleteModule,
-    query Core.getModule
+entity PersistentModule extends Module {
+}
+
+workflow savePersistentModule {
+  purge {PersistentModule {name? savePersistentModule.name}}
+  {PersistentModule {name savePersistentModule.name, definition savePersistentModule.definition}}
 }
 
 entity Migration {
@@ -464,7 +467,21 @@ export async function internModuleHelper(
 }
 
 export async function createModule(_: Resolver, inst: Instance) {
-  await internModuleHelper(inst.lookup('name'), inst.lookup('definition'));
+  const n = inst.lookup('name');
+  const d = inst.lookup('definition');
+  const env = new Environment('module-env');
+  try {
+    await parseAndEvaluateStatement(
+      `{agentlang/savePersistentModule {name "${n}", definition "${d}"}}`,
+      undefined,
+      env
+    );
+    await env.commitAllTransactions();
+  } catch (reason: any) {
+    await env.rollbackAllTransactions();
+    logger.error(`Failed to persist module ${n} - ${reason}`);
+  }
+  await internModuleHelper(n, d);
   return inst;
 }
 
@@ -473,7 +490,20 @@ export async function updateModule(r: Resolver, inst: Instance) {
 }
 
 export async function deleteModule(_: Resolver, inst: Instance) {
-  removeModule(inst.lookup('name'));
+  const n = inst.lookup('name');
+  const env = new Environment('module-env');
+  try {
+    await parseAndEvaluateStatement(
+      `purge {agentlang/PersistentModule {name? "${n}"}}`,
+      undefined,
+      env
+    );
+    await env.commitAllTransactions();
+  } catch (reason: any) {
+    await env.rollbackAllTransactions();
+    logger.error(`Failed to purge persistent module ${n} - ${reason}`);
+  }
+  removeModule(n);
   return inst;
 }
 
@@ -489,7 +519,46 @@ export async function getModule(_: Resolver, inst: Instance) {
       return [makeInstance('agentlang', 'Module', attrs)];
     }
   }
-  return null;
+  return [];
+}
+
+async function internPersistentModules() {
+  try {
+    const insts: Instance[] = await parseAndEvaluateStatement(`{agentlang/PersistentModule? {}}`);
+    for (let i = 0; i < insts.length; ++i) {
+      const inst = insts[i];
+      const n = inst.lookup('name');
+      if (!isModule(n)) await internModuleHelper(n, inst.lookup('definition'));
+    }
+  } catch (reason: any) {
+    logger.warn(`Failed to intern persistent modules: ${reason}`);
+  }
+}
+
+export function initCoreModuleManager() {
+  const ModuleResolverName = 'agentlang/moduleResolver';
+  const ModuleResolver = new GenericResolver(ModuleResolverName, {
+    create: createModule,
+    upsert: createModule,
+    update: updateModule,
+    query: getModule,
+    delete: deleteModule,
+    startTransaction: undefined,
+    commitTransaction: undefined,
+    rollbackTransaction: undefined,
+  });
+
+  registerResolver(ModuleResolverName, () => {
+    return ModuleResolver;
+  });
+
+  setResolver('agentlang/Module', ModuleResolverName);
+
+  if (isRuntimeMode_dev()) {
+    setInterval(() => {
+      internPersistentModules();
+    }, 10000);
+  }
 }
 
 const SqlSep = ';\n\n';

package/src/runtime/resolvers/interface.ts

@@ -14,7 +14,7 @@ import {
   newInstanceAttributes,
   Relationship,
 } from '../module.js';
-import { CrudType, nameToPath } from '../util.js';
+import { CrudType, nameToPath, generateLoggerCallId } from '../util.js';
 import { DefaultAuthInfo, ResolverAuthInfo } from './authinfo.js';
 
 export type JoinInfo = {
@@ -272,11 +272,22 @@ export class GenericResolver extends Resolver {
   }
 
   public override async createInstance(inst: Instance): Promise<any> {
+    const callId = generateLoggerCallId();
+    let attrVals;
+    if (inst.attributes) {
+      attrVals = JSON.stringify(Object.fromEntries(inst.attributes));
+    }
+    logger.debug(
+      `${callId}: Resolver createInstance called for ${inst.moduleName + '/' + inst.name} with values ${attrVals}`
+    );
+    let result;
     if (this.implementation?.create) {
-      return await this.implementation.create(this, inst);
+      result = await this.implementation.create(this, inst);
     } else {
-      return await super.createInstance(inst);
+      result = await super.createInstance(inst);
     }
+    logger.debug(`${callId}: Resolver createInstance response: ${JSON.stringify(result)}`);
+    return result;
   }
 
   public override async upsertInstance(inst: Instance): Promise<any> {
@@ -287,20 +298,57 @@ export class GenericResolver extends Resolver {
   }
 
   public override async updateInstance(inst: Instance, newAttrs: InstanceAttributes): Promise<any> {
+    const callId = generateLoggerCallId();
+
+    const newAttrsVals = JSON.stringify(Object.fromEntries(newAttrs));
+    logger.debug(
+      `${callId} Resolver updateInstance called for ${inst.moduleName + '/' + inst.name} with values ${newAttrsVals}`
+    );
+    if (inst.queryAttributes && inst.queryAttributeValues) {
+      const qattr = JSON.stringify(Object.fromEntries(inst.queryAttributes));
+      const qattrValues = JSON.stringify(Object.fromEntries(inst.queryAttributeValues));
+      logger.debug(`${callId}: Query attributes: ${qattr}, values ${qattrValues}`);
+    }
+
+    let result;
     if (this.implementation?.update) {
-      return await this.implementation.update(this, inst, newAttrs);
+      result = await this.implementation.update(this, inst, newAttrs);
+    } else {
+      result = await super.updateInstance(inst, newAttrs);
     }
-    return await super.updateInstance(inst, newAttrs);
+    logger.debug(`${callId}: Resolver updateInstance response: ${JSON.stringify(result)}`);
+    return result;
   }
 
   public override async queryInstances(inst: Instance, queryAll: boolean): Promise<any> {
+    const callId = generateLoggerCallId();
+    logger.debug(
+      `${callId}: Resolver queryInstances called for ${inst.moduleName + '/' + inst.name}`
+    );
+    if (inst.queryAttributes && inst.queryAttributeValues) {
+      const qattr = JSON.stringify(Object.fromEntries(inst.queryAttributes));
+      const qattrValues = JSON.stringify(Object.fromEntries(inst.queryAttributeValues));
+      logger.debug(`${callId}: Query attributes: ${qattr}, values ${qattrValues}`);
+    }
+    let result;
     if (this.implementation?.query) {
-      return await this.implementation.query(this, inst, queryAll);
+      result = await this.implementation.query(this, inst, queryAll);
+    } else {
+      result = await super.queryInstances(inst, queryAll);
     }
-    return await super.queryInstances(inst, queryAll);
+    logger.debug(`${callId}: Resolver queryInstances response: ${JSON.stringify(result)}`);
+    return result;
   }
 
   public override async deleteInstance(inst: Instance | Instance[], purge: boolean): Promise<any> {
+    if (inst instanceof Instance) {
+      if (inst.queryAttributes)
+        logger.debug(`Resolver deleteInstance called for ${inst.moduleName + '/' + inst.name}`);
+    } else {
+      logger.debug(
+        `Resolver deleteInstance called for ${inst.map(i => i.moduleName + '/' + i.name).join(', ')}`
+      );
+    }
     if (this.implementation?.delete) {
       return await this.implementation.delete(this, inst, purge);
     }

package/src/runtime/resolvers/sqldb/database.ts

@@ -34,6 +34,7 @@ import {
   isRuntimeMode_generate_migration,
   isRuntimeMode_init_schema,
   isRuntimeMode_migration,
+  isRuntimeMode_test,
   isRuntimeMode_undo_migration,
   PathAttributeName,
   UnauthorisedError,
@@ -171,11 +172,15 @@ function mkDbName(): string {
   return process.env.AGENTLANG_DB_NAME || `db-${Date.now()}`;
 }
 
+function needSync(): boolean {
+  return isRuntimeMode_dev() || isRuntimeMode_test() || isRuntimeMode_init_schema();
+}
+
 function makePostgresDataSource(
   entities: EntitySchema[],
   config: DatabaseConfig | undefined
 ): DataSource {
-  const synchronize = isRuntimeMode_dev() || isRuntimeMode_init_schema();
+  const synchronize = needSync();
   //const runMigrations = isRuntimeMode_migration() || isRuntimeMode_undo_migration() || !synchronize;
   return new DataSource({
     type: 'postgres',
@@ -208,7 +213,7 @@ function makeSqliteDataSource(
   entities: EntitySchema[],
   config: DatabaseConfig | undefined
 ): DataSource {
-  const synchronize = isRuntimeMode_dev() || isRuntimeMode_init_schema();
+  const synchronize = needSync();
   //const runMigrations = isRuntimeMode_migration() || isRuntimeMode_undo_migration() || !synchronize;
   return new DataSource({
     type: 'sqlite',

package/src/runtime/state.ts

@@ -111,6 +111,11 @@ export const ConfigSchema = z.object({
       })
     )
     .optional(),
+  logging: z
+    .object({
+      level: z.enum(['error', 'warn', 'info', 'debug']).default('info'),
+    })
+    .optional(),
 });
 
 export type Config = z.infer<typeof ConfigSchema>;

package/src/runtime/util.ts

@@ -612,6 +612,10 @@ export function generateUrlSafePassword(length: number = 8): string {
   return chars.join('');
 }
 
+export function generateLoggerCallId() {
+  return Math.floor(10000 + Math.random() * 90000);
+}
+
 const JS_PREFIX = '#js';
 
 export function preprocessRawConfig(rawConfig: any): any {
@@ -637,3 +641,12 @@ declare global {
 export function setScecretReader(f: ReadSecret) {
   globalThis.readSecret = f;
 }
+
+export function objectAsString(obj: any) {
+  const entries = new Array<string>();
+  Object.entries(obj).forEach(([k, v]) => {
+    const vv = typeof v === 'string' ? `"${v}"` : v;
+    entries.push(`${k}: ${vv}`);
+  });
+  return `{${entries.join(', ')}}`;
+}

package/out/setupClassic.d.ts

@@ -1,98 +0,0 @@
-export declare const setupConfigClassic: () => {
-    $type: string;
-    editorAppConfig: {
-        codeResources: {
-            modified: {
-                uri: string;
-                text: string;
-            };
-        };
-        useDiffEditor: boolean;
-        languageDef: {
-            languageExtensionConfig: {
-                id: string;
-            };
-            monarchLanguage: {
-                keywords: string[];
-                operators: string[];
-                symbols: RegExp;
-                tokenizer: {
-                    initial: ({
-                        regex: RegExp;
-                        action: {
-                            cases: {
-                                '@keywords': {
-                                    token: string;
-                                };
-                                '@default': {
-                                    token: string;
-                                };
-                                '@operators'?: undefined;
-                            };
-                            token?: undefined;
-                        };
-                        include?: undefined;
-                    } | {
-                        regex: RegExp;
-                        action: {
-                            token: string;
-                            cases?: undefined;
-                        };
-                        include?: undefined;
-                    } | {
-                        include: string;
-                        regex?: undefined;
-                        action?: undefined;
-                    } | {
-                        regex: RegExp;
-                        action: {
-                            cases: {
-                                '@operators': {
-                                    token: string;
-                                };
-                                '@default': {
-                                    token: string;
-                                };
-                                '@keywords'?: undefined;
-                            };
-                            token?: undefined;
-                        };
-                        include?: undefined;
-                    })[];
-                    whitespace: ({
-                        regex: RegExp;
-                        action: {
-                            token: string;
-                            next?: undefined;
-                        };
-                    } | {
-                        regex: RegExp;
-                        action: {
-                            token: string;
-                            next: string;
-                        };
-                    })[];
-                    comment: ({
-                        regex: RegExp;
-                        action: {
-                            token: string;
-                            next?: undefined;
-                        };
-                    } | {
-                        regex: RegExp;
-                        action: {
-                            token: string;
-                            next: string;
-                        };
-                    })[];
-                };
-            };
-        };
-        editorOptions: {
-            'semanticHighlighting.enabled': boolean;
-            theme: string;
-        };
-    };
-};
-export declare const executeClassic: (htmlElement: HTMLElement) => Promise<void>;
-//# sourceMappingURL=setupClassic.d.ts.map

package/out/setupClassic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setupClassic.d.ts","sourceRoot":"","sources":["../src/setupClassic.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqB9B,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,aAAa,WAAW,kBAgB5D,CAAC"}

package/out/setupClassic.js

@@ -1,38 +0,0 @@
-import { MonacoEditorLanguageClientWrapper } from 'monaco-editor-wrapper';
-import monarchSyntax from './syntaxes/agentlang.monarch.js';
-export const setupConfigClassic = () => {
-    return {
-        $type: 'classic',
-        editorAppConfig: {
-            codeResources: {
-                modified: {
-                    uri: '/workspace/example.al',
-                    text: `// Agentlang is running in the web!`,
-                },
-            },
-            useDiffEditor: false,
-            languageDef: {
-                languageExtensionConfig: { id: 'agentlang' },
-                monarchLanguage: monarchSyntax,
-            },
-            editorOptions: {
-                'semanticHighlighting.enabled': true,
-                theme: 'vs-dark',
-            },
-        },
-    };
-};
-export const executeClassic = async (htmlElement) => {
-    try {
-        const config = setupConfigClassic();
-        const wrapper = new MonacoEditorLanguageClientWrapper();
-        // Add the HTML container to the config
-        const wrapperConfig = Object.assign(Object.assign({}, config), { htmlContainer: htmlElement });
-        // Initialize and start the wrapper
-        await wrapper.initAndStart(wrapperConfig);
-    }
-    catch (error) {
-        console.error('Error initializing monaco editor:', error);
-    }
-};
-//# sourceMappingURL=setupClassic.js.map

package/out/setupClassic.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"setupClassic.js","sourceRoot":"","sources":["../src/setupClassic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iCAAiC,EAAsB,MAAM,uBAAuB,CAAC;AAC9F,OAAO,aAAa,MAAM,iCAAiC,CAAC;AAE5D,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,EAAE;IACrC,OAAO;QACL,KAAK,EAAE,SAAS;QAChB,eAAe,EAAE;YACf,aAAa,EAAE;gBACb,QAAQ,EAAE;oBACR,GAAG,EAAE,uBAAuB;oBAC5B,IAAI,EAAE,qCAAqC;iBAC5C;aACF;YACD,aAAa,EAAE,KAAK;YACpB,WAAW,EAAE;gBACX,uBAAuB,EAAE,EAAE,EAAE,EAAE,WAAW,EAAE;gBAC5C,eAAe,EAAE,aAAa;aAC/B;YACD,aAAa,EAAE;gBACb,8BAA8B,EAAE,IAAI;gBACpC,KAAK,EAAE,SAAS;aACjB;SACF;KACF,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG,KAAK,EAAE,WAAwB,EAAE,EAAE;IAC/D,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,kBAAkB,EAAE,CAAC;QACpC,MAAM,OAAO,GAAG,IAAI,iCAAiC,EAAE,CAAC;QAExD,uCAAuC;QACvC,MAAM,aAAa,GAAG,gCACjB,MAAM,KACT,aAAa,EAAE,WAAW,GACV,CAAC;QAEnB,mCAAmC;QACnC,MAAM,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IAC5C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,mCAAmC,EAAE,KAAK,CAAC,CAAC;IAC5D,CAAC;AACH,CAAC,CAAC"}

package/out/setupCommon.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=setupCommon.d.ts.map

package/out/setupCommon.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setupCommon.d.ts","sourceRoot":"","sources":["../src/setupCommon.ts"],"names":[],"mappings":""}