@scml-dol-maplebirch/types 5.0.3 → 5.1.0

package/compat/DoLPcompat.d.ts

@@ -0,0 +1,55 @@
+import type { MaplebirchCore } from '../core.js';
+import type { BuildUpdater, DecayCondition, NativeHistoryEntry, NativeMacroMap, NativeTransformState, SuppressCondition } from '../modules/CharacterAddon/TransformationConfig.js';
+interface TransformationPart {
+    name: string;
+    tfRequired: number;
+    default?: string;
+    [key: string]: unknown;
+}
+interface SetupTransformation {
+    name: string;
+    readonly level: number;
+    readonly build: number;
+    type: 'physicalTransform' | 'specialTransform';
+    parts: TransformationPart[];
+    traits: TransformationPart[];
+}
+interface TransformationPatch {
+    parts?: TransformationPart[];
+    traits?: TransformationPart[];
+}
+declare class Transformations {
+    private static active;
+    static readonly DecayConditions: Record<string, DecayCondition[]>;
+    static readonly SuppressConditions: Record<string, SuppressCondition[]>;
+    static readonly AnimalTransforms: NativeTransformState[];
+    static readonly AnimalMacros: NativeMacroMap;
+    static readonly HistoryTransforms: NativeHistoryEntry[];
+    static readonly BuildUpdaters: Record<string, BuildUpdater>;
+    static readonly TransformationPatches: Record<string, TransformationPatch>;
+    static readonly Transformations: SetupTransformation[];
+    static readonly PreservedTraits: string[];
+    static change(change: number): number;
+    static composite(): void;
+    private static forceAngel;
+    static extend(valid: {
+        names: Set<string>;
+        traits: Set<string>;
+    }): void;
+    static merge<T extends {
+        name?: string;
+        parts?: TransformationPart[];
+        traits?: TransformationPart[];
+    }>(base: T[]): Array<T | SetupTransformation>;
+    private static mergeProperties;
+    private static mergeParts;
+}
+declare class DoLPcompat {
+    static get isDoLP(): boolean;
+    static install(core: MaplebirchCore): void;
+    static readonly Transformations: typeof Transformations;
+    static nnpc: {
+        showfn: (options: Record<string, any>) => boolean;
+    };
+}
+export default DoLPcompat;

package/compat/ModI18N.d.ts

@@ -0,0 +1,10 @@
+import type ModLoader from '../host/ModLoader.js';
+import type Translator from '../services/Translator.js';
+declare class ModI18N {
+    private readonly translator;
+    private readonly modloader;
+    private installed;
+    constructor(translator: Translator, modloader: ModLoader);
+    install(): void;
+}
+export default ModI18N;

package/compat/Prototype.d.ts

@@ -0,0 +1,43 @@
+import type { MergeFilterFn } from '../utils/object.js';
+import type { ContainsMode, ContainsOptions } from '../utils/array.js';
+import type { ConvertMode } from '../utils/string.js';
+declare global {
+    interface ObjectConstructor {
+        merge<T extends object = Record<string, unknown>>(...sources: unknown[]): T;
+        append<T extends object = Record<string, unknown>>(...sources: unknown[]): T;
+        cover<T extends object = Record<string, unknown>>(...sources: unknown[]): T;
+        mergefn<T extends object = Record<string, unknown>>(filterFn: MergeFilterFn | null, ...sources: unknown[]): T;
+        appendfn<T extends object = Record<string, unknown>>(filterFn: MergeFilterFn | null, ...sources: unknown[]): T;
+        coverfn<T extends object = Record<string, unknown>>(filterFn: MergeFilterFn | null, ...sources: unknown[]): T;
+    }
+    interface Array<T> {
+        contains(value: unknown, mode?: ContainsMode, options?: ContainsOptions): boolean;
+        either(weights?: number[], allowNull?: boolean): T | null | undefined;
+    }
+    interface ArrayConstructor {
+        merge<T>(...sources: readonly T[][]): T[];
+        append<T>(...sources: readonly T[][]): T[];
+        cover<T>(...sources: readonly T[][]): T[];
+    }
+    interface ReadonlyArray<T> {
+        contains(value: unknown, mode?: ContainsMode, options?: ContainsOptions): boolean;
+        either(weights?: number[], allowNull?: boolean): T | null | undefined;
+    }
+    interface String {
+        contains(value: string, options?: {
+            case?: boolean;
+        }): boolean;
+        convert(mode?: ConvertMode, options?: {
+            delimiter?: string;
+            acronym?: boolean;
+        }): string;
+    }
+    interface Math {
+        random(): number;
+        random(max: number): number;
+        random(min: number, max: number, float?: boolean): number;
+        clamp(value: unknown, min: number, max: number, fallback?: number): number;
+    }
+}
+declare function prototypeUtils(): void;
+export default prototypeUtils;

package/compat/SimpleFrameworks.d.ts

@@ -0,0 +1 @@
+export {};

package/constants.d.ts

@@ -0,0 +1,52 @@
+export type LanguageCode = (typeof Languages)[number];
+export declare const version: string;
+export declare const Languages: readonly ['EN', 'CN'];
+export declare const Config: {
+    Title: string[];
+    DEBUG: string[];
+    DEBUGSTATUS: string[];
+    EnabledSTATUS: string[];
+    DisabledSTATUS: string[];
+    Languages: [string, string][];
+    LanguageSelection: string[];
+    EnableModule: string[];
+    DisableModule: string[];
+    EnableScript: string[];
+    DisableScript: string[];
+    ClearIndexedDB: string[];
+};
+export declare enum ModuleState {
+    REGISTERED = 0,
+    MOUNTED = 1,
+    ERROR = 2,
+    EXPOSED = 3,
+    DISABLED = 4
+}
+export declare const Translations: Record<LanguageCode, readonly string[]>;
+export declare const TimeConstants: Readonly<{
+    secondsPerDay: 86400;
+    secondsPerHour: 3600;
+    secondsPerMinute: 60;
+    minutesPerHour: 60;
+    standardYearMonths: readonly number[];
+    leapYearMonths: readonly number[];
+    synodicMonth: 29.53058867;
+    MIN_DATE: Readonly<{
+        timeStamp: -315537984000;
+        year: -9999;
+        month: 1;
+        day: 1;
+        hour: 0;
+        minute: 0;
+        second: 0;
+    }>;
+    MAX_DATE: Readonly<{
+        timeStamp: 315537897599;
+        year: 9999;
+        month: 12;
+        day: 31;
+        hour: 23;
+        minute: 59;
+        second: 59;
+    }>;
+}>;

package/core.d.ts

@@ -0,0 +1,143 @@
+import type { Passage } from '@scml/types/sugarcube-2-ModLoader/SugarCube2';
+import type { TwineSugarCube } from './types/twine-sugarcube.js';
+import type { SC2DataManager } from '@scml/types/sugarcube-2-ModLoader/SC2DataManager';
+import type { Gui } from '@scml/types/Mod_LoaderGui/Gui';
+import * as marked from 'marked';
+import jsyaml from 'js-yaml';
+import { Howl } from 'howler';
+import * as utils from './utils/index.js';
+import ModLoader from './host/ModLoader.js';
+import SugarCube, { type Save } from './host/SugarCube.js';
+import Diagnostics from './infra/Diagnostics.js';
+import Emitter, { type EventCallback } from './infra/Emitter.js';
+import IndexedDB, { type StoreIndex, type Transaction } from './services/IndexedDB.js';
+import CredentialVault from './services/CredentialVault.js';
+import CloudSave from './services/CloudSave.js';
+import Translator from './services/Translator.js';
+import Modules, { type Module, type DependencyGraph } from './services/Modules.js';
+import GUIControl from './services/GUIControl.js';
+import AddonPlugin from './services/AddonPlugin.js';
+declare global {
+    interface MaplebirchExtensions {
+    }
+}
+interface Extensions extends MaplebirchExtensions {
+}
+interface CoreEvents {
+    ':indexedDB': [];
+    ':idbReady': [];
+    ':import': [];
+    ':variable': [];
+    ':onSave': [save: Save];
+    ':onLoad': [save: Save];
+    ':language': [];
+    ':storyready': [];
+    ':passageinit': [passage: Passage];
+    ':passagestart': [passage: Passage, content: HTMLDivElement];
+    ':passagerender': [passage: Passage, content: HTMLDivElement];
+    ':passagedisplay': [passage: Passage, content: HTMLDivElement];
+    ':passageend': [passage: Passage, content: HTMLDivElement];
+    ':sugarcube': [];
+    ':modLoaderEnd': [];
+}
+export interface FrameworkHost {
+    readonly sugarcube: SugarCube;
+    readonly modLoader: ModLoader;
+}
+export interface FrameworkInfra {
+    readonly diagnostics: Diagnostics;
+    readonly events: Emitter;
+}
+export interface FrameworkServices {
+    readonly indexedDB: IndexedDB;
+    readonly modules: Modules;
+    readonly addonPlugin: AddonPlugin;
+    readonly translator: Translator;
+    readonly credentialVault: CredentialVault;
+    readonly cloudSave: CloudSave;
+    readonly gui: GUIControl;
+}
+type MaplebirchCore = InstanceType<typeof MaplebirchCore> & Extensions;
+declare const MaplebirchCore: {
+    new (modSC2DataManager: SC2DataManager, modLoaderGui: Gui): {
+        readonly meta: {
+            name: 'maplebirch Frameworks';
+            author: string;
+            version: string;
+            modifiedby: string;
+            updateDate: string;
+            Languages: readonly ["EN", "CN"];
+            core: readonly string[];
+            protected: readonly string[];
+        };
+        readonly host: Readonly<FrameworkHost>;
+        readonly infra: Readonly<FrameworkInfra>;
+        readonly services: Readonly<FrameworkServices>;
+        readonly utils: Readonly<{
+            clone: typeof utils.clone;
+            equal: typeof utils.equal;
+            merge: typeof utils.merge;
+            append: typeof utils.append;
+            cover: typeof utils.cover;
+            mergefn: typeof utils.mergefn;
+            appendfn: typeof utils.appendfn;
+            coverfn: typeof utils.coverfn;
+            contains: typeof utils.contains;
+            random: typeof utils.random;
+            either: typeof utils.either;
+            SelectCase: typeof utils.SelectCase;
+            convert: typeof utils.convert;
+            clamp: typeof utils.clamp;
+        }>;
+        readonly yaml: Readonly<typeof jsyaml>;
+        readonly howler: Readonly<{
+            Howl: typeof Howl;
+            Howler: HowlerGlobal;
+        }>;
+        log(message: string, level?: string, ...objects: unknown[]): void;
+        get export(): string;
+        get passage(): Passage;
+        set passage(passage: Passage);
+        get SugarCube(): TwineSugarCube;
+        set SugarCube(runtime: TwineSugarCube);
+        get modUtils(): ReturnType<SC2DataManager['getModUtils']>;
+        get modLoader(): ReturnType<SC2DataManager['getModLoader']>;
+        get lodash(): ModLoader['lodash'];
+        get marked(): typeof marked;
+        get Language(): string;
+        set Language(language: string);
+        get LogLevel(): string;
+        set LogLevel(level: string);
+        get dependencyGraph(): DependencyGraph;
+        get modList(): string[];
+        on<Name extends keyof CoreEvents>(eventName: Name, callback: EventCallback<CoreEvents[Name]>, description?: string): boolean;
+        on<Name extends string, Args extends unknown[]>(eventName: Name extends keyof CoreEvents ? never : Name, callback: EventCallback<Args>, description?: string): boolean;
+        off<Args extends unknown[]>(eventName: string, identifier: string | EventCallback<Args>): boolean;
+        once<Name extends keyof CoreEvents>(eventName: Name, callback: EventCallback<CoreEvents[Name]>, description?: string): boolean;
+        once<Name extends string, Args extends unknown[]>(eventName: Name extends keyof CoreEvents ? never : Name, callback: EventCallback<Args>, description?: string): boolean;
+        after<Name extends keyof CoreEvents>(eventName: Name, callback: EventCallback<CoreEvents[Name]>): void;
+        after<Name extends string, Args extends unknown[]>(eventName: Name extends keyof CoreEvents ? never : Name, callback: EventCallback<Args>): void;
+        trigger<Name extends keyof CoreEvents>(eventName: Name, ...args: CoreEvents[Name]): Promise<void>;
+        trigger<Name extends string>(eventName: Name extends keyof CoreEvents ? never : Name, ...args: unknown[]): Promise<void>;
+        define<T extends object>(name: string, module: T & Module, dependencies?: string[]): boolean;
+        idb(name: string, options?: IDBObjectStoreParameters, indexes?: StoreIndex[]): boolean;
+        with<T, Mode extends IDBTransactionMode>(storeNames: string | string[], mode: Mode, callback: (tx: Transaction<Mode>) => T | Promise<T>): Promise<T>;
+        t(key: string, space?: boolean): string;
+        auto(text: string): string;
+        get<K extends keyof Extensions>(name: K): Extensions[K] | undefined;
+        get(name: string): Module | undefined;
+    };
+    meta: {
+        name: 'maplebirch Frameworks';
+        author: string;
+        version: string;
+        modifiedby: string;
+        updateDate: string;
+        Languages: readonly ["EN", "CN"];
+        core: readonly string[];
+        protected: readonly string[];
+    };
+};
+declare var maplebirch: MaplebirchCore;
+export { MaplebirchCore, type CoreEvents, type Extensions };
+export default maplebirch;

package/host/DoL.d.ts

@@ -0,0 +1,44 @@
+export type DoLVariables = typeof V;
+export type DoLTemporary = typeof T;
+export type DoLCharacters = typeof C;
+export type DoLSetup = typeof setup;
+export type DoLRenderer = typeof Renderer;
+export type DoLGlobalName = 'V' | 'T' | 'C' | 'setup' | 'Renderer' | 'variables' | 'temporary' | 'characters' | 'renderer';
+export interface DoLHost {
+    readonly V: DoLVariables;
+    readonly T: DoLTemporary;
+    readonly C: DoLCharacters;
+    readonly setup: DoLSetup;
+    readonly Renderer: DoLRenderer;
+    readonly variables: DoLVariables;
+    readonly temporary: DoLTemporary;
+    readonly characters: DoLCharacters;
+    readonly renderer: DoLRenderer;
+    readonly gameVersion: string;
+    has(name: DoLGlobalName): boolean;
+}
+export interface DoLGlobalScope {
+    V?: DoLVariables;
+    T?: DoLTemporary;
+    C?: DoLCharacters;
+    setup?: DoLSetup;
+    Renderer?: DoLRenderer;
+}
+export declare class DoL implements DoLHost {
+    private readonly scope;
+    constructor(scope?: DoLGlobalScope);
+    get V(): DoLVariables;
+    get T(): DoLTemporary;
+    get C(): DoLCharacters;
+    get setup(): DoLSetup;
+    get Renderer(): DoLRenderer;
+    get variables(): DoLVariables;
+    get temporary(): DoLTemporary;
+    get characters(): DoLCharacters;
+    get renderer(): DoLRenderer;
+    get gameVersion(): string;
+    has(name: DoLGlobalName): boolean;
+    private require;
+}
+declare const dol: DoL;
+export default dol;

package/host/ModLoader.d.ts

@@ -0,0 +1,37 @@
+import type { Gui } from '@scml/types/Mod_LoaderGui/Gui';
+import type { SC2DataManager } from '@scml/types/sugarcube-2-ModLoader/SC2DataManager';
+import Diagnostics, { type PatchResult } from '../infra/Diagnostics.js';
+import Resources from './Resources.js';
+export type Replacement = [RegExp, string];
+type TwineAssetMode = 'append' | 'replace' | 'patch';
+export interface SourcePatch {
+    src?: string;
+    srcmatch?: RegExp;
+    srcmatchgroup?: RegExp;
+    to?: string;
+    applyafter?: string;
+    applybefore?: string;
+    expected?: number;
+}
+export interface SourcePatchResult extends Pick<PatchResult, 'pattern' | 'matches' | 'applied' | 'status' | 'expected' | 'error'> {
+    content: string;
+}
+export declare function applySourcePatch(source: string, patch: SourcePatch): SourcePatchResult;
+export declare class ModLoader {
+    readonly modSC2DataManager: SC2DataManager;
+    readonly modLoaderGui: Gui;
+    static getLodash(): ReturnType<ReturnType<SC2DataManager['getModUtils']>['getLodash']>;
+    readonly diagnostics: Diagnostics;
+    readonly resources: Resources;
+    constructor(modSC2DataManager: SC2DataManager, modLoaderGui: Gui);
+    replace(content: string, replacements: Replacement[], label?: string): string;
+    defineTwineAsset(type: 'script' | 'style', name: string, content: string | ((current: string) => string), mode?: TwineAssetMode): void;
+    disabled(modNames: string | string[], reload?: boolean): Promise<boolean>;
+    get modUtils(): ReturnType<SC2DataManager['getModUtils']>;
+    get modLoader(): ReturnType<SC2DataManager['getModLoader']>;
+    get loadController(): ReturnType<SC2DataManager['getModLoadController']>;
+    get dependence(): ReturnType<SC2DataManager['getDependenceChecker']>;
+    get conflict(): ReturnType<SC2DataManager['getConflictResult']>;
+    get lodash(): ReturnType<ReturnType<SC2DataManager['getModUtils']>['getLodash']>;
+}
+export default ModLoader;

package/host/Resources.d.ts

@@ -0,0 +1,15 @@
+import type { SC2DataManager } from '@scml/types/sugarcube-2-ModLoader/SC2DataManager';
+type ImageResult = string | false;
+declare class Resources {
+    private readonly manager;
+    private readonly report;
+    private readonly cache;
+    private readonly pending;
+    constructor(manager: SC2DataManager, report: (path: string, error: unknown) => void);
+    normalize(path: string): string;
+    has(path: string): boolean | undefined;
+    load(path: string): ImageResult | Promise<ImageResult>;
+    clear(path?: string): void;
+    private resolve;
+}
+export default Resources;

package/host/SugarCube.d.ts

@@ -0,0 +1,25 @@
+import type { Passage } from '@scml/types/sugarcube-2-ModLoader/SugarCube2';
+import type { DolStateAPI, DolStateMoment, TwineSugarCube } from '../types/twine-sugarcube.js';
+export interface SaveObject {
+    state: {
+        history: DolStateMoment[];
+        index?: number;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export declare class Save {
+    private readonly state;
+    readonly details?: unknown;
+    readonly saveObj: SaveObject;
+    constructor(state: DolStateAPI, saveObj: unknown, details?: unknown);
+    get V(): Record<string, unknown>;
+    use<Result>(variables: Record<string, unknown>, callback: () => Result): Result;
+}
+export declare class SugarCube {
+    runtime: TwineSugarCube | undefined;
+    passage: Passage;
+    require(): TwineSugarCube;
+    save(saveObj: unknown, details?: unknown): Save;
+}
+export default SugarCube;

package/index.d.ts

@@ -1,30 +1,11 @@
-import instance, * as types from './maplebirch';
-
-type Utils = typeof types.utils.publicUtils;
-
-declare global {
-  const maplebirch: typeof instance;
-  function clone<T>(...args: Parameters<typeof types.utils.clone<T>>): ReturnType<typeof types.utils.clone<T>>;
-  const equal: Utils['equal'];
-  const merge: Utils['merge'];
-  const append: Utils['append'];
-  const cover: Utils['cover'];
-  const mergefn: Utils['mergefn'];
-  const appendfn: Utils['appendfn'];
-  const coverfn: Utils['coverfn'];
-  const contains: Utils['contains'];
-  function random(...args: Parameters<Utils['random']>): ReturnType<Utils['random']>;
-  function either<T>(...args: Parameters<typeof types.utils.either<T>>): ReturnType<typeof types.utils.either<T>>;
-  const SelectCase: Utils['SelectCase'];
-  const convert: Utils['convert'];
-  const clamp: Utils['clamp'];
-  const loadImage: typeof types.ImageLoader.load;
-
-  interface Window extends Readonly<Utils> {
-    readonly maplebirch: typeof instance;
-    readonly loadImage: typeof types.ImageLoader.load;
-  }
-}
-
-export default instance;
-export * from './maplebirch';
+import './modules/DoL/index.js';
+import './compat/SimpleFrameworks.js';
+import './compat/Prototype.js';
+import './types/global.js';
+export { default } from './main.js';
+export * from './main.js';
+export { default as dol, DoL, type DoLHost, type DoLGlobalScope } from './host/DoL.js';
+export type { CoreModules } from './modules/DoL/types.js';
+export { default as DoLDynamic } from './modules/DoL/Dynamic.js';
+export { default as DoLToolCollection } from './modules/DoL/ToolCollection.js';
+export { default as ImageLoader } from './modules/Frameworks/ImageLoader.js';

package/infra/Catalog.d.ts

@@ -0,0 +1,14 @@
+import type ModLoader from '../host/ModLoader.js';
+import Diagnostics from './Diagnostics.js';
+export declare class Catalog<Key, Value> extends Diagnostics {
+    protected readonly items: Map<Key, Value>;
+    constructor(modloader?: ModLoader, entries?: Iterable<readonly [Key, Value]>);
+    add(key: Key, value: Value): boolean;
+    remove(key: Key): boolean;
+    get(key: Key): Value | undefined;
+    has(key: Key): boolean;
+    list(): Value[];
+    clear(): void;
+    get entries(): ReadonlyMap<Key, Value>;
+}
+export default Catalog;

package/infra/Diagnostics.d.ts

@@ -0,0 +1,48 @@
+import type ModLoader from '../host/ModLoader.js';
+import Logger, { type LogLevel } from './Logger.js';
+export interface DiagnosticRecord {
+    at: string;
+    level: LogLevel;
+    scope?: string;
+    message: string;
+    data?: unknown;
+}
+export interface PatchResult {
+    kind: 'passage' | 'script' | 'style' | 'source';
+    target: string;
+    index: number;
+    pattern: string;
+    matches: number;
+    applied: number;
+    status: 'applied' | 'unmatched' | 'missing' | 'invalid' | 'mismatch' | 'error';
+    expected?: number;
+    error?: string;
+}
+export interface ModConflict {
+    source: string;
+    dataSource: string;
+    passages: string[];
+    scripts: string[];
+    styles: string[];
+}
+export type ScopedLog = (message: string, level?: string, ...objects: unknown[]) => void;
+export declare class Diagnostics extends Logger {
+    readonly scope: string;
+    private static readonly entries;
+    private static readonly patchResults;
+    constructor(modloader?: ModLoader, scope?: string);
+    static message(error: unknown): string;
+    log(message: string, levelName?: string | number, ...objects: unknown[]): void;
+    record(message: string, level?: string, scope?: string, ...objects: unknown[]): void;
+    write(message: string, level?: string, scope?: string, ...objects: unknown[]): void;
+    scoped(scope: string): ScopedLog;
+    get history(): readonly DiagnosticRecord[];
+    get errors(): DiagnosticRecord[];
+    get patches(): PatchResult[];
+    recordPatch(result: PatchResult): void;
+    clearPatches(): void;
+    get conflicts(): ModConflict[] | undefined;
+    export(): string;
+    reset(): void;
+}
+export default Diagnostics;

package/infra/Emitter.d.ts

@@ -0,0 +1,18 @@
+import Diagnostics from './Diagnostics.js';
+export type EventCallback<Args extends unknown[] = unknown[]> = (...args: Args) => unknown;
+export declare class Emitter extends Diagnostics {
+    private readonly events;
+    private readonly afters;
+    private readonly triggering;
+    private readonly stickyEvents;
+    private readonly stickyArgs;
+    private readonly synchronousEvents;
+    on<Args extends unknown[]>(eventName: string, callback: EventCallback<Args>, description?: string): boolean;
+    off<Args extends unknown[]>(eventName: string, identifier: EventCallback<Args> | string): boolean;
+    once<Args extends unknown[]>(eventName: string, callback: EventCallback<Args>, description?: string): boolean;
+    trigger(eventName: string, ...args: unknown[]): Promise<void>;
+    after<Args extends unknown[]>(eventName: string, callback: EventCallback<Args>): void;
+    private pending;
+    private callSticky;
+}
+export default Emitter;

package/infra/Hooks.d.ts

@@ -0,0 +1,15 @@
+import type ModLoader from '../host/ModLoader.js';
+import Catalog from './Catalog.js';
+export type HookCallback<Args extends unknown[] = unknown[], Result = unknown> = (...args: Args) => Result | Promise<Result>;
+export type HookErrorPolicy = 'throw' | 'continue';
+export declare class Hooks<Args extends unknown[] = unknown[], Result = unknown> extends Catalog<string, HookCallback<Args, Result>> {
+    private readonly onError;
+    private readonly order;
+    constructor(modloader?: ModLoader, onError?: HookErrorPolicy);
+    add(name: string, callback: HookCallback<Args, Result>, order?: number): boolean;
+    remove(name: string): boolean;
+    clear(): void;
+    execute(...args: Args): Result[];
+    call(name: string, ...args: Args): Promise<Awaited<Result> | undefined>;
+}
+export default Hooks;

package/infra/Lifecycle.d.ts

@@ -0,0 +1,24 @@
+import Catalog from './Catalog.js';
+export type LifecyclePhase = 'preInit' | 'Init' | 'loadInit' | 'postInit';
+export interface LifecycleTarget {
+    preInit?(): void | Promise<void>;
+    Init?(): void;
+    loadInit?(): void;
+    postInit?(): void;
+}
+export interface LifecycleResult {
+    called: boolean;
+    ok: boolean;
+    error?: unknown;
+}
+export declare class Lifecycle<Key = string, Target extends LifecycleTarget = LifecycleTarget> extends Catalog<Key, Target> {
+    preInit(): void | Promise<void>;
+    Init(): void;
+    loadInit(): void;
+    postInit(): void;
+    execute(target: Target, phase: 'preInit', scope?: string): Promise<LifecycleResult>;
+    execute(target: Target, phase: Exclude<LifecyclePhase, 'preInit'>, scope?: string): LifecycleResult;
+    execute(target: Target, phase: LifecyclePhase, scope?: string): LifecycleResult | Promise<LifecycleResult>;
+    private failure;
+}
+export default Lifecycle;

package/infra/Logger.d.ts

@@ -0,0 +1,15 @@
+import type ModLoader from '../host/ModLoader.js';
+export type LogLevel = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+export declare class Logger {
+    readonly modloader?: ModLoader | undefined;
+    private static readonly LEVELS;
+    private static readonly CONFIG;
+    private static readonly FORWARD;
+    private static level;
+    constructor(modloader?: ModLoader | undefined);
+    static toLevel(level: string | number): LogLevel;
+    log(message: string, levelName?: string | number, ...objects: unknown[]): void;
+    set LevelName(levelName: string);
+    get LevelName(): string;
+}
+export default Logger;