maka-agent 0.2.0-dev.26.20260909 → 0.2.0-dev.27.20260910

package/node_modules/@maka/runtime/dist/plugin-data-services.js

@@ -0,0 +1,332 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+import { pluginIdentity, registerPluginContribution } from './plugin-runtime.js';
+class PluginNamespacedDataService extends Service {
+    domain;
+    dataRuntime;
+    constructor(ctx, name, domain) {
+        super(ctx, name);
+        this.domain = domain;
+    }
+    bindRuntime(runtime) {
+        if (this.ctx.maka)
+            throw new Error(`Only the Host may bind the Plugin ${this.domain} Runtime`);
+        if (this.dataRuntime)
+            throw new Error(`Plugin ${this.domain} Runtime is already bound`);
+        this.dataRuntime = runtime;
+        return this.ctx.effect(() => () => {
+            if (this.dataRuntime === runtime)
+                this.dataRuntime = undefined;
+        }, `${this.domain}.bindRuntime()`);
+    }
+    runtime() {
+        if (!this.dataRuntime)
+            throw new Error(`Plugin ${this.domain} Runtime is unavailable`);
+        return this.dataRuntime;
+    }
+    namespace() {
+        const { extensionId, scopeId } = pluginIdentity(this.ctx);
+        return Object.freeze({ extensionId, scopeId });
+    }
+    readValue(key) {
+        return this.runtime().read(this.namespace(), this.domain, validKey(key));
+    }
+    listValues(prefix) {
+        return this.runtime().list(this.namespace(), this.domain, prefix === undefined ? undefined : validPrefix(prefix));
+    }
+    mutateValues(mutations) {
+        return this.runtime().mutate(this.namespace(), this.domain, Object.freeze(mutations.map((mutation) => Object.freeze({
+            ...mutation,
+            key: validKey(mutation.key),
+            ...(mutation.value === undefined ? {} : { value: detached(mutation.value) }),
+        }))));
+    }
+    watchValues(listener) {
+        const subscribe = this.runtime().subscribe;
+        if (!subscribe)
+            throw new Error(`Plugin ${this.domain} subscriptions are unavailable`);
+        return subscribe(this.namespace(), this.domain, listener);
+    }
+}
+/** Per-extension Settings with schema contributions, CAS revisions, and no global-policy access. */
+export class PluginSettingsService extends PluginNamespacedDataService {
+    definitions = new Map();
+    constructor(ctx) {
+        super(ctx, 'settings', 'settings');
+    }
+    define(definition) {
+        validateSettingDefinition(definition);
+        const identity = pluginIdentity(this.ctx);
+        return registerPluginContribution(this.ctx, `settings.define(${JSON.stringify(definition.key)})`, () => {
+            const id = `${identity.scopeId}\0${identity.extensionId}\0${definition.key}`;
+            if (this.definitions.has(id))
+                throw new Error(`Plugin Setting is already defined: ${definition.key}`);
+            this.definitions.set(id, Object.freeze({
+                ...definition,
+                ...(definition.defaultValue === undefined
+                    ? {}
+                    : { defaultValue: detached(definition.defaultValue) }),
+            }));
+            return () => {
+                this.definitions.delete(id);
+            };
+        });
+    }
+    async get(key) {
+        const snapshot = await this.readValue(key);
+        if (snapshot.value !== undefined)
+            return snapshot;
+        const definition = this.definition(key);
+        return definition?.defaultValue === undefined
+            ? snapshot
+            : Object.freeze({
+                revision: snapshot.revision,
+                value: detached(definition.defaultValue),
+            });
+    }
+    async set(key, value, options = {}) {
+        const definition = this.definition(key);
+        if (!definition)
+            throw new Error(`Plugin Setting is not defined: ${key}`);
+        if (definition.secret)
+            throw new Error(`Secret Setting must use ctx.authorization: ${key}`);
+        if (definition.validate && !definition.validate(value))
+            throw new TypeError(`Plugin Setting failed validation: ${key}`);
+        const result = await this.mutateValues([{ key, value, ...options }]);
+        return result[key];
+    }
+    async delete(key, options = {}) {
+        const result = await this.mutateValues([{ key, ...options }]);
+        return result[key];
+    }
+    list(prefix) {
+        return this.listValues(prefix);
+    }
+    watch(listener) {
+        return this.watchValues(listener);
+    }
+    definition(key) {
+        const identity = pluginIdentity(this.ctx);
+        return this.definitions.get(`${identity.scopeId}\0${identity.extensionId}\0${validKey(key)}`);
+    }
+}
+/** Per-extension durable KV/blob-safe JSON surface with atomic batch mutations. */
+export class PluginStorageService extends PluginNamespacedDataService {
+    constructor(ctx) {
+        super(ctx, 'storage', 'storage');
+    }
+    get(key) {
+        return this.readValue(key);
+    }
+    async set(key, value, options = {}) {
+        const result = await this.mutateValues([{ key, value, ...options }]);
+        return result[key];
+    }
+    async delete(key, options = {}) {
+        const result = await this.mutateValues([{ key, ...options }]);
+        return result[key];
+    }
+    list(prefix) {
+        return this.listValues(prefix);
+    }
+    transaction(mutations) {
+        if (!mutations.length)
+            throw new TypeError('Plugin Storage transaction must not be empty');
+        return this.mutateValues(mutations);
+    }
+    watch(listener) {
+        return this.watchValues(listener);
+    }
+}
+const authorizationCommit = Symbol('authorizationCommit');
+/** Declared Secret Slots. Values stay in Host custody and are never enumerable. */
+export class PluginCredentialService extends Service {
+    dataRuntime;
+    slots = new Map();
+    constructor(ctx) {
+        super(ctx, 'credentials');
+    }
+    bindRuntime(runtime) {
+        if (this.ctx.maka)
+            throw new Error('Only the Host may bind the Credential Runtime');
+        if (this.dataRuntime)
+            throw new Error('Plugin Credential Runtime is already bound');
+        this.dataRuntime = runtime;
+        return this.ctx.effect(() => () => {
+            if (this.dataRuntime === runtime)
+                this.dataRuntime = undefined;
+        }, 'credentials.bindRuntime()');
+    }
+    declare(slot) {
+        validateSlot(slot);
+        const identity = namespace(this.ctx);
+        const id = slotId(identity, slot.name);
+        return registerPluginContribution(this.ctx, `credentials.declare(${JSON.stringify(slot.name)})`, () => {
+            if (this.slots.has(id))
+                throw new Error(`Credential Slot is already declared: ${slot.name}`);
+            this.slots.set(id, { identity, definition: Object.freeze({ ...slot }) });
+            return () => {
+                this.slots.delete(id);
+            };
+        });
+    }
+    has(name) {
+        const slot = this.requireSlot(name);
+        return this.runtime().hasCredential(slot.identity, slot.definition.name);
+    }
+    use(name, operation) {
+        if (typeof operation !== 'function')
+            throw new TypeError('Credential use callback is required');
+        const slot = this.requireSlot(name);
+        return this.runtime().useCredential(slot.identity, slot.definition.name, operation);
+    }
+    remove(name) {
+        const slot = this.requireSlot(name);
+        return this.runtime().removeCredential(slot.identity, slot.definition.name);
+    }
+    async [authorizationCommit](name, secret, metadata) {
+        if (!secret)
+            throw new TypeError('Credential secret must not be empty');
+        const slot = this.requireSlot(name);
+        await this.runtime().commitCredential(slot.identity, slot.definition.name, secret, metadata);
+    }
+    requireSlot(name) {
+        const identity = namespace(this.ctx);
+        const slot = this.slots.get(slotId(identity, validName(name)));
+        if (!slot)
+            throw new Error(`Credential Slot is not declared: ${name}`);
+        return slot;
+    }
+    runtime() {
+        if (!this.dataRuntime)
+            throw new Error('Plugin Credential Runtime is unavailable');
+        return this.dataRuntime;
+    }
+}
+/** Effect-owned authorization flows with one cancellable attempt per Secret Slot. */
+export class PluginAuthorizationService extends Service {
+    flows = new Map();
+    active = new Map();
+    constructor(ctx, _credentials) {
+        super(ctx, 'authorization');
+    }
+    register(flow) {
+        validateFlow(flow);
+        const identity = namespace(this.ctx);
+        const id = slotId(identity, flow.slot);
+        return registerPluginContribution(this.ctx, `authorization.register(${JSON.stringify(flow.slot)})`, () => {
+            if (this.flows.has(id))
+                throw new Error(`Authorization Flow is already registered: ${flow.slot}`);
+            this.flows.set(id, flow);
+            return () => {
+                this.active.get(id)?.abort(new Error('Authorization Flow disposed'));
+                this.active.delete(id);
+                this.flows.delete(id);
+            };
+        });
+    }
+    async begin(slot, method, signal) {
+        const identity = namespace(this.ctx);
+        const id = slotId(identity, validName(slot));
+        const flow = this.flows.get(id);
+        if (!flow)
+            throw new Error(`Authorization Flow is unavailable: ${slot}`);
+        if (this.active.has(id))
+            throw new Error(`Authorization is already in progress: ${slot}`);
+        const selected = method ?? flow.methods[0].id;
+        if (!flow.methods.some(({ id }) => id === selected))
+            throw new Error(`Authorization method is unavailable: ${selected}`);
+        const controller = new AbortController();
+        const onAbort = () => controller.abort(signal?.reason);
+        signal?.addEventListener('abort', onAbort, { once: true });
+        this.active.set(id, controller);
+        let committed = false;
+        try {
+            const outcome = await flow.run({
+                method: selected,
+                signal: controller.signal,
+                commit: async (secret, metadata) => {
+                    await this.ctx.credentials[authorizationCommit](slot, secret, metadata);
+                    committed = true;
+                },
+            });
+            if (outcome === 'authorized' && !committed)
+                throw new Error('Authorization Flow returned authorized without committing a credential');
+            return outcome;
+        }
+        finally {
+            signal?.removeEventListener('abort', onAbort);
+            if (this.active.get(id) === controller)
+                this.active.delete(id);
+        }
+    }
+    cancel(slot) {
+        const identity = namespace(this.ctx);
+        this.active.get(slotId(identity, validName(slot)))?.abort(new Error('Authorization cancelled'));
+    }
+}
+function namespace(ctx) {
+    const { extensionId, scopeId } = pluginIdentity(ctx);
+    return Object.freeze({ extensionId, scopeId });
+}
+function slotId(identity, name) {
+    return `${identity.scopeId}\0${identity.extensionId}\0${name}`;
+}
+function validName(value) {
+    if (!/^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$/u.test(value))
+        throw new TypeError(`Invalid plugin name: ${value}`);
+    return value;
+}
+function validKey(value) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._/-]{0,255}$/u.test(value) || value.includes('..'))
+        throw new TypeError(`Invalid plugin data key: ${value}`);
+    return value;
+}
+function validPrefix(value) {
+    if (value === '')
+        return value;
+    return validKey(value);
+}
+function detached(value) {
+    const json = JSON.stringify(value);
+    if (json === undefined)
+        throw new TypeError('Plugin data must be JSON-serializable');
+    if (Buffer.byteLength(json, 'utf8') > 1024 * 1024)
+        throw new TypeError('Plugin data value exceeds 1 MiB');
+    return JSON.parse(json);
+}
+function validateSettingDefinition(value) {
+    validKey(value.key);
+    if (!value.title.trim())
+        throw new TypeError('Plugin Setting title must not be empty');
+}
+function validateSlot(value) {
+    validName(value.name);
+    if (!value.label.trim())
+        throw new TypeError('Credential Slot label must not be empty');
+}
+function validateFlow(value) {
+    validName(value.slot);
+    if (!value.label.trim() || typeof value.run !== 'function' || value.methods.length === 0)
+        throw new TypeError('Invalid Authorization Flow');
+    const ids = value.methods.map(({ id }) => validName(id));
+    if (new Set(ids).size !== ids.length || value.methods.some(({ label }) => !label.trim()))
+        throw new TypeError('Invalid Authorization methods');
+}

package/node_modules/@maka/runtime/dist/plugin-fs-service.js

@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+/** Full-fidelity filesystem entry point bound to Maka's canonical workspace authority. */
+export class PluginFilesystemService extends Service {
+    agents;
+    filesystemRuntime;
+    constructor(ctx, agents) {
+        super(ctx, 'fs');
+        this.agents = agents;
+    }
+    bindRuntime(runtime) {
+        if (this.ctx.maka)
+            throw new Error('Only the Host may bind the Filesystem Runtime');
+        if (this.filesystemRuntime)
+            throw new Error('Plugin Filesystem Runtime is already bound');
+        this.filesystemRuntime = runtime;
+        return this.ctx.effect(() => () => {
+            if (this.filesystemRuntime === runtime)
+                this.filesystemRuntime = undefined;
+        }, 'fs.bindRuntime()');
+    }
+    execute(operation) {
+        if (!this.filesystemRuntime)
+            throw new Error('Plugin Filesystem Runtime is unavailable');
+        return this.filesystemRuntime.execute(operation, this.agents.requireInvocation());
+    }
+    read(path, options = {}) {
+        return this.execute({ kind: 'read', path, ...options });
+    }
+    write(path, content) {
+        return this.execute({ kind: 'write', path, content });
+    }
+    edit(path, oldString, newString) {
+        return this.execute({ kind: 'edit', path, oldString, newString });
+    }
+    glob(pattern, options = {}) {
+        return this.execute({ kind: 'glob', pattern, ...options });
+    }
+    grep(pattern, options = {}) {
+        return this.execute({ kind: 'grep', pattern, ...options });
+    }
+    applyPatch(patch) {
+        return this.execute({ kind: 'apply_patch', patch });
+    }
+}

package/node_modules/@maka/runtime/dist/plugin-goal-service.js

@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+/** Current-Session Goal facade; mutations retain Maka's Turn lease and revision authority. */
+export class PluginGoalService extends Service {
+    agents;
+    goalRuntime;
+    constructor(ctx, agents) {
+        super(ctx, 'goals');
+        this.agents = agents;
+    }
+    bindRuntime(runtime) {
+        if (this.ctx.maka)
+            throw new Error('Only the Host may bind the Goal Runtime');
+        if (this.goalRuntime)
+            throw new Error('Plugin Goal Runtime is already bound');
+        this.goalRuntime = runtime;
+        return this.ctx.effect(() => () => {
+            if (this.goalRuntime === runtime)
+                this.goalRuntime = undefined;
+        }, 'goals.bindRuntime()');
+    }
+    get() {
+        return this.execute({ kind: 'get' });
+    }
+    create(input) {
+        if (!input.objective.trim())
+            throw new TypeError('Goal objective must not be empty');
+        return this.execute({ ...input, kind: 'create', objective: input.objective.trim() });
+    }
+    clear() {
+        return this.execute({ kind: 'clear' });
+    }
+    pause() {
+        return this.execute({ kind: 'pause' });
+    }
+    resume() {
+        return this.execute({ kind: 'resume' });
+    }
+    execute(operation) {
+        if (!this.goalRuntime)
+            throw new Error('Plugin Goal Runtime is unavailable');
+        return this.goalRuntime.execute(operation, this.agents.requireInvocation());
+    }
+}

package/node_modules/@maka/runtime/dist/plugin-invocation-signal.js

@@ -0,0 +1,24 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/** Preserve Host cancellation when a plugin adds its own cancellation source. */
+export function pluginInvocationSignal(invocationSignal, pluginSignal) {
+    if (!pluginSignal || pluginSignal === invocationSignal)
+        return invocationSignal;
+    return AbortSignal.any([invocationSignal, pluginSignal]);
+}

package/node_modules/@maka/runtime/dist/plugin-llm-service.js

@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+import { pluginInvocationSignal } from './plugin-invocation-signal.js';
+import { MakaPluginRuntimeError, pluginIdentity, registerPluginContribution, } from './plugin-runtime.js';
+import { PluginScopeRegistry } from './plugin-scope-registry.js';
+/** Metered Host model calls plus an ordered plugin adapter seam. */
+export class PluginLlmService extends Service {
+    agents;
+    llmRuntime;
+    adapters = new PluginScopeRegistry();
+    constructor(ctx, agents) {
+        super(ctx, 'llm');
+        this.agents = agents;
+    }
+    bindRuntime(runtime) {
+        if (this.ctx.maka)
+            throw new Error('Only the Host may bind the LLM Runtime');
+        if (this.llmRuntime)
+            throw new Error('Plugin LLM Runtime is already bound');
+        this.llmRuntime = runtime;
+        return this.ctx.effect(() => () => {
+            if (this.llmRuntime === runtime)
+                this.llmRuntime = undefined;
+        }, 'llm.bindRuntime()');
+    }
+    register(adapter) {
+        if (!adapter || !/^[A-Za-z][A-Za-z0-9._:-]{0,127}$/u.test(adapter.id)) {
+            throw new TypeError('LLM adapter id is invalid');
+        }
+        if (typeof adapter.supports !== 'function' || typeof adapter.generate !== 'function') {
+            throw new TypeError(`LLM adapter implementation is invalid: ${adapter.id}`);
+        }
+        const identity = pluginIdentity(this.ctx);
+        return registerPluginContribution(this.ctx, `llm.adapter:${adapter.id}`, () => {
+            const rootId = identity.scopeId;
+            const existing = this.adapters.get(rootId, adapter.id);
+            if (existing && existing.entryId !== identity.entryId) {
+                throw new MakaPluginRuntimeError('activation_failed', `LLM adapter is already registered in this scope: ${adapter.id}`);
+            }
+            const entry = {
+                ...identity,
+                adapter,
+                token: Symbol(adapter.id),
+                retired: false,
+            };
+            return this.adapters.publish(rootId, adapter.id, entry);
+        });
+    }
+    generate(input) {
+        const invocation = this.agents.requireInvocation();
+        const effectiveInput = Object.freeze({
+            ...input,
+            signal: pluginInvocationSignal(invocation.abortSignal, input.signal),
+        });
+        const visibleAdapters = this.adapters.visible(invocation.sessionId);
+        const adapter = input.model
+            ? [...visibleAdapters.values()]
+                .map((entry) => entry.adapter)
+                .filter((candidate) => candidate.supports(input.model))
+                .sort((left, right) => (right.priority ?? 0) - (left.priority ?? 0))[0]
+            : undefined;
+        if (adapter)
+            return adapter.generate(effectiveInput, invocation);
+        if (!this.llmRuntime)
+            throw new Error('Plugin LLM Runtime is unavailable');
+        return this.llmRuntime.generate(effectiveInput, invocation);
+    }
+}

package/node_modules/@maka/runtime/dist/plugin-lsp-service.js

@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+import { PluginScopeRegistry } from './plugin-scope-registry.js';
+import { pluginIdentity, registerPluginContribution, MakaPluginRuntimeError, } from './plugin-runtime.js';
+/** High-level LSP router; providers own processes, callers receive no JSON-RPC escape hatch. */
+export class PluginLspService extends Service {
+    routes = new PluginScopeRegistry();
+    constructor(ctx) {
+        super(ctx, 'lsp');
+    }
+    registerProvider(provider) {
+        validateProvider(provider);
+        const identity = pluginIdentity(this.ctx);
+        if (identity.scopeId === 'desktop-ui')
+            throw new MakaPluginRuntimeError('activation_failed', 'desktop-ui plugins cannot register Host LSP providers');
+        return registerPluginContribution(this.ctx, `lsp.registerProvider(${JSON.stringify(provider.id)})`, () => {
+            const rootId = identity.scopeId;
+            const pending = Object.entries(provider.extensionToLanguage).map(([extension, languageId]) => [normalizeExtension(extension), languageId]);
+            for (const [extension] of pending) {
+                const existing = this.routes.get(rootId, extension);
+                if (existing && existing.entryId !== identity.entryId)
+                    throw new MakaPluginRuntimeError('activation_failed', `LSP extension ${JSON.stringify(extension)} is already registered by ${existing.entryId}`);
+            }
+            const disposers = pending.map(([extension, languageId]) => this.routes.publish(rootId, extension, {
+                ...identity,
+                provider,
+                languageId,
+                token: Symbol(`${provider.id}:${extension}`),
+                retired: false,
+            }));
+            return async () => {
+                await Promise.all(disposers.reverse().map((dispose) => dispose()));
+            };
+        });
+    }
+    async query(request, signal) {
+        validateRequest(request);
+        const route = this.routes.visible(request.sessionId).get(finalExtension(request.filePath));
+        if (!route)
+            throw new Error(`No LSP provider handles ${JSON.stringify(request.filePath)}`);
+        if (signal?.aborted)
+            throw signal.reason ?? new Error('LSP query aborted');
+        return await route.provider.query(Object.freeze({ ...request, languageId: route.languageId }), signal);
+    }
+}
+export function finalExtension(filePath) {
+    const base = filePath.slice(Math.max(filePath.lastIndexOf('/'), filePath.lastIndexOf('\\')) + 1);
+    const dot = base.lastIndexOf('.');
+    return dot <= 0 ? '' : base.slice(dot).toLowerCase();
+}
+function normalizeExtension(value) {
+    const extension = value.toLowerCase();
+    const result = extension.startsWith('.') ? extension : `.${extension}`;
+    if (!/^\.[^./\\]+$/u.test(result))
+        throw new TypeError(`Invalid LSP extension: ${value}`);
+    return result;
+}
+function validateProvider(provider) {
+    if (!provider.id.trim() ||
+        typeof provider.query !== 'function' ||
+        Object.keys(provider.extensionToLanguage).length === 0)
+        throw new TypeError('Invalid LSP provider');
+    for (const [extension, language] of Object.entries(provider.extensionToLanguage)) {
+        normalizeExtension(extension);
+        if (!language.trim())
+            throw new TypeError('LSP language id must not be empty');
+    }
+}
+function validateRequest(request) {
+    if (!request.sessionId ||
+        !request.filePath ||
+        !Number.isSafeInteger(request.position.line) ||
+        request.position.line < 0 ||
+        !Number.isSafeInteger(request.position.character) ||
+        request.position.character < 0)
+        throw new TypeError('Invalid LSP query');
+}