export function createGatewayMethodRegistry(

inputs: readonly GatewayMethodDescriptorInput[],

): GatewayMethodRegistry {

const descriptors = inputs

.map(normalizeDescriptor)

.toSorted((left, right) => left.name.localeCompare(right.name));

const descriptors = inputs.map(normalizeDescriptor);

const byName = new Map<string, GatewayMethodDescriptor>();

for (const descriptor of descriptors) {

if (byName.has(descriptor.name)) {

expect(methods).not.toContain("sessions.usage");

});

it("preserves the legacy advertised method order", () => {

const methods = listGatewayMethods();

expect(methods.slice(0, 5)).toEqual([

"health",

"diagnostics.stability",

"doctor.memory.status",

"doctor.memory.dreamDiary",

"doctor.memory.backfillDreamDiary",

]);

expect(methods.slice(32, 37)).toEqual([

"exec.approvals.get",

"exec.approvals.set",

"exec.approvals.node.get",

"exec.approvals.node.set",

"exec.approval.get",

]);

});

it("advertises the versioned Talk session RPCs", () => {

const methods = listGatewayMethods();

expect(methods).toContain("talk.client.create");

import { listLoadedChannelPlugins } from "../channels/plugins/registry-loaded.js";

import { GATEWAY_EVENT_UPDATE_AVAILABLE } from "./events.js";

import { CORE_ADVERTISED_GATEWAY_METHODS } from "./methods/legacy-metadata.js";

import {

createCoreGatewayMethodDescriptors,

createGatewayMethodRegistry,

};

export function listCoreGatewayMethods(): string[] {

return createGatewayMethodRegistry(

const registry = createGatewayMethodRegistry(

createCoreGatewayMethodDescriptors(coreGatewayHandlers),

).listAdvertisedMethods();

);

return [...CORE_ADVERTISED_GATEWAY_METHODS].filter((method) => registry.getHandler(method));

}

function listChannelGatewayMethods(): string[] {

}

export function listGatewayMethods(): string[] {

const advertisedBaseMethods = new Set([...listCoreGatewayMethods(), ...GATEWAY_AUX_METHODS]);

const baseMethods = [...CORE_ADVERTISED_GATEWAY_METHODS].filter((method) =>

advertisedBaseMethods.has(method),

);

return Array.from(

new Set([...listCoreGatewayMethods(), ...GATEWAY_AUX_METHODS, ...listChannelGatewayMethods()]),

new Set([...baseMethods, ...GATEWAY_AUX_METHODS, ...listChannelGatewayMethods()]),

);

}

import { createAuthRateLimiter, type AuthRateLimiter } from "./auth-rate-limit.js";

import { resolveGatewayAuth } from "./auth.js";

import { ADMIN_SCOPE } from "./method-scopes.js";

import { CORE_ADVERTISED_GATEWAY_METHODS } from "./methods/legacy-metadata.js";

import {

createCoreGatewayMethodDescriptors,

createGatewayMethodDescriptorsFromHandlers,

}),

]);

let attachedGatewayMethodRegistry = buildAttachedGatewayMethodRegistry(pluginRegistry);

const listAttachedGatewayMethods = () =>

Array.from(

new Set([

...attachedGatewayMethodRegistry.listAdvertisedMethods(),

...listStartupChannelGatewayMethods(),

]),

const listAttachedGatewayMethods = () => {

const advertisedMethods = attachedGatewayMethodRegistry.listAdvertisedMethods();

const advertisedSet = new Set(advertisedMethods);

const methods = [...CORE_ADVERTISED_GATEWAY_METHODS].filter((method) =>

advertisedSet.has(method),

);

for (const method of advertisedMethods) {

if (!CORE_ADVERTISED_GATEWAY_METHODS.has(method)) {

methods.push(method);

}

}

methods.push(...listStartupChannelGatewayMethods());

return Array.from(new Set(methods));

};

runtimeState.gatewayMethods.splice(

0,

runtimeState.gatewayMethods.length,