@jsprismarine/kernel 0.0.0 → 0.16.0-unstable-20261031031332

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,183 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
3
+ const require_events = require("./events.cjs.cjs");
4
+ const require_logger = require("./logger.cjs.cjs");
5
+ // src/kernel.ts
6
+ /**
7
+ * Error raised for kernel contract violations: missing providers, dependency
8
+ * cycles, duplicate providers, out-of-phase calls, and undeclared `use()`.
9
+ */
10
+ var KernelError = class extends Error {
11
+ name = "KernelError";
12
+ };
13
+ /**
14
+ * The module kernel. It owns lifecycle, a token-keyed service registry, and the
15
+ * event bus; everything else — worlds, sessions, commands, networking, the tick
16
+ * loop — is a module.
17
+ *
18
+ * Lifecycle: construct the kernel once, `register()` modules, then drive it
19
+ * through `registerAll()`, `start()`, and `stop()`. `registerAll()` runs every
20
+ * module's `register()` phase exactly once and validates providers and the
21
+ * dependency graph; after it, `get()` resolves provided services. `start()`
22
+ * runs `registerAll()` first when it has not run, then runs the `start()`
23
+ * phases in dependency order. `stop()` runs `stop()` phases in reverse order,
24
+ * logging failures instead of throwing, and returns the kernel to the
25
+ * registered state, so the same kernel — and the services its modules
26
+ * constructed — can be started again. Event listeners a module attaches are
27
+ * detached when it stops; a module that must survive a restart attaches its
28
+ * listeners in `start()`, not `register()`.
29
+ */
30
+ var Kernel = class {
31
+ entries = [];
32
+ services = /* @__PURE__ */ new Map();
33
+ providerOf = /* @__PURE__ */ new Map();
34
+ bus = new require_events.KernelEventBus();
35
+ config;
36
+ logger;
37
+ phase = "created";
38
+ registering;
39
+ startOrder = [];
40
+ constructor(options = {}) {
41
+ this.config = options.config ?? {};
42
+ this.logger = options.logger ?? require_logger.consoleLogger;
43
+ }
44
+ /** The kernel-owned event bus, unscoped. Module code should use its context's scoped handle. */
45
+ get events() {
46
+ return this.bus;
47
+ }
48
+ /**
49
+ * Adds a module. Legal only before `registerAll()` (or the first `start()`,
50
+ * which runs it).
51
+ *
52
+ * @throws KernelError after `registerAll()` or when a module with the same id is already registered.
53
+ */
54
+ register(module) {
55
+ if (this.phase !== "created") throw new KernelError(`Cannot register module "${module.id}" after the kernel has run registerAll()`);
56
+ if (this.entries.some((entry) => entry.module.id === module.id)) throw new KernelError(`A module with id "${module.id}" is already registered`);
57
+ const dependencyIds = new Set((module.dependencies ?? []).map((token) => token.id));
58
+ const entry = {
59
+ module,
60
+ dependencyIds,
61
+ context: this.createContext(module.id, dependencyIds)
62
+ };
63
+ this.entries.push(entry);
64
+ }
65
+ /**
66
+ * Runs all `register()` phases, validates providers and the dependency
67
+ * graph, and computes the start order. After it resolves, `get()` resolves
68
+ * every provided service even though `start()` has not run. Runs at most
69
+ * once per kernel; later calls are no-ops.
70
+ *
71
+ * @throws KernelError when a declared dependency has no provider or the dependency graph has a cycle.
72
+ */
73
+ async registerAll() {
74
+ if (this.phase !== "created") return;
75
+ for (const entry of this.entries) {
76
+ this.registering = entry.module.id;
77
+ try {
78
+ await entry.module.register(entry.context);
79
+ } finally {
80
+ this.registering = void 0;
81
+ }
82
+ }
83
+ this.assertProvidersExist();
84
+ this.startOrder = this.sortByDependencies();
85
+ this.phase = "registered";
86
+ }
87
+ /**
88
+ * Runs `registerAll()` when it has not run, then runs `start()` phases in
89
+ * dependency order. Legal again after `stop()`: the `register()` phases do
90
+ * not rerun, so the modules' services carry over into the next start.
91
+ *
92
+ * @throws KernelError when the kernel is already starting or started, when
93
+ * a declared dependency has no provider, or when the dependency graph has a
94
+ * cycle.
95
+ */
96
+ async start() {
97
+ if (this.phase === "starting" || this.phase === "started") throw new KernelError(`Kernel is already ${this.phase}; stop() it before starting again`);
98
+ await this.registerAll();
99
+ this.phase = "starting";
100
+ for (const entry of this.startOrder) await entry.module.start?.(entry.context);
101
+ this.phase = "started";
102
+ }
103
+ /**
104
+ * Runs `stop()` phases in reverse start order and detaches each module's
105
+ * event listeners. Failures are logged, not thrown, so one module cannot
106
+ * block the others' teardown. Leaves the kernel registered, so `start()`
107
+ * may run it again; a no-op unless the kernel is started.
108
+ */
109
+ async stop() {
110
+ if (this.phase !== "started") return;
111
+ this.phase = "registered";
112
+ for (const entry of [...this.startOrder].reverse()) try {
113
+ await entry.module.stop?.(entry.context);
114
+ } catch (error) {
115
+ this.logger.error(`Module "${entry.module.id}" failed to stop: ${error}`);
116
+ } finally {
117
+ this.bus.removeScope(entry.module.id);
118
+ }
119
+ }
120
+ /**
121
+ * Resolves a service for the host or for tests. Module code should resolve
122
+ * through its context instead.
123
+ *
124
+ * @throws KernelError when no module has provided the token.
125
+ */
126
+ get(token) {
127
+ if (!this.services.has(token.id)) throw new KernelError(`No provider for service "${token.id}"`);
128
+ return this.services.get(token.id);
129
+ }
130
+ createContext(moduleId, dependencyIds) {
131
+ return {
132
+ use: (token) => {
133
+ if (!dependencyIds.has(token.id)) throw new KernelError(`Module "${moduleId}" used service "${token.id}" without declaring it as a dependency`);
134
+ if (!this.services.has(token.id)) throw new KernelError(`Service "${token.id}" is not provided yet; resolve dependencies in start(), not register()`);
135
+ return this.get(token);
136
+ },
137
+ provide: (token, service, options) => {
138
+ if (this.registering !== moduleId) throw new KernelError(`Module "${moduleId}" may only provide "${token.id}" during its register() phase`);
139
+ const existing = this.providerOf.get(token.id);
140
+ if (existing !== void 0 && !options?.override) throw new KernelError(`Service "${token.id}" is already provided by module "${existing}"; pass override: true to replace it`);
141
+ this.services.set(token.id, service);
142
+ this.providerOf.set(token.id, moduleId);
143
+ },
144
+ events: this.bus.scoped(moduleId),
145
+ logger: require_logger.scopedLogger(this.logger, moduleId),
146
+ config: this.config[moduleId]
147
+ };
148
+ }
149
+ assertProvidersExist() {
150
+ for (const entry of this.entries) for (const tokenId of entry.dependencyIds) if (!this.providerOf.has(tokenId)) throw new KernelError(`Module "${entry.module.id}" depends on service "${tokenId}" but no registered module provides it`);
151
+ }
152
+ /**
153
+ * Topologically sorts modules so providers start before their dependents,
154
+ * preserving registration order among independent modules.
155
+ */
156
+ sortByDependencies() {
157
+ const byId = new Map(this.entries.map((entry) => [entry.module.id, entry]));
158
+ const order = [];
159
+ const state = /* @__PURE__ */ new Map();
160
+ const visit = (entry, path) => {
161
+ const status = state.get(entry.module.id);
162
+ if (status === "done") return;
163
+ if (status === "visiting") throw new KernelError(`Dependency cycle between modules: ${[...path.slice(path.indexOf(entry.module.id)), entry.module.id].join(" -> ")}`);
164
+ state.set(entry.module.id, "visiting");
165
+ path.push(entry.module.id);
166
+ for (const tokenId of entry.dependencyIds) {
167
+ const providerId = this.providerOf.get(tokenId);
168
+ if (providerId === void 0 || providerId === entry.module.id) continue;
169
+ const provider = byId.get(providerId);
170
+ if (provider) visit(provider, path);
171
+ }
172
+ path.pop();
173
+ state.set(entry.module.id, "done");
174
+ order.push(entry);
175
+ };
176
+ for (const entry of this.entries) visit(entry, []);
177
+ return order;
178
+ }
179
+ };
180
+ exports.Kernel = Kernel;
181
+ exports.KernelError = KernelError;
182
+
183
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"kernel.cjs.cjs","names":["KernelEventBus","consoleLogger","scopedLogger"],"sources":["../src/kernel.ts"],"sourcesContent":["import type { EventBus, EventMap } from './events';\nimport { KernelEventBus } from './events';\nimport type { KernelLogger } from './logger';\nimport { consoleLogger, scopedLogger } from './logger';\nimport type { Module, ModuleContext } from './module';\nimport type { ServiceToken } from './token';\n\n/**\n * Error raised for kernel contract violations: missing providers, dependency\n * cycles, duplicate providers, out-of-phase calls, and undeclared `use()`.\n */\nexport class KernelError extends Error {\n    public override readonly name = 'KernelError';\n}\n\n/**\n * Options for constructing a kernel.\n */\nexport interface KernelOptions {\n    /** Per-module configuration, keyed by module id. */\n    readonly config?: Readonly<Record<string, unknown>>;\n    /** Base logger; module loggers are scoped from it. Defaults to the console. */\n    readonly logger?: KernelLogger;\n}\n\ntype KernelPhase = 'created' | 'registered' | 'starting' | 'started';\n\ninterface ModuleEntry<Events extends EventMap> {\n    readonly module: Module<unknown, Events>;\n    readonly context: ModuleContext<unknown, Events>;\n    readonly dependencyIds: ReadonlySet<string>;\n}\n\n/**\n * The module kernel. It owns lifecycle, a token-keyed service registry, and the\n * event bus; everything else — worlds, sessions, commands, networking, the tick\n * loop — is a module.\n *\n * Lifecycle: construct the kernel once, `register()` modules, then drive it\n * through `registerAll()`, `start()`, and `stop()`. `registerAll()` runs every\n * module's `register()` phase exactly once and validates providers and the\n * dependency graph; after it, `get()` resolves provided services. `start()`\n * runs `registerAll()` first when it has not run, then runs the `start()`\n * phases in dependency order. `stop()` runs `stop()` phases in reverse order,\n * logging failures instead of throwing, and returns the kernel to the\n * registered state, so the same kernel — and the services its modules\n * constructed — can be started again. Event listeners a module attaches are\n * detached when it stops; a module that must survive a restart attaches its\n * listeners in `start()`, not `register()`.\n */\nexport class Kernel<Events extends EventMap = EventMap> {\n    private readonly entries: ModuleEntry<Events>[] = [];\n    private readonly services = new Map<string, unknown>();\n    private readonly providerOf = new Map<string, string>();\n    private readonly bus = new KernelEventBus<Events>();\n    private readonly config: Readonly<Record<string, unknown>>;\n    private readonly logger: KernelLogger;\n    private phase: KernelPhase = 'created';\n    private registering: string | undefined;\n    private startOrder: ModuleEntry<Events>[] = [];\n\n    public constructor(options: KernelOptions = {}) {\n        this.config = options.config ?? {};\n        this.logger = options.logger ?? consoleLogger;\n    }\n\n    /** The kernel-owned event bus, unscoped. Module code should use its context's scoped handle. */\n    public get events(): EventBus<Events> {\n        return this.bus;\n    }\n\n    /**\n     * Adds a module. Legal only before `registerAll()` (or the first `start()`,\n     * which runs it).\n     *\n     * @throws KernelError after `registerAll()` or when a module with the same id is already registered.\n     */\n    public register<Config>(module: Module<Config, Events>): void {\n        if (this.phase !== 'created') {\n            throw new KernelError(`Cannot register module \"${module.id}\" after the kernel has run registerAll()`);\n        }\n        if (this.entries.some((entry) => entry.module.id === module.id)) {\n            throw new KernelError(`A module with id \"${module.id}\" is already registered`);\n        }\n        const dependencyIds = new Set((module.dependencies ?? []).map((token) => token.id));\n        const entry: ModuleEntry<Events> = {\n            module,\n            dependencyIds,\n            context: this.createContext(module.id, dependencyIds)\n        };\n        this.entries.push(entry);\n    }\n\n    /**\n     * Runs all `register()` phases, validates providers and the dependency\n     * graph, and computes the start order. After it resolves, `get()` resolves\n     * every provided service even though `start()` has not run. Runs at most\n     * once per kernel; later calls are no-ops.\n     *\n     * @throws KernelError when a declared dependency has no provider or the dependency graph has a cycle.\n     */\n    public async registerAll(): Promise<void> {\n        if (this.phase !== 'created') return;\n        for (const entry of this.entries) {\n            this.registering = entry.module.id;\n            try {\n                await entry.module.register(entry.context);\n            } finally {\n                this.registering = undefined;\n            }\n        }\n        this.assertProvidersExist();\n        this.startOrder = this.sortByDependencies();\n        this.phase = 'registered';\n    }\n\n    /**\n     * Runs `registerAll()` when it has not run, then runs `start()` phases in\n     * dependency order. Legal again after `stop()`: the `register()` phases do\n     * not rerun, so the modules' services carry over into the next start.\n     *\n     * @throws KernelError when the kernel is already starting or started, when\n     * a declared dependency has no provider, or when the dependency graph has a\n     * cycle.\n     */\n    public async start(): Promise<void> {\n        if (this.phase === 'starting' || this.phase === 'started') {\n            throw new KernelError(`Kernel is already ${this.phase}; stop() it before starting again`);\n        }\n        await this.registerAll();\n        this.phase = 'starting';\n        for (const entry of this.startOrder) {\n            await entry.module.start?.(entry.context);\n        }\n        this.phase = 'started';\n    }\n\n    /**\n     * Runs `stop()` phases in reverse start order and detaches each module's\n     * event listeners. Failures are logged, not thrown, so one module cannot\n     * block the others' teardown. Leaves the kernel registered, so `start()`\n     * may run it again; a no-op unless the kernel is started.\n     */\n    public async stop(): Promise<void> {\n        if (this.phase !== 'started') return;\n        this.phase = 'registered';\n        for (const entry of [...this.startOrder].reverse()) {\n            try {\n                await entry.module.stop?.(entry.context);\n            } catch (error) {\n                this.logger.error(`Module \"${entry.module.id}\" failed to stop: ${error}`);\n            } finally {\n                this.bus.removeScope(entry.module.id);\n            }\n        }\n    }\n\n    /**\n     * Resolves a service for the host or for tests. Module code should resolve\n     * through its context instead.\n     *\n     * @throws KernelError when no module has provided the token.\n     */\n    public get<T>(token: ServiceToken<T>): T {\n        if (!this.services.has(token.id)) {\n            throw new KernelError(`No provider for service \"${token.id}\"`);\n        }\n        // The registry stores services untyped; the token's phantom type is the\n        // contract that the provider stored a matching value.\n        return this.services.get(token.id) as T;\n    }\n\n    private createContext(moduleId: string, dependencyIds: ReadonlySet<string>): ModuleContext<unknown, Events> {\n        return {\n            use: <T>(token: ServiceToken<T>): T => {\n                if (!dependencyIds.has(token.id)) {\n                    throw new KernelError(\n                        `Module \"${moduleId}\" used service \"${token.id}\" without declaring it as a dependency`\n                    );\n                }\n                if (!this.services.has(token.id)) {\n                    throw new KernelError(\n                        `Service \"${token.id}\" is not provided yet; resolve dependencies in start(), not register()`\n                    );\n                }\n                return this.get(token);\n            },\n            provide: <T>(token: ServiceToken<T>, service: T, options?: { override?: boolean }): void => {\n                if (this.registering !== moduleId) {\n                    throw new KernelError(\n                        `Module \"${moduleId}\" may only provide \"${token.id}\" during its register() phase`\n                    );\n                }\n                const existing = this.providerOf.get(token.id);\n                if (existing !== undefined && !options?.override) {\n                    throw new KernelError(\n                        `Service \"${token.id}\" is already provided by module \"${existing}\"; pass override: true to replace it`\n                    );\n                }\n                this.services.set(token.id, service);\n                this.providerOf.set(token.id, moduleId);\n            },\n            events: this.bus.scoped(moduleId),\n            logger: scopedLogger(this.logger, moduleId),\n            config: this.config[moduleId]\n        };\n    }\n\n    private assertProvidersExist(): void {\n        for (const entry of this.entries) {\n            for (const tokenId of entry.dependencyIds) {\n                if (!this.providerOf.has(tokenId)) {\n                    throw new KernelError(\n                        `Module \"${entry.module.id}\" depends on service \"${tokenId}\" but no registered module provides it`\n                    );\n                }\n            }\n        }\n    }\n\n    /**\n     * Topologically sorts modules so providers start before their dependents,\n     * preserving registration order among independent modules.\n     */\n    private sortByDependencies(): ModuleEntry<Events>[] {\n        const byId = new Map(this.entries.map((entry) => [entry.module.id, entry]));\n        const order: ModuleEntry<Events>[] = [];\n        const state = new Map<string, 'visiting' | 'done'>();\n        const visit = (entry: ModuleEntry<Events>, path: string[]): void => {\n            const status = state.get(entry.module.id);\n            if (status === 'done') return;\n            if (status === 'visiting') {\n                const cycle = [...path.slice(path.indexOf(entry.module.id)), entry.module.id];\n                throw new KernelError(`Dependency cycle between modules: ${cycle.join(' -> ')}`);\n            }\n            state.set(entry.module.id, 'visiting');\n            path.push(entry.module.id);\n            for (const tokenId of entry.dependencyIds) {\n                const providerId = this.providerOf.get(tokenId);\n                if (providerId === undefined || providerId === entry.module.id) continue;\n                const provider = byId.get(providerId);\n                if (provider) visit(provider, path);\n            }\n            path.pop();\n            state.set(entry.module.id, 'done');\n            order.push(entry);\n        };\n        for (const entry of this.entries) {\n            visit(entry, []);\n        }\n        return order;\n    }\n}\n"],"mappings":"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"}
@@ -0,0 +1,99 @@
1
+ import type { EventBus, EventMap } from './events';
2
+ import type { KernelLogger } from './logger';
3
+ import type { Module } from './module';
4
+ import type { ServiceToken } from './token';
5
+ /**
6
+ * Error raised for kernel contract violations: missing providers, dependency
7
+ * cycles, duplicate providers, out-of-phase calls, and undeclared `use()`.
8
+ */
9
+ export declare class KernelError extends Error {
10
+ readonly name = "KernelError";
11
+ }
12
+ /**
13
+ * Options for constructing a kernel.
14
+ */
15
+ export interface KernelOptions {
16
+ /** Per-module configuration, keyed by module id. */
17
+ readonly config?: Readonly<Record<string, unknown>>;
18
+ /** Base logger; module loggers are scoped from it. Defaults to the console. */
19
+ readonly logger?: KernelLogger;
20
+ }
21
+ /**
22
+ * The module kernel. It owns lifecycle, a token-keyed service registry, and the
23
+ * event bus; everything else — worlds, sessions, commands, networking, the tick
24
+ * loop — is a module.
25
+ *
26
+ * Lifecycle: construct the kernel once, `register()` modules, then drive it
27
+ * through `registerAll()`, `start()`, and `stop()`. `registerAll()` runs every
28
+ * module's `register()` phase exactly once and validates providers and the
29
+ * dependency graph; after it, `get()` resolves provided services. `start()`
30
+ * runs `registerAll()` first when it has not run, then runs the `start()`
31
+ * phases in dependency order. `stop()` runs `stop()` phases in reverse order,
32
+ * logging failures instead of throwing, and returns the kernel to the
33
+ * registered state, so the same kernel — and the services its modules
34
+ * constructed — can be started again. Event listeners a module attaches are
35
+ * detached when it stops; a module that must survive a restart attaches its
36
+ * listeners in `start()`, not `register()`.
37
+ */
38
+ export declare class Kernel<Events extends EventMap = EventMap> {
39
+ private readonly entries;
40
+ private readonly services;
41
+ private readonly providerOf;
42
+ private readonly bus;
43
+ private readonly config;
44
+ private readonly logger;
45
+ private phase;
46
+ private registering;
47
+ private startOrder;
48
+ constructor(options?: KernelOptions);
49
+ /** The kernel-owned event bus, unscoped. Module code should use its context's scoped handle. */
50
+ get events(): EventBus<Events>;
51
+ /**
52
+ * Adds a module. Legal only before `registerAll()` (or the first `start()`,
53
+ * which runs it).
54
+ *
55
+ * @throws KernelError after `registerAll()` or when a module with the same id is already registered.
56
+ */
57
+ register<Config>(module: Module<Config, Events>): void;
58
+ /**
59
+ * Runs all `register()` phases, validates providers and the dependency
60
+ * graph, and computes the start order. After it resolves, `get()` resolves
61
+ * every provided service even though `start()` has not run. Runs at most
62
+ * once per kernel; later calls are no-ops.
63
+ *
64
+ * @throws KernelError when a declared dependency has no provider or the dependency graph has a cycle.
65
+ */
66
+ registerAll(): Promise<void>;
67
+ /**
68
+ * Runs `registerAll()` when it has not run, then runs `start()` phases in
69
+ * dependency order. Legal again after `stop()`: the `register()` phases do
70
+ * not rerun, so the modules' services carry over into the next start.
71
+ *
72
+ * @throws KernelError when the kernel is already starting or started, when
73
+ * a declared dependency has no provider, or when the dependency graph has a
74
+ * cycle.
75
+ */
76
+ start(): Promise<void>;
77
+ /**
78
+ * Runs `stop()` phases in reverse start order and detaches each module's
79
+ * event listeners. Failures are logged, not thrown, so one module cannot
80
+ * block the others' teardown. Leaves the kernel registered, so `start()`
81
+ * may run it again; a no-op unless the kernel is started.
82
+ */
83
+ stop(): Promise<void>;
84
+ /**
85
+ * Resolves a service for the host or for tests. Module code should resolve
86
+ * through its context instead.
87
+ *
88
+ * @throws KernelError when no module has provided the token.
89
+ */
90
+ get<T>(token: ServiceToken<T>): T;
91
+ private createContext;
92
+ private assertProvidersExist;
93
+ /**
94
+ * Topologically sorts modules so providers start before their dependents,
95
+ * preserving registration order among independent modules.
96
+ */
97
+ private sortByDependencies;
98
+ }
99
+ //# sourceMappingURL=kernel.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../src/kernel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,UAAU,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C;;;GAGG;AACH,qBAAa,WAAY,SAAQ,KAAK;IAClC,SAAyB,IAAI,iBAAiB;CACjD;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B,oDAAoD;IACpD,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACpD,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;CAClC;AAUD;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,MAAM,CAAC,MAAM,SAAS,QAAQ,GAAG,QAAQ;IAClD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IACrD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IACvD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAgC;IACpD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoC;IAC3D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,KAAK,CAA0B;IACvC,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,UAAU,CAA6B;IAE/C,YAAmB,OAAO,GAAE,aAAkB,EAG7C;IAED,gGAAgG;IAChG,IAAW,MAAM,IAAI,QAAQ,CAAC,MAAM,CAAC,CAEpC;IAED;;;;;OAKG;IACI,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAc5D;IAED;;;;;;;OAOG;IACU,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAaxC;IAED;;;;;;;;OAQG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAUlC;IAED;;;;;OAKG;IACU,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAYjC;IAED;;;;;OAKG;IACI,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAOvC;IAED,OAAO,CAAC,aAAa;IAoCrB,OAAO,CAAC,oBAAoB;IAY5B;;;OAGG;IACH,OAAO,CAAC,kBAAkB;CA4B7B"}
@@ -0,0 +1,180 @@
1
+ import { KernelEventBus } from "./events.es.js";
2
+ import { consoleLogger, scopedLogger } from "./logger.es.js";
3
+ // src/kernel.ts
4
+ /**
5
+ * Error raised for kernel contract violations: missing providers, dependency
6
+ * cycles, duplicate providers, out-of-phase calls, and undeclared `use()`.
7
+ */
8
+ var KernelError = class extends Error {
9
+ name = "KernelError";
10
+ };
11
+ /**
12
+ * The module kernel. It owns lifecycle, a token-keyed service registry, and the
13
+ * event bus; everything else — worlds, sessions, commands, networking, the tick
14
+ * loop — is a module.
15
+ *
16
+ * Lifecycle: construct the kernel once, `register()` modules, then drive it
17
+ * through `registerAll()`, `start()`, and `stop()`. `registerAll()` runs every
18
+ * module's `register()` phase exactly once and validates providers and the
19
+ * dependency graph; after it, `get()` resolves provided services. `start()`
20
+ * runs `registerAll()` first when it has not run, then runs the `start()`
21
+ * phases in dependency order. `stop()` runs `stop()` phases in reverse order,
22
+ * logging failures instead of throwing, and returns the kernel to the
23
+ * registered state, so the same kernel — and the services its modules
24
+ * constructed — can be started again. Event listeners a module attaches are
25
+ * detached when it stops; a module that must survive a restart attaches its
26
+ * listeners in `start()`, not `register()`.
27
+ */
28
+ var Kernel = class {
29
+ entries = [];
30
+ services = /* @__PURE__ */ new Map();
31
+ providerOf = /* @__PURE__ */ new Map();
32
+ bus = new KernelEventBus();
33
+ config;
34
+ logger;
35
+ phase = "created";
36
+ registering;
37
+ startOrder = [];
38
+ constructor(options = {}) {
39
+ this.config = options.config ?? {};
40
+ this.logger = options.logger ?? consoleLogger;
41
+ }
42
+ /** The kernel-owned event bus, unscoped. Module code should use its context's scoped handle. */
43
+ get events() {
44
+ return this.bus;
45
+ }
46
+ /**
47
+ * Adds a module. Legal only before `registerAll()` (or the first `start()`,
48
+ * which runs it).
49
+ *
50
+ * @throws KernelError after `registerAll()` or when a module with the same id is already registered.
51
+ */
52
+ register(module) {
53
+ if (this.phase !== "created") throw new KernelError(`Cannot register module "${module.id}" after the kernel has run registerAll()`);
54
+ if (this.entries.some((entry) => entry.module.id === module.id)) throw new KernelError(`A module with id "${module.id}" is already registered`);
55
+ const dependencyIds = new Set((module.dependencies ?? []).map((token) => token.id));
56
+ const entry = {
57
+ module,
58
+ dependencyIds,
59
+ context: this.createContext(module.id, dependencyIds)
60
+ };
61
+ this.entries.push(entry);
62
+ }
63
+ /**
64
+ * Runs all `register()` phases, validates providers and the dependency
65
+ * graph, and computes the start order. After it resolves, `get()` resolves
66
+ * every provided service even though `start()` has not run. Runs at most
67
+ * once per kernel; later calls are no-ops.
68
+ *
69
+ * @throws KernelError when a declared dependency has no provider or the dependency graph has a cycle.
70
+ */
71
+ async registerAll() {
72
+ if (this.phase !== "created") return;
73
+ for (const entry of this.entries) {
74
+ this.registering = entry.module.id;
75
+ try {
76
+ await entry.module.register(entry.context);
77
+ } finally {
78
+ this.registering = void 0;
79
+ }
80
+ }
81
+ this.assertProvidersExist();
82
+ this.startOrder = this.sortByDependencies();
83
+ this.phase = "registered";
84
+ }
85
+ /**
86
+ * Runs `registerAll()` when it has not run, then runs `start()` phases in
87
+ * dependency order. Legal again after `stop()`: the `register()` phases do
88
+ * not rerun, so the modules' services carry over into the next start.
89
+ *
90
+ * @throws KernelError when the kernel is already starting or started, when
91
+ * a declared dependency has no provider, or when the dependency graph has a
92
+ * cycle.
93
+ */
94
+ async start() {
95
+ if (this.phase === "starting" || this.phase === "started") throw new KernelError(`Kernel is already ${this.phase}; stop() it before starting again`);
96
+ await this.registerAll();
97
+ this.phase = "starting";
98
+ for (const entry of this.startOrder) await entry.module.start?.(entry.context);
99
+ this.phase = "started";
100
+ }
101
+ /**
102
+ * Runs `stop()` phases in reverse start order and detaches each module's
103
+ * event listeners. Failures are logged, not thrown, so one module cannot
104
+ * block the others' teardown. Leaves the kernel registered, so `start()`
105
+ * may run it again; a no-op unless the kernel is started.
106
+ */
107
+ async stop() {
108
+ if (this.phase !== "started") return;
109
+ this.phase = "registered";
110
+ for (const entry of [...this.startOrder].reverse()) try {
111
+ await entry.module.stop?.(entry.context);
112
+ } catch (error) {
113
+ this.logger.error(`Module "${entry.module.id}" failed to stop: ${error}`);
114
+ } finally {
115
+ this.bus.removeScope(entry.module.id);
116
+ }
117
+ }
118
+ /**
119
+ * Resolves a service for the host or for tests. Module code should resolve
120
+ * through its context instead.
121
+ *
122
+ * @throws KernelError when no module has provided the token.
123
+ */
124
+ get(token) {
125
+ if (!this.services.has(token.id)) throw new KernelError(`No provider for service "${token.id}"`);
126
+ return this.services.get(token.id);
127
+ }
128
+ createContext(moduleId, dependencyIds) {
129
+ return {
130
+ use: (token) => {
131
+ if (!dependencyIds.has(token.id)) throw new KernelError(`Module "${moduleId}" used service "${token.id}" without declaring it as a dependency`);
132
+ if (!this.services.has(token.id)) throw new KernelError(`Service "${token.id}" is not provided yet; resolve dependencies in start(), not register()`);
133
+ return this.get(token);
134
+ },
135
+ provide: (token, service, options) => {
136
+ if (this.registering !== moduleId) throw new KernelError(`Module "${moduleId}" may only provide "${token.id}" during its register() phase`);
137
+ const existing = this.providerOf.get(token.id);
138
+ if (existing !== void 0 && !options?.override) throw new KernelError(`Service "${token.id}" is already provided by module "${existing}"; pass override: true to replace it`);
139
+ this.services.set(token.id, service);
140
+ this.providerOf.set(token.id, moduleId);
141
+ },
142
+ events: this.bus.scoped(moduleId),
143
+ logger: scopedLogger(this.logger, moduleId),
144
+ config: this.config[moduleId]
145
+ };
146
+ }
147
+ assertProvidersExist() {
148
+ for (const entry of this.entries) for (const tokenId of entry.dependencyIds) if (!this.providerOf.has(tokenId)) throw new KernelError(`Module "${entry.module.id}" depends on service "${tokenId}" but no registered module provides it`);
149
+ }
150
+ /**
151
+ * Topologically sorts modules so providers start before their dependents,
152
+ * preserving registration order among independent modules.
153
+ */
154
+ sortByDependencies() {
155
+ const byId = new Map(this.entries.map((entry) => [entry.module.id, entry]));
156
+ const order = [];
157
+ const state = /* @__PURE__ */ new Map();
158
+ const visit = (entry, path) => {
159
+ const status = state.get(entry.module.id);
160
+ if (status === "done") return;
161
+ if (status === "visiting") throw new KernelError(`Dependency cycle between modules: ${[...path.slice(path.indexOf(entry.module.id)), entry.module.id].join(" -> ")}`);
162
+ state.set(entry.module.id, "visiting");
163
+ path.push(entry.module.id);
164
+ for (const tokenId of entry.dependencyIds) {
165
+ const providerId = this.providerOf.get(tokenId);
166
+ if (providerId === void 0 || providerId === entry.module.id) continue;
167
+ const provider = byId.get(providerId);
168
+ if (provider) visit(provider, path);
169
+ }
170
+ path.pop();
171
+ state.set(entry.module.id, "done");
172
+ order.push(entry);
173
+ };
174
+ for (const entry of this.entries) visit(entry, []);
175
+ return order;
176
+ }
177
+ };
178
+ export { Kernel, KernelError };
179
+
180
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"kernel.es.js","names":[],"sources":["../src/kernel.ts"],"sourcesContent":["import type { EventBus, EventMap } from './events';\nimport { KernelEventBus } from './events';\nimport type { KernelLogger } from './logger';\nimport { consoleLogger, scopedLogger } from './logger';\nimport type { Module, ModuleContext } from './module';\nimport type { ServiceToken } from './token';\n\n/**\n * Error raised for kernel contract violations: missing providers, dependency\n * cycles, duplicate providers, out-of-phase calls, and undeclared `use()`.\n */\nexport class KernelError extends Error {\n    public override readonly name = 'KernelError';\n}\n\n/**\n * Options for constructing a kernel.\n */\nexport interface KernelOptions {\n    /** Per-module configuration, keyed by module id. */\n    readonly config?: Readonly<Record<string, unknown>>;\n    /** Base logger; module loggers are scoped from it. Defaults to the console. */\n    readonly logger?: KernelLogger;\n}\n\ntype KernelPhase = 'created' | 'registered' | 'starting' | 'started';\n\ninterface ModuleEntry<Events extends EventMap> {\n    readonly module: Module<unknown, Events>;\n    readonly context: ModuleContext<unknown, Events>;\n    readonly dependencyIds: ReadonlySet<string>;\n}\n\n/**\n * The module kernel. It owns lifecycle, a token-keyed service registry, and the\n * event bus; everything else — worlds, sessions, commands, networking, the tick\n * loop — is a module.\n *\n * Lifecycle: construct the kernel once, `register()` modules, then drive it\n * through `registerAll()`, `start()`, and `stop()`. `registerAll()` runs every\n * module's `register()` phase exactly once and validates providers and the\n * dependency graph; after it, `get()` resolves provided services. `start()`\n * runs `registerAll()` first when it has not run, then runs the `start()`\n * phases in dependency order. `stop()` runs `stop()` phases in reverse order,\n * logging failures instead of throwing, and returns the kernel to the\n * registered state, so the same kernel — and the services its modules\n * constructed — can be started again. Event listeners a module attaches are\n * detached when it stops; a module that must survive a restart attaches its\n * listeners in `start()`, not `register()`.\n */\nexport class Kernel<Events extends EventMap = EventMap> {\n    private readonly entries: ModuleEntry<Events>[] = [];\n    private readonly services = new Map<string, unknown>();\n    private readonly providerOf = new Map<string, string>();\n    private readonly bus = new KernelEventBus<Events>();\n    private readonly config: Readonly<Record<string, unknown>>;\n    private readonly logger: KernelLogger;\n    private phase: KernelPhase = 'created';\n    private registering: string | undefined;\n    private startOrder: ModuleEntry<Events>[] = [];\n\n    public constructor(options: KernelOptions = {}) {\n        this.config = options.config ?? {};\n        this.logger = options.logger ?? consoleLogger;\n    }\n\n    /** The kernel-owned event bus, unscoped. Module code should use its context's scoped handle. */\n    public get events(): EventBus<Events> {\n        return this.bus;\n    }\n\n    /**\n     * Adds a module. Legal only before `registerAll()` (or the first `start()`,\n     * which runs it).\n     *\n     * @throws KernelError after `registerAll()` or when a module with the same id is already registered.\n     */\n    public register<Config>(module: Module<Config, Events>): void {\n        if (this.phase !== 'created') {\n            throw new KernelError(`Cannot register module \"${module.id}\" after the kernel has run registerAll()`);\n        }\n        if (this.entries.some((entry) => entry.module.id === module.id)) {\n            throw new KernelError(`A module with id \"${module.id}\" is already registered`);\n        }\n        const dependencyIds = new Set((module.dependencies ?? []).map((token) => token.id));\n        const entry: ModuleEntry<Events> = {\n            module,\n            dependencyIds,\n            context: this.createContext(module.id, dependencyIds)\n        };\n        this.entries.push(entry);\n    }\n\n    /**\n     * Runs all `register()` phases, validates providers and the dependency\n     * graph, and computes the start order. After it resolves, `get()` resolves\n     * every provided service even though `start()` has not run. Runs at most\n     * once per kernel; later calls are no-ops.\n     *\n     * @throws KernelError when a declared dependency has no provider or the dependency graph has a cycle.\n     */\n    public async registerAll(): Promise<void> {\n        if (this.phase !== 'created') return;\n        for (const entry of this.entries) {\n            this.registering = entry.module.id;\n            try {\n                await entry.module.register(entry.context);\n            } finally {\n                this.registering = undefined;\n            }\n        }\n        this.assertProvidersExist();\n        this.startOrder = this.sortByDependencies();\n        this.phase = 'registered';\n    }\n\n    /**\n     * Runs `registerAll()` when it has not run, then runs `start()` phases in\n     * dependency order. Legal again after `stop()`: the `register()` phases do\n     * not rerun, so the modules' services carry over into the next start.\n     *\n     * @throws KernelError when the kernel is already starting or started, when\n     * a declared dependency has no provider, or when the dependency graph has a\n     * cycle.\n     */\n    public async start(): Promise<void> {\n        if (this.phase === 'starting' || this.phase === 'started') {\n            throw new KernelError(`Kernel is already ${this.phase}; stop() it before starting again`);\n        }\n        await this.registerAll();\n        this.phase = 'starting';\n        for (const entry of this.startOrder) {\n            await entry.module.start?.(entry.context);\n        }\n        this.phase = 'started';\n    }\n\n    /**\n     * Runs `stop()` phases in reverse start order and detaches each module's\n     * event listeners. Failures are logged, not thrown, so one module cannot\n     * block the others' teardown. Leaves the kernel registered, so `start()`\n     * may run it again; a no-op unless the kernel is started.\n     */\n    public async stop(): Promise<void> {\n        if (this.phase !== 'started') return;\n        this.phase = 'registered';\n        for (const entry of [...this.startOrder].reverse()) {\n            try {\n                await entry.module.stop?.(entry.context);\n            } catch (error) {\n                this.logger.error(`Module \"${entry.module.id}\" failed to stop: ${error}`);\n            } finally {\n                this.bus.removeScope(entry.module.id);\n            }\n        }\n    }\n\n    /**\n     * Resolves a service for the host or for tests. Module code should resolve\n     * through its context instead.\n     *\n     * @throws KernelError when no module has provided the token.\n     */\n    public get<T>(token: ServiceToken<T>): T {\n        if (!this.services.has(token.id)) {\n            throw new KernelError(`No provider for service \"${token.id}\"`);\n        }\n        // The registry stores services untyped; the token's phantom type is the\n        // contract that the provider stored a matching value.\n        return this.services.get(token.id) as T;\n    }\n\n    private createContext(moduleId: string, dependencyIds: ReadonlySet<string>): ModuleContext<unknown, Events> {\n        return {\n            use: <T>(token: ServiceToken<T>): T => {\n                if (!dependencyIds.has(token.id)) {\n                    throw new KernelError(\n                        `Module \"${moduleId}\" used service \"${token.id}\" without declaring it as a dependency`\n                    );\n                }\n                if (!this.services.has(token.id)) {\n                    throw new KernelError(\n                        `Service \"${token.id}\" is not provided yet; resolve dependencies in start(), not register()`\n                    );\n                }\n                return this.get(token);\n            },\n            provide: <T>(token: ServiceToken<T>, service: T, options?: { override?: boolean }): void => {\n                if (this.registering !== moduleId) {\n                    throw new KernelError(\n                        `Module \"${moduleId}\" may only provide \"${token.id}\" during its register() phase`\n                    );\n                }\n                const existing = this.providerOf.get(token.id);\n                if (existing !== undefined && !options?.override) {\n                    throw new KernelError(\n                        `Service \"${token.id}\" is already provided by module \"${existing}\"; pass override: true to replace it`\n                    );\n                }\n                this.services.set(token.id, service);\n                this.providerOf.set(token.id, moduleId);\n            },\n            events: this.bus.scoped(moduleId),\n            logger: scopedLogger(this.logger, moduleId),\n            config: this.config[moduleId]\n        };\n    }\n\n    private assertProvidersExist(): void {\n        for (const entry of this.entries) {\n            for (const tokenId of entry.dependencyIds) {\n                if (!this.providerOf.has(tokenId)) {\n                    throw new KernelError(\n                        `Module \"${entry.module.id}\" depends on service \"${tokenId}\" but no registered module provides it`\n                    );\n                }\n            }\n        }\n    }\n\n    /**\n     * Topologically sorts modules so providers start before their dependents,\n     * preserving registration order among independent modules.\n     */\n    private sortByDependencies(): ModuleEntry<Events>[] {\n        const byId = new Map(this.entries.map((entry) => [entry.module.id, entry]));\n        const order: ModuleEntry<Events>[] = [];\n        const state = new Map<string, 'visiting' | 'done'>();\n        const visit = (entry: ModuleEntry<Events>, path: string[]): void => {\n            const status = state.get(entry.module.id);\n            if (status === 'done') return;\n            if (status === 'visiting') {\n                const cycle = [...path.slice(path.indexOf(entry.module.id)), entry.module.id];\n                throw new KernelError(`Dependency cycle between modules: ${cycle.join(' -> ')}`);\n            }\n            state.set(entry.module.id, 'visiting');\n            path.push(entry.module.id);\n            for (const tokenId of entry.dependencyIds) {\n                const providerId = this.providerOf.get(tokenId);\n                if (providerId === undefined || providerId === entry.module.id) continue;\n                const provider = byId.get(providerId);\n                if (provider) visit(provider, path);\n            }\n            path.pop();\n            state.set(entry.module.id, 'done');\n            order.push(entry);\n        };\n        for (const entry of this.entries) {\n            visit(entry, []);\n        }\n        return order;\n    }\n}\n"],"mappings":"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"}
@@ -0,0 +1,28 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
3
+ // src/logger.ts
4
+ /**
5
+ * The default kernel logger, backed by the global console.
6
+ */
7
+ var consoleLogger = {
8
+ debug: (message) => console.debug(message),
9
+ info: (message) => console.debug(message),
10
+ warn: (message) => console.warn(message),
11
+ error: (message) => console.error(message)
12
+ };
13
+ /**
14
+ * Wraps a logger so every message is prefixed with a scope, e.g. a module id.
15
+ */
16
+ function scopedLogger(base, scope) {
17
+ const prefix = `[${scope}] `;
18
+ return {
19
+ debug: (message) => base.debug(prefix + message),
20
+ info: (message) => base.info(prefix + message),
21
+ warn: (message) => base.warn(prefix + message),
22
+ error: (message) => base.error(prefix + message)
23
+ };
24
+ }
25
+ exports.consoleLogger = consoleLogger;
26
+ exports.scopedLogger = scopedLogger;
27
+
28
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmNqcy5janMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vc3JjL2xvZ2dlci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFRoZSBtaW5pbWFsIGxvZ2dpbmcgc3VyZmFjZSB0aGUga2VybmVsIG5lZWRzLlxuICpcbiAqIGBAanNwcmlzbWFyaW5lL2xvZ2dlcmAncyBgTG9nZ2VyYCBzYXRpc2ZpZXMgdGhpcyBzdHJ1Y3R1cmFsbHk7IHRoZSBrZXJuZWwgZG9lc1xuICogbm90IGRlcGVuZCBvbiBpdCBzbyB0aGF0IGhvc3RzIGFuZCB0ZXN0cyBjYW4gc3VwcGx5IGFueSBpbXBsZW1lbnRhdGlvbi5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBLZXJuZWxMb2dnZXIge1xuICAgIC8qKiBMb2dzIGRpYWdub3N0aWMgZGV0YWlsLiAqL1xuICAgIGRlYnVnKG1lc3NhZ2U6IHN0cmluZyk6IHZvaWQ7XG4gICAgLyoqIExvZ3Mgcm91dGluZSBsaWZlY3ljbGUgaW5mb3JtYXRpb24uICovXG4gICAgaW5mbyhtZXNzYWdlOiBzdHJpbmcpOiB2b2lkO1xuICAgIC8qKiBMb2dzIGEgcmVjb3ZlcmFibGUgcHJvYmxlbS4gKi9cbiAgICB3YXJuKG1lc3NhZ2U6IHN0cmluZyk6IHZvaWQ7XG4gICAgLyoqIExvZ3MgYSBmYWlsdXJlLiAqL1xuICAgIGVycm9yKG1lc3NhZ2U6IHN0cmluZyk6IHZvaWQ7XG59XG5cbi8qKlxuICogVGhlIGRlZmF1bHQga2VybmVsIGxvZ2dlciwgYmFja2VkIGJ5IHRoZSBnbG9iYWwgY29uc29sZS5cbiAqL1xuZXhwb3J0IGNvbnN0IGNvbnNvbGVMb2dnZXI6IEtlcm5lbExvZ2dlciA9IHtcbiAgICBkZWJ1ZzogKG1lc3NhZ2UpID0+IGNvbnNvbGUuZGVidWcobWVzc2FnZSksXG4gICAgLy8gVGhlIHJlcG9zaXRvcnkgbGludCByZXNlcnZlcyBjb25zb2xlLmluZm8vbG9nIGZvciBkZWJ1Z2dpbmc7IHJvdXRlXG4gICAgLy8gcm91dGluZSBrZXJuZWwgbWVzc2FnZXMgdGhyb3VnaCBjb25zb2xlLmRlYnVnIGFzIHdlbGwuXG4gICAgaW5mbzogKG1lc3NhZ2UpID0+IGNvbnNvbGUuZGVidWcobWVzc2FnZSksXG4gICAgd2FybjogKG1lc3NhZ2UpID0+IGNvbnNvbGUud2FybihtZXNzYWdlKSxcbiAgICBlcnJvcjogKG1lc3NhZ2UpID0+IGNvbnNvbGUuZXJyb3IobWVzc2FnZSlcbn07XG5cbi8qKlxuICogV3JhcHMgYSBsb2dnZXIgc28gZXZlcnkgbWVzc2FnZSBpcyBwcmVmaXhlZCB3aXRoIGEgc2NvcGUsIGUuZy4gYSBtb2R1bGUgaWQuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzY29wZWRMb2dnZXIoYmFzZTogS2VybmVsTG9nZ2VyLCBzY29wZTogc3RyaW5nKTogS2VybmVsTG9nZ2VyIHtcbiAgICBjb25zdCBwcmVmaXggPSBgWyR7c2NvcGV9XSBgO1xuICAgIHJldHVybiB7XG4gICAgICAgIGRlYnVnOiAobWVzc2FnZSkgPT4gYmFzZS5kZWJ1ZyhwcmVmaXggKyBtZXNzYWdlKSxcbiAgICAgICAgaW5mbzogKG1lc3NhZ2UpID0+IGJhc2UuaW5mbyhwcmVmaXggKyBtZXNzYWdlKSxcbiAgICAgICAgd2FybjogKG1lc3NhZ2UpID0+IGJhc2Uud2FybihwcmVmaXggKyBtZXNzYWdlKSxcbiAgICAgICAgZXJyb3I6IChtZXNzYWdlKSA9PiBiYXNlLmVycm9yKHByZWZpeCArIG1lc3NhZ2UpXG4gICAgfTtcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBb0JBLElBQWEsZ0JBQThCO0NBQ3ZDLFFBQVEsWUFBWSxRQUFRLE1BQU0sT0FBTztDQUd6QyxPQUFPLFlBQVksUUFBUSxNQUFNLE9BQU87Q0FDeEMsT0FBTyxZQUFZLFFBQVEsS0FBSyxPQUFPO0NBQ3ZDLFFBQVEsWUFBWSxRQUFRLE1BQU0sT0FBTztBQUM3Qzs7OztBQUtBLFNBQWdCLGFBQWEsTUFBb0IsT0FBNkI7Q0FDMUUsTUFBTSxTQUFTLElBQUksTUFBTTtDQUN6QixPQUFPO0VBQ0gsUUFBUSxZQUFZLEtBQUssTUFBTSxTQUFTLE9BQU87RUFDL0MsT0FBTyxZQUFZLEtBQUssS0FBSyxTQUFTLE9BQU87RUFDN0MsT0FBTyxZQUFZLEtBQUssS0FBSyxTQUFTLE9BQU87RUFDN0MsUUFBUSxZQUFZLEtBQUssTUFBTSxTQUFTLE9BQU87Q0FDbkQ7QUFDSiJ9
@@ -0,0 +1,25 @@
1
+ /**
2
+ * The minimal logging surface the kernel needs.
3
+ *
4
+ * `@jsprismarine/logger`'s `Logger` satisfies this structurally; the kernel does
5
+ * not depend on it so that hosts and tests can supply any implementation.
6
+ */
7
+ export interface KernelLogger {
8
+ /** Logs diagnostic detail. */
9
+ debug(message: string): void;
10
+ /** Logs routine lifecycle information. */
11
+ info(message: string): void;
12
+ /** Logs a recoverable problem. */
13
+ warn(message: string): void;
14
+ /** Logs a failure. */
15
+ error(message: string): void;
16
+ }
17
+ /**
18
+ * The default kernel logger, backed by the global console.
19
+ */
20
+ export declare const consoleLogger: KernelLogger;
21
+ /**
22
+ * Wraps a logger so every message is prefixed with a scope, e.g. a module id.
23
+ */
24
+ export declare function scopedLogger(base: KernelLogger, scope: string): KernelLogger;
25
+ //# sourceMappingURL=logger.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IACzB,8BAA8B;IAC9B,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,0CAA0C;IAC1C,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,kCAAkC;IAClC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,sBAAsB;IACtB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,YAO3B,CAAC;AAEF;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAQ5E"}
@@ -0,0 +1,25 @@
1
+ // src/logger.ts
2
+ /**
3
+ * The default kernel logger, backed by the global console.
4
+ */
5
+ var consoleLogger = {
6
+ debug: (message) => console.debug(message),
7
+ info: (message) => console.debug(message),
8
+ warn: (message) => console.warn(message),
9
+ error: (message) => console.error(message)
10
+ };
11
+ /**
12
+ * Wraps a logger so every message is prefixed with a scope, e.g. a module id.
13
+ */
14
+ function scopedLogger(base, scope) {
15
+ const prefix = `[${scope}] `;
16
+ return {
17
+ debug: (message) => base.debug(prefix + message),
18
+ info: (message) => base.info(prefix + message),
19
+ warn: (message) => base.warn(prefix + message),
20
+ error: (message) => base.error(prefix + message)
21
+ };
22
+ }
23
+ export { consoleLogger, scopedLogger };
24
+
25
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmVzLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uL3NyYy9sb2dnZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUaGUgbWluaW1hbCBsb2dnaW5nIHN1cmZhY2UgdGhlIGtlcm5lbCBuZWVkcy5cbiAqXG4gKiBgQGpzcHJpc21hcmluZS9sb2dnZXJgJ3MgYExvZ2dlcmAgc2F0aXNmaWVzIHRoaXMgc3RydWN0dXJhbGx5OyB0aGUga2VybmVsIGRvZXNcbiAqIG5vdCBkZXBlbmQgb24gaXQgc28gdGhhdCBob3N0cyBhbmQgdGVzdHMgY2FuIHN1cHBseSBhbnkgaW1wbGVtZW50YXRpb24uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgS2VybmVsTG9nZ2VyIHtcbiAgICAvKiogTG9ncyBkaWFnbm9zdGljIGRldGFpbC4gKi9cbiAgICBkZWJ1ZyhtZXNzYWdlOiBzdHJpbmcpOiB2b2lkO1xuICAgIC8qKiBMb2dzIHJvdXRpbmUgbGlmZWN5Y2xlIGluZm9ybWF0aW9uLiAqL1xuICAgIGluZm8obWVzc2FnZTogc3RyaW5nKTogdm9pZDtcbiAgICAvKiogTG9ncyBhIHJlY292ZXJhYmxlIHByb2JsZW0uICovXG4gICAgd2FybihtZXNzYWdlOiBzdHJpbmcpOiB2b2lkO1xuICAgIC8qKiBMb2dzIGEgZmFpbHVyZS4gKi9cbiAgICBlcnJvcihtZXNzYWdlOiBzdHJpbmcpOiB2b2lkO1xufVxuXG4vKipcbiAqIFRoZSBkZWZhdWx0IGtlcm5lbCBsb2dnZXIsIGJhY2tlZCBieSB0aGUgZ2xvYmFsIGNvbnNvbGUuXG4gKi9cbmV4cG9ydCBjb25zdCBjb25zb2xlTG9nZ2VyOiBLZXJuZWxMb2dnZXIgPSB7XG4gICAgZGVidWc6IChtZXNzYWdlKSA9PiBjb25zb2xlLmRlYnVnKG1lc3NhZ2UpLFxuICAgIC8vIFRoZSByZXBvc2l0b3J5IGxpbnQgcmVzZXJ2ZXMgY29uc29sZS5pbmZvL2xvZyBmb3IgZGVidWdnaW5nOyByb3V0ZVxuICAgIC8vIHJvdXRpbmUga2VybmVsIG1lc3NhZ2VzIHRocm91Z2ggY29uc29sZS5kZWJ1ZyBhcyB3ZWxsLlxuICAgIGluZm86IChtZXNzYWdlKSA9PiBjb25zb2xlLmRlYnVnKG1lc3NhZ2UpLFxuICAgIHdhcm46IChtZXNzYWdlKSA9PiBjb25zb2xlLndhcm4obWVzc2FnZSksXG4gICAgZXJyb3I6IChtZXNzYWdlKSA9PiBjb25zb2xlLmVycm9yKG1lc3NhZ2UpXG59O1xuXG4vKipcbiAqIFdyYXBzIGEgbG9nZ2VyIHNvIGV2ZXJ5IG1lc3NhZ2UgaXMgcHJlZml4ZWQgd2l0aCBhIHNjb3BlLCBlLmcuIGEgbW9kdWxlIGlkLlxuICovXG5leHBvcnQgZnVuY3Rpb24gc2NvcGVkTG9nZ2VyKGJhc2U6IEtlcm5lbExvZ2dlciwgc2NvcGU6IHN0cmluZyk6IEtlcm5lbExvZ2dlciB7XG4gICAgY29uc3QgcHJlZml4ID0gYFske3Njb3BlfV0gYDtcbiAgICByZXR1cm4ge1xuICAgICAgICBkZWJ1ZzogKG1lc3NhZ2UpID0+IGJhc2UuZGVidWcocHJlZml4ICsgbWVzc2FnZSksXG4gICAgICAgIGluZm86IChtZXNzYWdlKSA9PiBiYXNlLmluZm8ocHJlZml4ICsgbWVzc2FnZSksXG4gICAgICAgIHdhcm46IChtZXNzYWdlKSA9PiBiYXNlLndhcm4ocHJlZml4ICsgbWVzc2FnZSksXG4gICAgICAgIGVycm9yOiAobWVzc2FnZSkgPT4gYmFzZS5lcnJvcihwcmVmaXggKyBtZXNzYWdlKVxuICAgIH07XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7QUFvQkEsSUFBYSxnQkFBOEI7Q0FDdkMsUUFBUSxZQUFZLFFBQVEsTUFBTSxPQUFPO0NBR3pDLE9BQU8sWUFBWSxRQUFRLE1BQU0sT0FBTztDQUN4QyxPQUFPLFlBQVksUUFBUSxLQUFLLE9BQU87Q0FDdkMsUUFBUSxZQUFZLFFBQVEsTUFBTSxPQUFPO0FBQzdDOzs7O0FBS0EsU0FBZ0IsYUFBYSxNQUFvQixPQUE2QjtDQUMxRSxNQUFNLFNBQVMsSUFBSSxNQUFNO0NBQ3pCLE9BQU87RUFDSCxRQUFRLFlBQVksS0FBSyxNQUFNLFNBQVMsT0FBTztFQUMvQyxPQUFPLFlBQVksS0FBSyxLQUFLLFNBQVMsT0FBTztFQUM3QyxPQUFPLFlBQVksS0FBSyxLQUFLLFNBQVMsT0FBTztFQUM3QyxRQUFRLFlBQVksS0FBSyxNQUFNLFNBQVMsT0FBTztDQUNuRDtBQUNKIn0=
@@ -0,0 +1,2 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });