jitar 0.1.0

package/dist/runtime/RemoteGateway.js

@@ -0,0 +1,22 @@
+import NotImplemented from '../core/errors/NotImplemented.js';
+import Gateway from './Gateway.js';
+import Remote from './Remote.js';
+export default class RemoteGateway extends Gateway {
+    #remote;
+    constructor(url) {
+        super(url);
+        this.#remote = new Remote(url, true);
+    }
+    getProcedureNames() {
+        throw new NotImplemented();
+    }
+    hasProcedure(name) {
+        throw new NotImplemented();
+    }
+    async addNode(node) {
+        return this.#remote.addNode(node);
+    }
+    async run(fqn, version, args) {
+        return this.#remote.run(fqn, version, args);
+    }
+}

package/dist/runtime/RemoteNode.d.ts

@@ -0,0 +1,12 @@
+import Version from '../core/Version.js';
+import Node from './Node.js';
+export default class RemoteNode extends Node {
+    #private;
+    constructor(url: string, procedureNames: string[]);
+    getProcedureNames(): string[];
+    registerProcedures(procedureNames: string[]): void;
+    hasProcedure(name: string): boolean;
+    isHealthy(): Promise<boolean>;
+    getHealth(): Promise<Map<string, boolean>>;
+    run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+}

package/dist/runtime/RemoteNode.js

@@ -0,0 +1,29 @@
+import Node from './Node.js';
+import Remote from './Remote.js';
+export default class RemoteNode extends Node {
+    #remote;
+    #procedureNames = new Set();
+    constructor(url, procedureNames) {
+        super(url);
+        this.#remote = new Remote(url, false);
+        this.registerProcedures(procedureNames);
+    }
+    getProcedureNames() {
+        return [...this.#procedureNames.values()];
+    }
+    registerProcedures(procedureNames) {
+        procedureNames.forEach(procedureName => this.#procedureNames.add(procedureName));
+    }
+    hasProcedure(name) {
+        return this.#procedureNames.has(name);
+    }
+    async isHealthy() {
+        return this.#remote.isHealthy();
+    }
+    async getHealth() {
+        return this.#remote.getHealth();
+    }
+    async run(fqn, version, args) {
+        return this.#remote.run(fqn, version, args);
+    }
+}

package/dist/runtime/RemoteNodeBuilder.d.ts

@@ -0,0 +1,4 @@
+import RemoteNode from './RemoteNode.js';
+export default class RemoteNodeBuilder {
+    static build(url: string, procedureNames: string[]): RemoteNode;
+}

package/dist/runtime/RemoteNodeBuilder.js

@@ -0,0 +1,10 @@
+import RemoteNode from './RemoteNode.js';
+export default class RemoteNodeBuilder {
+    static build(url, procedureNames) {
+        const node = new RemoteNode(url);
+        for (const name of procedureNames) {
+            node.registerProcedure(name);
+        }
+        return node;
+    }
+}

package/dist/runtime/RemoteRepository.d.ts

@@ -0,0 +1,14 @@
+import Module from '../core/types/Module.js';
+import File from './models/File.js';
+import Repository from './Repository.js';
+import Runtime from './Runtime.js';
+export default class RemoteRepository extends Repository {
+    #private;
+    constructor(url: string);
+    registerClient(segmentFiles: string[]): Promise<string>;
+    setRuntime(runtime: Runtime): Promise<void>;
+    loadAsset(filename: string): Promise<File>;
+    getModuleLocation(clientId: string): Promise<string>;
+    loadModule(clientId: string, filename: string): Promise<File>;
+    importModule(clientId: string, filename: string): Promise<Module>;
+}

package/dist/runtime/RemoteRepository.js

@@ -0,0 +1,34 @@
+import InvalidJitarHooks from './errors/InvalidJitarHooks.js';
+import Remote from './Remote.js';
+import Repository from './Repository.js';
+import ModuleLoader from './utils/ModuleLoader.js';
+export default class RemoteRepository extends Repository {
+    #remote;
+    constructor(url) {
+        super(url);
+        this.#remote = new Remote(url, true);
+    }
+    async registerClient(segmentFiles) {
+        return this.#remote.registerClient(segmentFiles);
+    }
+    async setRuntime(runtime) {
+        const jitar = await this.#remote.importFile('jitar/hooks.js');
+        if (jitar?.setRuntime === undefined || jitar?.setDependencyLoader === undefined) {
+            throw new InvalidJitarHooks();
+        }
+        jitar.setRuntime(runtime);
+        jitar.setDependencyLoader(ModuleLoader.import);
+    }
+    async loadAsset(filename) {
+        return this.#remote.loadFile(filename);
+    }
+    async getModuleLocation(clientId) {
+        return `${this.url}/modules/${clientId}`;
+    }
+    async loadModule(clientId, filename) {
+        return this.#remote.loadFile(`modules/${clientId}/${filename}`);
+    }
+    async importModule(clientId, filename) {
+        return this.#remote.importFile(`modules/${clientId}/${filename}`);
+    }
+}

package/dist/runtime/Repository.d.ts

@@ -0,0 +1,11 @@
+import Module from '../core/types/Module.js';
+import File from './models/File.js';
+import Runtime from './Runtime.js';
+export default abstract class Repository extends Runtime {
+    abstract registerClient(segmentFiles: string[]): Promise<string>;
+    abstract setRuntime(runtime: Runtime): Promise<void>;
+    abstract loadAsset(filename: string): Promise<File>;
+    abstract getModuleLocation(clientId: string): Promise<string>;
+    abstract loadModule(clientId: string, filename: string): Promise<File>;
+    abstract importModule(clientId: string, filename: string): Promise<Module>;
+}

package/dist/runtime/Repository.js

@@ -0,0 +1,3 @@
+import Runtime from './Runtime.js';
+export default class Repository extends Runtime {
+}

package/dist/runtime/Runtime.d.ts

@@ -0,0 +1,9 @@
+import HealthCheck from './interfaces/HealthCheck.js';
+export default abstract class Runtime {
+    #private;
+    constructor(url?: string);
+    get url(): string | undefined;
+    addHealthCheck(name: string, healthCheck: HealthCheck): void;
+    isHealthy(): Promise<boolean>;
+    getHealth(): Promise<Map<string, boolean>>;
+}

package/dist/runtime/Runtime.js

@@ -0,0 +1,27 @@
+export default class Runtime {
+    #url;
+    #healthChecks = new Map();
+    constructor(url) {
+        this.#url = url;
+    }
+    get url() { return this.#url; }
+    addHealthCheck(name, healthCheck) {
+        this.#healthChecks.set(name, healthCheck);
+    }
+    async isHealthy() {
+        for (const healthCheck of this.#healthChecks.values()) {
+            if (await healthCheck.isHealthy() === false) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async getHealth() {
+        const health = new Map();
+        for (const [name, healthCheck] of this.#healthChecks) {
+            const healthy = await healthCheck.isHealthy();
+            health.set(name, healthy);
+        }
+        return health;
+    }
+}

package/dist/runtime/caching/CachBuilder.d.ts

@@ -0,0 +1,6 @@
+import FileManager from '../interfaces/FileManager.js';
+export default class CacheBuilder {
+    #private;
+    constructor(sourceManager: FileManager, cacheManager: FileManager);
+    build(...filenames: string[]): Promise<void>;
+}

package/dist/runtime/caching/CachBuilder.js

@@ -0,0 +1,150 @@
+import ModuleLoader from '../utils/ModuleLoader.js';
+import ModuleAnalyser from '../utils/ModuleAnalyser.js';
+import ApplicationModule from './models/ApplicationModule.js';
+import SourceAppender from './SourceAppender.js';
+import ImportRewriter from './ImportRewriter.js';
+import RemoteBuilder from './RemoteBuilder.js';
+import SegmentModule from './models/SegmentModule.js';
+import FunctionFilenameNotFound from './errors/FunctionFilenameNotFound.js';
+import ModuleAppender from './ModuleAppender.js';
+const IGNORED_SOURCE_FILES = ['.min.js', '.segment.js'];
+export default class CacheBuilder {
+    #sourceManager;
+    #cacheManager;
+    constructor(sourceManager, cacheManager) {
+        this.#sourceManager = sourceManager;
+        this.#cacheManager = cacheManager;
+    }
+    async build(...filenames) {
+        const segmentFiles = this.#filterSegmentFiles(filenames);
+        const applicationFiles = this.#filterApplicationFiles(filenames);
+        const segmentModules = await this.#createSegmentModules(segmentFiles);
+        const segmentedFunctions = this.#extractSegmentedFunctions(segmentModules);
+        const applicationModules = await this.#createApplicationModules(applicationFiles);
+        const cachableApplicationModules = this.#filterCachableApplicationModules(applicationModules, segmentedFunctions);
+        await this.#buildSegmentCache(segmentModules, cachableApplicationModules);
+        await this.#buildApplicationCache(cachableApplicationModules);
+    }
+    #filterSegmentFiles(fileNames) {
+        return fileNames.filter(filename => filename.endsWith('.segment.js'));
+    }
+    #filterApplicationFiles(fileNames) {
+        return fileNames.filter(filename => !this.#mustIgnoreFile(filename));
+    }
+    #mustIgnoreFile(filename) {
+        return IGNORED_SOURCE_FILES.some((ignored) => filename.endsWith(ignored));
+    }
+    async #createSegmentModules(filenames) {
+        const promises = filenames.map(async (filename) => this.#createSegmentModule(filename));
+        return Promise.all(promises).then(results => results);
+    }
+    async #createSegmentModule(filename) {
+        const relativeLocation = this.#sourceManager.getRelativeLocation(filename);
+        const module = await this.#loadModule(filename);
+        if (module === undefined) {
+            return new SegmentModule(relativeLocation, new Map());
+        }
+        const functions = ModuleAnalyser.filterFunctions(module);
+        return new SegmentModule(relativeLocation, functions);
+    }
+    #extractSegmentedFunctions(segmentModules) {
+        const functions = new Set();
+        for (const segmentModule of segmentModules) {
+            const moduleFunctions = [...segmentModule.functions.values()];
+            moduleFunctions.forEach(moduleFunction => functions.add(moduleFunction));
+        }
+        return functions;
+    }
+    async #createApplicationModules(filenames) {
+        const promises = filenames.map(async (filename) => this.#createApplicationModule(filename));
+        return Promise.all(promises).then(results => results);
+    }
+    async #createApplicationModule(filename) {
+        const module = await this.#loadModule(filename);
+        const relativeLocation = this.#sourceManager.getRelativeLocation(filename);
+        if (module === undefined) {
+            return new ApplicationModule(relativeLocation, new Map(), new Map());
+        }
+        const classes = ModuleAnalyser.filterClasses(module);
+        const functions = ModuleAnalyser.filterFunctions(module);
+        return new ApplicationModule(relativeLocation, classes, functions);
+    }
+    #filterCachableApplicationModules(applicationModules, segmentFunctions) {
+        return applicationModules.filter(module => module.hasClasses || this.#hasSegmentedFunctions(module, segmentFunctions));
+    }
+    #hasSegmentedFunctions(applicationModule, segmentFunctions) {
+        const applicationFunctions = [...applicationModule.functions.values()];
+        return applicationFunctions.some(applicationFunction => segmentFunctions.has(applicationFunction));
+    }
+    async #loadModule(filename) {
+        try {
+            return await ModuleLoader.load(filename);
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    async #buildSegmentCache(segmentModules, applicationModules) {
+        const promises = segmentModules.map(async (module) => this.#buildSegmentModuleCache(module, applicationModules));
+        return Promise.all(promises);
+    }
+    async #buildSegmentModuleCache(module, applicationModules) {
+        const filenames = this.#extractSegmentFilenames(module, applicationModules);
+        const segmentCode = `export const files = ${JSON.stringify(filenames)};`;
+        const segmentLocation = module.filename.replace('.js', '.files.js');
+        return this.#cacheManager.store(segmentLocation, segmentCode);
+    }
+    #extractSegmentFilenames(module, applicationModules) {
+        const filenames = [];
+        for (const segmentFunction of module.functions.values()) {
+            const filename = this.#findFunctionFilename(segmentFunction, applicationModules);
+            if (filename === undefined) {
+                throw new FunctionFilenameNotFound(segmentFunction.name, module.filename);
+            }
+            filenames.push(filename);
+        }
+        return filenames;
+    }
+    #findFunctionFilename(segmentFunction, applicationModules) {
+        const applicationModule = applicationModules.find(applicationModule => applicationModule.containsFunction(segmentFunction));
+        return applicationModule !== undefined
+            ? applicationModule.filename
+            : undefined;
+    }
+    async #buildApplicationCache(applicationModules) {
+        const promises = applicationModules.map(async (module) => this.#buildApplicationModuleCache(module));
+        return Promise.all(promises);
+    }
+    async #buildApplicationModuleCache(module) {
+        const filename = module.filename;
+        const sourceLocation = this.#sourceManager.getAbsoluteLocation(filename);
+        const relativeLocation = filename;
+        const file = await this.#sourceManager.load(sourceLocation);
+        const content = file.content.toString();
+        const code = await this.#buildForRepository(module, content, relativeLocation);
+        if (module.hasFunctions) {
+            await this.#buildForNode(code, relativeLocation);
+            await this.#buildForRemote(module, relativeLocation);
+        }
+    }
+    async #buildForRepository(module, code, location) {
+        if (module.hasFunctions) {
+            code = ModuleAppender.append(module, code, location);
+        }
+        if (module.hasClasses) {
+            code = SourceAppender.append(module, code, location);
+        }
+        await this.#cacheManager.store(location, code);
+        return code;
+    }
+    async #buildForNode(code, location) {
+        code = ImportRewriter.rewrite(code);
+        const nodeLocation = location.replace('.js', '.node.js');
+        return this.#cacheManager.store(nodeLocation, code);
+    }
+    async #buildForRemote(module, location) {
+        const remoteCode = RemoteBuilder.build(module);
+        const remoteLocation = location.replace('.js', '.remote.js');
+        return this.#cacheManager.store(remoteLocation, remoteCode);
+    }
+}

package/dist/runtime/caching/CacheBuilder.d.ts

@@ -0,0 +1,6 @@
+import FileManager from '../interfaces/FileManager.js';
+export default class CacheBuilder {
+    #private;
+    constructor(sourceManager: FileManager, cacheManager: FileManager);
+    build(segmentFiles: string[], moduleFiles: string[]): Promise<void>;
+}

package/dist/runtime/caching/CacheBuilder.js

@@ -0,0 +1,249 @@
+import * as AccessLevel from '../../core/definitions/AccessLevel.js';
+import Version from '../../core/Version.js';
+import ModuleLoader from '../utils/ModuleLoader.js';
+import ModuleAnalyser from '../utils/ModuleAnalyser.js';
+import SourceAppender from './SourceAppender.js';
+import ImportRewriter from './ImportRewriter.js';
+import RemoteBuilder from './RemoteBuilder.js';
+import ApplicationModule from './models/ApplicationModule.js';
+import Procedure from './models/Procedure.js';
+import Segment from './models/Segment.js';
+import SegmentModule from './models/SegmentModule.js';
+import Implementation from './models/Implementation.js';
+import SegmentFileNotLoaded from './errors/SegmentFileNotLoaded.js';
+import SegmentModuleNotLoaded from './errors/SegmentModuleNotLoaded.js';
+import MissingModuleExport from './errors/MissingModuleExport.js';
+import InvalidSegmentFilename from './errors/InvalidSegmentFilename.js';
+const IGNORED_SOURCE_FILES = ['.min.js'];
+const DEFAULT_ACCESS_LEVEL = AccessLevel.PRIVATE;
+const DEFAULT_VERSION_NUMBER = Version.DEFAULT.toString();
+export default class CacheBuilder {
+    #sourceManager;
+    #cacheManager;
+    constructor(sourceManager, cacheManager) {
+        this.#sourceManager = sourceManager;
+        this.#cacheManager = cacheManager;
+    }
+    async build(segmentFiles, moduleFiles) {
+        const applicationFiles = this.#filterApplicationFiles(moduleFiles);
+        const segments = await this.#createSegments(segmentFiles);
+        const applicationModules = await this.#createApplicationModules(applicationFiles);
+        await this.#buildSegmentCache(segments);
+        await this.#buildApplicationCache(applicationModules);
+    }
+    #filterApplicationFiles(fileNames) {
+        return fileNames.filter(filename => this.#mustIgnoreFile(filename) === false);
+    }
+    #mustIgnoreFile(filename) {
+        return IGNORED_SOURCE_FILES.some((ignored) => filename.endsWith(ignored));
+    }
+    async #createSegments(filenames) {
+        const promises = filenames.map(async (filename) => this.#createSegment(filename));
+        return Promise.all(promises).then(segments => segments);
+    }
+    async #createSegment(filename) {
+        const definition = await this.#loadSegmentDefinition(filename);
+        const modules = await this.#createSegmentModules(definition);
+        const procedures = this.#createSegmentProcedures(modules);
+        return new Segment(filename, modules, procedures);
+    }
+    async #loadSegmentDefinition(filename) {
+        try {
+            const content = await this.#sourceManager.getContent(filename);
+            return JSON.parse(content.toString());
+        }
+        catch (error) {
+            throw new SegmentFileNotLoaded(filename);
+        }
+    }
+    async #createSegmentModules(definition) {
+        const modules = [];
+        for (const [moduleFilename, moduleImports] of Object.entries(definition)) {
+            const absoluteLocation = this.#sourceManager.getAbsoluteLocation(moduleFilename);
+            const module = await this.#createSegmentModule(absoluteLocation, moduleImports);
+            modules.push(module);
+        }
+        return modules;
+    }
+    async #createSegmentModule(absoluteLocation, imports) {
+        const exports = await this.#loadSegmentModule(absoluteLocation);
+        const implementations = await this.#createSegmentModuleImplementations(absoluteLocation, exports, imports);
+        return new SegmentModule(absoluteLocation, exports, implementations);
+    }
+    async #loadSegmentModule(absoluteLocation) {
+        const module = await this.#loadModule(absoluteLocation);
+        if (module === undefined) {
+            throw new SegmentModuleNotLoaded(absoluteLocation);
+        }
+        return module;
+    }
+    async #createSegmentModuleImplementations(absoluteLocation, exports, imports) {
+        const moduleName = this.#extractModuleName(absoluteLocation);
+        const implementations = new Map();
+        for (const [importKey, properties] of Object.entries(imports)) {
+            const executable = exports[importKey];
+            if (executable === undefined) {
+                throw new MissingModuleExport(moduleName, importKey);
+            }
+            const procedureName = properties.as ?? executable.name;
+            const access = properties.access ?? DEFAULT_ACCESS_LEVEL;
+            const version = properties.version ?? DEFAULT_VERSION_NUMBER;
+            const implementation = new Implementation(moduleName, procedureName, access, version, executable);
+            implementations.set(importKey, implementation);
+        }
+        return implementations;
+    }
+    #createSegmentProcedures(modules) {
+        const procedures = new Map();
+        for (const module of modules) {
+            for (const implementation of module.implementations.values()) {
+                let procedure = procedures.get(implementation.fqn);
+                if (procedure === undefined) {
+                    procedure = new Procedure(implementation.module, implementation.name);
+                    procedures.set(implementation.fqn, procedure);
+                }
+                procedure.addImplementation(implementation);
+            }
+        }
+        return procedures;
+    }
+    #extractModuleName(absoluteLocation) {
+        const relativeLocation = this.#sourceManager.getRelativeLocation(absoluteLocation);
+        const moduleParts = relativeLocation.split('/');
+        moduleParts.pop();
+        return moduleParts.join('/');
+    }
+    async #createApplicationModules(filenames) {
+        const promises = filenames.map(async (filename) => this.#createApplicationModule(filename));
+        return Promise.all(promises).then(results => results);
+    }
+    async #createApplicationModule(filename) {
+        const module = await this.#loadModule(filename);
+        const relativeLocation = this.#sourceManager.getRelativeLocation(filename);
+        if (module === undefined) {
+            return new ApplicationModule(relativeLocation, new Map(), new Map());
+        }
+        const classes = ModuleAnalyser.filterClasses(module);
+        const functions = ModuleAnalyser.filterFunctions(module);
+        return new ApplicationModule(relativeLocation, classes, functions);
+    }
+    async #loadModule(filename) {
+        try {
+            return await ModuleLoader.load(filename);
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    async #buildSegmentCache(segments) {
+        const promises = segments.map(async (segment) => this.#buildSegmentModuleCache(segment));
+        return Promise.all(promises);
+    }
+    async #buildSegmentModuleCache(segment) {
+        await this.#buildSegmentCacheForRepository(segment);
+        await this.#buildSegmentCacheForNode(segment);
+    }
+    async #buildSegmentCacheForRepository(segment) {
+        return this.#buildSegmentDefinitionForRepository(segment);
+    }
+    async #buildSegmentDefinitionForRepository(segment) {
+        const code = this.#createSegmentRepositoryCode(segment);
+        const filename = this.#createSegmentRepositoryFilename(segment);
+        return this.#cacheManager.store(filename, code);
+    }
+    #createSegmentRepositoryCode(segment) {
+        const filenames = segment.getFilenames();
+        const relativeLocations = filenames.map(filename => this.#sourceManager.getRelativeLocation(filename));
+        return `export const files = [\n\t"${[...relativeLocations].join('",\n\t"')}"\n];`;
+    }
+    #createSegmentRepositoryFilename(segment) {
+        const filename = this.#extractSegmentFilename(segment);
+        return filename.replace('.json', '.repository.js');
+    }
+    async #buildSegmentCacheForNode(segment) {
+        await this.#buildSegmentDefinitionForNode(segment);
+        await this.#buildSegmentModulesForNode(segment);
+    }
+    async #buildSegmentDefinitionForNode(segment) {
+        const code = this.#createSegmentNodeCode(segment);
+        const filename = this.#createSegmentNodeFilename(segment);
+        return this.#cacheManager.store(filename, code);
+    }
+    #createSegmentNodeCode(segment) {
+        const importCode = this.#createSegmentImportCode(segment);
+        const modelCode = this.#createSegmentModelCode(segment);
+        return `${importCode}\n\n${modelCode}`;
+    }
+    #createSegmentImportCode(segment) {
+        let codes = [];
+        for (const module of segment.modules) {
+            const relativeLocation = this.#sourceManager.getRelativeLocation(module.filename);
+            const imports = [];
+            for (const [importKey, implementation] of module.implementations) {
+                imports.push(`${importKey} as \$${implementation.id}`);
+            }
+            codes.push(`import { ${imports.join(',')} } from "./${relativeLocation}";`);
+        }
+        return codes.join('\n');
+    }
+    #createSegmentModelCode(segment) {
+        const procedureCode = [];
+        for (const procedure of segment.procedures.values()) {
+            const implementationCode = [];
+            for (const implementation of procedure.implementations) {
+                implementationCode.push(`{ access: "${implementation.access}", version: "${implementation.version}", executable: \$${implementation.id} }`);
+            }
+            procedureCode.push(`{ module: "${procedure.module}", name: "${procedure.name}", implementations: [\n\t\t${implementationCode.join(',\n\t\t')}\n\t]}`);
+        }
+        return `export const procedures = [\n\t${procedureCode.join(',\n\t')}\n];`;
+    }
+    async #buildSegmentModulesForNode(segment) {
+        for (const module of segment.modules) {
+            const filename = module.filename;
+            const absoluteLocation = this.#sourceManager.getAbsoluteLocation(filename);
+            const relativeLocation = this.#sourceManager.getRelativeLocation(filename);
+            const file = await this.#sourceManager.load(absoluteLocation);
+            const code = file.content.toString();
+            await this.#buildSegmentModuleForLocal(code, relativeLocation);
+            await this.#buildSegmentModuleForRemote(module, relativeLocation);
+        }
+    }
+    async #buildSegmentModuleForLocal(code, location) {
+        const importedCode = ImportRewriter.rewrite(code);
+        const nodeLocation = location.replace('.js', '.local.js');
+        return this.#cacheManager.store(nodeLocation, importedCode);
+    }
+    async #buildSegmentModuleForRemote(module, location) {
+        const remoteCode = RemoteBuilder.build(module);
+        const remoteLocation = location.replace('.js', '.remote.js');
+        return this.#cacheManager.store(remoteLocation, remoteCode);
+    }
+    #createSegmentNodeFilename(segment) {
+        const filename = this.#extractSegmentFilename(segment);
+        return filename.replace('.json', '.local.js');
+    }
+    #extractSegmentFilename(segment) {
+        const filename = segment.filename.split('/').pop();
+        if (filename === undefined) {
+            throw new InvalidSegmentFilename(segment.filename);
+        }
+        return filename;
+    }
+    async #buildApplicationCache(applicationModules) {
+        const promises = applicationModules.map(async (module) => this.#buildApplicationModuleCache(module));
+        return Promise.all(promises);
+    }
+    async #buildApplicationModuleCache(module) {
+        return this.#buildApplicationShareables(module);
+    }
+    async #buildApplicationShareables(module) {
+        if (module.hasClasses() === false) {
+            return;
+        }
+        const filename = module.filename;
+        const file = await this.#sourceManager.load(filename);
+        const code = file.content.toString();
+        const sourcedCode = SourceAppender.append(module, code, filename);
+        return this.#cacheManager.store(filename, sourcedCode);
+    }
+}

package/dist/runtime/caching/ImportRewriter.d.ts

@@ -0,0 +1,4 @@
+export default class ImportRewriter {
+    #private;
+    static rewrite(content: string): string;
+}

package/dist/runtime/caching/ImportRewriter.js

@@ -0,0 +1,49 @@
+import * as Keywords from './definitions/Keywords.js';
+const IMPORT_PATTERN = /import(?:["'\s]*([\w*{}\n, ]+)from\s*)?["'\s]*([@\w/_-]+)["'\s].*/g;
+const NON_SYSTEM_INDICATORS = ['.', '/', 'http:', 'https:'];
+class Dependency {
+    items;
+    from;
+    constructor(items, from) {
+        this.items = items;
+        this.from = from;
+    }
+}
+export default class ImportRewriter {
+    static rewrite(content) {
+        const replacer = (statement) => this.#replaceImport(statement);
+        const newContent = content.replaceAll(IMPORT_PATTERN, replacer);
+        return newContent !== content
+            ? this.#insertGetDependency(newContent)
+            : newContent;
+    }
+    static #replaceImport(statement) {
+        const dependency = this.#parseImport(statement);
+        return this.#isSystemDependency(dependency)
+            ? this.#rewriteImport(dependency)
+            : statement;
+    }
+    static #parseImport(statement) {
+        const hasSemicolon = statement.endsWith(';');
+        const fromIndex = statement.indexOf('from');
+        const endIndex = statement.length - (hasSemicolon ? 1 : 0);
+        const items = statement.substring(6, fromIndex).trim();
+        const from = statement.substring(fromIndex + 4, endIndex).trim().slice(1, -1);
+        return new Dependency(items, from);
+    }
+    static #isSystemDependency(dependency) {
+        return NON_SYSTEM_INDICATORS.some(indicator => dependency.from.startsWith(indicator)) === false;
+    }
+    static #isJitarDependency(dependency) {
+        return dependency.from === Keywords.JITAR;
+    }
+    static #rewriteImport(dependency) {
+        if (this.#isJitarDependency(dependency)) {
+            return `import ${dependency.items} from "/jitar/hooks.js";`;
+        }
+        return `const ${dependency.items} = await getDependency('${dependency.from}');`;
+    }
+    static #insertGetDependency(module) {
+        return `import { getDependency } from "/jitar/hooks.js";\n${module}`;
+    }
+}

package/dist/runtime/caching/ModuleAppender.d.ts

@@ -0,0 +1,5 @@
+import ApplicationModule from './models/ApplicationModule.js';
+export default class ModuleAppender {
+    #private;
+    static append(module: ApplicationModule, code: string, filename: string): string;
+}