dsh-plugin-subscription-oauth 0.0.0-stage → 0.2.0

package/lib/providers/common.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Shared provider plumbing: an idle watchdog for streams, wire-error
+ * classification, and transport-failure mapping.
+ *
+ * @module dsh-plugin-subscription-oauth/providers/common
+ */
+import { LlmError } from '@deepseek-ai/dsh-llm';
+/** Watchdog handle used around one streaming request. */
+export interface IdleWatchdog {
+    /** Abort signal to hand to `fetch`; also fires when the caller's signal does. */
+    readonly signal: AbortSignal;
+    /** Report inbound transport activity, resetting the idle timer. */
+    pulse(): void;
+    /** Stop the timer; safe to call more than once. */
+    stop(): void;
+    /** Whether the idle budget (rather than the caller) aborted the request. */
+    readonly timedOut: boolean;
+}
+/**
+ * Guard one stream with an inactivity budget.
+ *
+ * The timer aborts the request when no chunk arrives for `idleMs`, so a dead
+ * connection fails the turn instead of hanging it forever.
+ *
+ * @param signal - the caller's cancellation signal, if any.
+ * @param idleMs - inactivity budget in milliseconds; a non-positive value disables it.
+ * @returns the watchdog.
+ */
+export declare function idleWatchdog(signal: AbortSignal | undefined, idleMs: number): IdleWatchdog;
+/**
+ * Turn a non-2xx provider response into an LlmError carrying the status and
+ * any rate-limit hint the headers disclosed.
+ *
+ * @param response - the failed response.
+ * @param label - human name of the endpoint, used in the message.
+ * @returns the error to throw.
+ */
+export declare function httpLlmError(response: Response, label: string): Promise<LlmError>;
+/** Whether a failure means the stored credential no longer works. */
+export declare function isMissingOrInvalidCredential(error: unknown): boolean;
+/**
+ * Map a thrown transport failure onto a harness error, distinguishing caller
+ * cancellation from an idle timeout from a genuine network fault.
+ *
+ * @param label - human name of the endpoint.
+ * @param error - the thrown value.
+ * @param watchdog - the request's watchdog, when one was installed.
+ * @param signal - the caller's signal.
+ * @returns the error to throw.
+ */
+export declare function mapFetchFailure(label: string, error: unknown, watchdog?: Pick<IdleWatchdog, 'timedOut'>, signal?: AbortSignal): unknown;

package/lib/providers/common.js

@@ -0,0 +1,169 @@
+/**
+ * Shared provider plumbing: an idle watchdog for streams, wire-error
+ * classification, and transport-failure mapping.
+ *
+ * @module dsh-plugin-subscription-oauth/providers/common
+ */
+import { errorChain, LlmError } from '@deepseek-ai/dsh-llm';
+/**
+ * Guard one stream with an inactivity budget.
+ *
+ * The timer aborts the request when no chunk arrives for `idleMs`, so a dead
+ * connection fails the turn instead of hanging it forever.
+ *
+ * @param signal - the caller's cancellation signal, if any.
+ * @param idleMs - inactivity budget in milliseconds; a non-positive value disables it.
+ * @returns the watchdog.
+ */
+export function idleWatchdog(signal, idleMs) {
+    const controller = new AbortController();
+    let timedOut = false;
+    let timer;
+    const onCallerAbort = () => controller.abort(signal?.reason);
+    if (signal !== undefined) {
+        if (signal.aborted)
+            controller.abort(signal.reason);
+        else
+            signal.addEventListener('abort', onCallerAbort, { once: true });
+    }
+    const arm = () => {
+        if (idleMs <= 0)
+            return;
+        timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort(new Error(`Kimi stream idle for more than ${idleMs}ms`));
+        }, idleMs);
+        timer.unref?.();
+    };
+    const clear = () => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        timer = undefined;
+    };
+    const stop = () => {
+        clear();
+        signal?.removeEventListener('abort', onCallerAbort);
+    };
+    arm();
+    return {
+        signal: controller.signal,
+        pulse: () => {
+            clear();
+            arm();
+        },
+        stop,
+        get timedOut() {
+            return timedOut;
+        },
+    };
+}
+/** Read a `retry-after` header as an absolute delay in milliseconds. */
+function retryAfterMs(response) {
+    const raw = response.headers.get('retry-after');
+    if (raw === null)
+        return undefined;
+    const seconds = Number(raw);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return Math.round(seconds * 1000);
+    const at = Date.parse(raw);
+    if (!Number.isNaN(at))
+        return Math.max(0, at - Date.now());
+    return undefined;
+}
+/** Provider-neutral failure code for one HTTP status. */
+function statusCode(status) {
+    if (status === 401 || status === 403)
+        return 'INVALID_CREDENTIAL';
+    if (status === 404)
+        return 'MODEL_NOT_FOUND';
+    if (status === 429)
+        return 'RATE_LIMIT';
+    if (status === 400 || status === 422)
+        return 'INVALID_REQUEST';
+    if (status >= 500)
+        return 'SERVER';
+    return 'HTTP_ERROR';
+}
+/** Best-effort provider message out of an error response body. */
+async function errorBodyMessage(response) {
+    try {
+        const text = await response.text();
+        if (text.trim() === '')
+            return undefined;
+        try {
+            const parsed = JSON.parse(text);
+            if (typeof parsed === 'object' && parsed !== null) {
+                const record = parsed;
+                const error = record.error;
+                if (typeof error === 'object' && error !== null) {
+                    const message = error.message;
+                    if (typeof message === 'string' && message.trim() !== '')
+                        return message.trim();
+                }
+                if (typeof record.message === 'string' && record.message.trim() !== '')
+                    return record.message.trim();
+                if (typeof error === 'string' && error.trim() !== '')
+                    return error.trim();
+            }
+        }
+        catch {
+            // Not JSON: fall through to the raw body.
+        }
+        return text.slice(0, 400).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Turn a non-2xx provider response into an LlmError carrying the status and
+ * any rate-limit hint the headers disclosed.
+ *
+ * @param response - the failed response.
+ * @param label - human name of the endpoint, used in the message.
+ * @returns the error to throw.
+ */
+export async function httpLlmError(response, label) {
+    const detail = await errorBodyMessage(response);
+    const retryAfter = retryAfterMs(response);
+    const message = detail === undefined
+        ? `${label} request failed (HTTP ${response.status} ${response.statusText})`.trim()
+        : `${label} request failed (HTTP ${response.status}): ${detail}`;
+    return new LlmError(message, statusCode(response.status), {
+        status: response.status,
+        ...retryAfter === undefined ? {} : { providerRetryAfterMs: retryAfter },
+    });
+}
+/** Whether a failure means the stored credential no longer works. */
+export function isMissingOrInvalidCredential(error) {
+    if (error instanceof LlmError) {
+        return error.failure.code === 'INVALID_CREDENTIAL' || error.failure.status === 401 || error.failure.status === 403;
+    }
+    return false;
+}
+/**
+ * Map a thrown transport failure onto a harness error, distinguishing caller
+ * cancellation from an idle timeout from a genuine network fault.
+ *
+ * @param label - human name of the endpoint.
+ * @param error - the thrown value.
+ * @param watchdog - the request's watchdog, when one was installed.
+ * @param signal - the caller's signal.
+ * @returns the error to throw.
+ */
+export function mapFetchFailure(label, error, watchdog, signal) {
+    if (error instanceof LlmError)
+        return error;
+    if (signal?.aborted === true)
+        return error;
+    if (watchdog?.timedOut === true) {
+        return new LlmError(`${label} stream timed out waiting for data`, 'TIMEOUT');
+    }
+    const cause = error instanceof Error ? error.cause : undefined;
+    if (cause !== undefined && cause !== error) {
+        return new LlmError(`${label} request failed: ${errorChain(error)}`, 'NETWORK', { cause: error });
+    }
+    return error instanceof Error
+        ? new LlmError(`${label} request failed: ${error.message}`, 'NETWORK', { cause: error })
+        : new LlmError(`${label} request failed: ${String(error)}`, 'NETWORK');
+}

package/lib/providers/glm-provider.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The `glm` provider route's wiring: credential store, ZCode OAuth login, model
+ * catalog, and its Settings card facts.
+ *
+ * @module dsh-plugin-subscription-oauth/providers/glm-provider
+ */
+import type { ProviderRoute } from '../auth/registry.js';
+import type { ModelPreferences } from '../settings.js';
+import type { FetchFn } from '../http.js';
+import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+/** Everything the GLM route needs from the plugin configuration. */
+export interface GlmProviderOptions {
+    /** Absolute path of `auth.json`. */
+    credentialFile: string;
+    /** Request base; `<base>/responses` is the endpoint. */
+    apiBase?: string;
+    /** Consult the endpoint's live model list. */
+    discovery: boolean;
+    /** Abandon a stream after this much silence. */
+    streamIdleTimeoutMs: number;
+    /** Model the picker preselects. */
+    defaultModel?: string;
+    /** Extra model ids published without shipped metadata. */
+    extraModels?: readonly string[];
+    /** Shared model-visibility preferences. */
+    preferences: ModelPreferences;
+    /** Resolve the attachment service per request. */
+    resolveAttachments?: () => AttachmentStore | undefined;
+    /** Invoked when the catalog or its visibility changed. */
+    onCatalogChanged?: () => void;
+    onWarn?: (message: string) => void;
+    /** Fetch implementation; defaults to the proxy-aware fetch. */
+    fetchFn?: FetchFn;
+}
+/**
+ * Build the `glm` route: its adapter and its login/lifecycle controller.
+ *
+ * @param options - resolved endpoints, paths, and shared services.
+ * @returns the route, ready to register and to serve over RPC.
+ */
+export declare function createGlmProvider(options: GlmProviderOptions): ProviderRoute;

package/lib/providers/glm-provider.js

@@ -0,0 +1,165 @@
+/**
+ * The `glm` provider route's wiring: credential store, ZCode OAuth login, model
+ * catalog, and its Settings card facts.
+ *
+ * @module dsh-plugin-subscription-oauth/providers/glm-provider
+ */
+import { REAUTH_REQUIRED, ProviderError } from '../errors.js';
+import { TokenStore } from '../auth/store.js';
+import { TokenManager } from '../auth/tokens.js';
+import { LOGIN_CANCELLED_MESSAGE } from '../auth/device-flow.js';
+import { startGlmFlow, pollGlmFlow } from '../auth/glm-flow.js';
+import { GlmAdapter, GLM_API_BASE, GLM_CODE_URL, GLM_CONTEXT_WINDOW, GLM_DEFAULT_MODEL, GLM_ORIGIN, GLM_PROVIDER_ID, GLM_PROVIDER_NAME, parseGlmSession, readGlmUsage } from './glm.js';
+import { ProviderController } from '../auth/provider-controller.js';
+import { proxiedFetch } from '../http.js';
+/** Wait, honouring cancellation. */
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(new Error(LOGIN_CANCELLED_MESSAGE));
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        function onAbort() {
+            clearTimeout(timer);
+            reject(new Error(LOGIN_CANCELLED_MESSAGE));
+        }
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
+/**
+ * Build the `glm` route: its adapter and its login/lifecycle controller.
+ *
+ * @param options - resolved endpoints, paths, and shared services.
+ * @returns the route, ready to register and to serve over RPC.
+ */
+export function createGlmProvider(options) {
+    const fetchFn = options.fetchFn ?? proxiedFetch;
+    const apiBase = options.apiBase ?? GLM_API_BASE;
+    const store = new TokenStore(options.credentialFile, GLM_PROVIDER_ID, parseGlmSession);
+    const toSession = (tokens) => ({
+        accessToken: tokens.accessToken,
+        zcodeJwt: tokens.zcodeJwt,
+        expiresAt: tokens.expiresAt,
+        ...tokens.refreshToken === undefined ? {} : { refreshToken: tokens.refreshToken },
+        apiBase,
+        ...tokens.accountId === undefined ? {} : { accountId: tokens.accountId },
+        ...tokens.label === undefined ? {} : { email: tokens.label },
+    });
+    /** The in-flight attempt, so `pending()` is stable across calls. */
+    let current;
+    const flow = {
+        async start() {
+            const start = await startGlmFlow({ fetchFn });
+            const controller = new AbortController();
+            const session = (async () => {
+                // The browser sign-in completes on the broker's own callback, so this side
+                // only has to keep asking until the flow is ready or lapses.
+                while (true) {
+                    if (controller.signal.aborted)
+                        throw new Error(LOGIN_CANCELLED_MESSAGE);
+                    const tokens = await pollGlmFlow({ fetchFn }, start, controller.signal);
+                    if (tokens !== undefined)
+                        return toSession(tokens);
+                    await sleep(start.pollIntervalMs, controller.signal);
+                }
+            })();
+            const attempt = {
+                prompt: {
+                    url: start.authorizeUrl,
+                    expiresAt: start.expiresAt,
+                    mode: 'open-url',
+                },
+                session,
+                cancel: () => { controller.abort(); },
+            };
+            current = attempt;
+            // Drop the record once the attempt settles, so `pending()` cannot report a
+            // login that already finished or failed.
+            void session.catch(() => undefined).finally(() => {
+                if (current === attempt)
+                    current = undefined;
+            });
+            return attempt;
+        },
+        pending() {
+            return current;
+        },
+    };
+    const tokens = new TokenManager({
+        store,
+        displayName: GLM_PROVIDER_NAME,
+        // The ZCode flow has no refresh grant, so there is nothing to pre-empt: asking
+        // five minutes early would refuse a token that is still perfectly usable and
+        // send the user to sign in again for no reason. Renewal happens when the token
+        // has actually lapsed, which is also what the official client does.
+        preemptMs: 0,
+        refresh: () => {
+            throw new ProviderError(`${GLM_PROVIDER_NAME} sign-in has expired; connect the account again`, REAUTH_REQUIRED);
+        },
+    });
+    const adapter = new GlmAdapter({
+        apiBase,
+        discovery: options.discovery,
+        streamIdleTimeoutMs: options.streamIdleTimeoutMs,
+        tokens,
+        ...options.onWarn === undefined ? {} : { onWarn: options.onWarn },
+        ...options.resolveAttachments === undefined ? {} : { resolveAttachments: options.resolveAttachments },
+        hiddenModels: () => options.preferences.hiddenIds(GLM_PROVIDER_ID),
+        userModels: () => options.preferences.extraIds(GLM_PROVIDER_ID),
+        ...options.extraModels === undefined ? {} : { extraModels: options.extraModels },
+        fetchFn,
+    });
+    const spec = {
+        id: GLM_PROVIDER_ID,
+        displayName: GLM_PROVIDER_NAME,
+        codeUrl: GLM_CODE_URL,
+        credentialFile: options.credentialFile,
+        discovery: options.discovery,
+        defaultModel: options.defaultModel ?? GLM_DEFAULT_MODEL,
+        catalog: () => adapter.catalogEntries(),
+        catalogOwn: () => adapter.ownCatalogEntries(),
+        fallbackContextWindow: GLM_CONTEXT_WINDOW,
+        discover: (accessToken) => adapter.fetchCatalog(accessToken),
+        usage: (accessToken) => readGlmUsage({ origin: GLM_ORIGIN, accessToken, fetchFn }),
+        details: () => [
+            { key: 'apiBase', value: apiBase },
+            { key: 'oauthBroker', value: 'https://zcode.z.ai' },
+            { key: 'credentialFile', value: options.credentialFile },
+        ],
+        applyDiscovery: (ids) => { adapter.discover(ids); },
+    };
+    const controller = new ProviderController({
+        spec,
+        store,
+        tokens,
+        flow,
+        preferences: options.preferences,
+        ...options.onCatalogChanged === undefined ? {} : { onCatalogChanged: options.onCatalogChanged },
+        ...options.onWarn === undefined ? {} : { onWarn: options.onWarn },
+    });
+    // An explicit façade, not a spread: a spread would copy own properties and drop
+    // the class prototype, leaving every method undefined.
+    return {
+        id: controller.id,
+        displayName: controller.displayName,
+        credentialFile: controller.credentialFile,
+        adapter,
+        status: () => controller.status(),
+        login: (account) => controller.login(account),
+        cancel: () => controller.cancel(),
+        logout: (account) => controller.logout(account),
+        setDefault: (account) => controller.setDefault(account),
+        refresh: (account) => controller.refresh(account),
+        discover: (force) => controller.discover(force),
+        setModelVisible: (id, visible) => controller.setModelVisible(id, visible),
+        setModelOrder: (ids) => controller.setModelOrder(ids),
+        addModel: (id) => controller.addModel(id),
+        removeModel: (id) => controller.removeModel(id),
+        usage: (force) => controller.usage(force),
+        reload: () => controller.reload(),
+    };
+}

package/lib/providers/glm.d.ts

@@ -0,0 +1,159 @@
+/**
+ * The `glm` route: BigModel's coding plan over the OpenAI Responses wire.
+ *
+ * Sign-in is ZCode's own OAuth flow (see `auth/glm-flow.ts`). What the flow hands
+ * back is a BigModel access token and the ZCode JWT the subscription is bound to;
+ * requests and the model list then go to the coding-plan host, whose
+ * `/responses` route answers the same wire the `kimi` and `grok` routes use.
+ *
+ * @module dsh-plugin-subscription-oauth/providers/glm
+ */
+import { LlmAdapter } from '@deepseek-ai/dsh-llm';
+import type { GenerateOptions, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { SessionBase } from '../auth/store.js';
+import type { TokenManager } from '../auth/tokens.js';
+import type { FetchFn } from '../http.js';
+import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+import type { UsageWindow } from '../protocol.js';
+import type { CatalogEntry } from './catalog.js';
+import type { UsageRead } from './usage.js';
+/** Provider route this module serves. */
+export declare const GLM_PROVIDER_ID = "glm";
+/** Display name for the picker group and the Settings card. */
+export declare const GLM_PROVIDER_NAME = "GLM (BigModel)";
+/** Page a user opens to manage the coding plan. */
+export declare const GLM_CODE_URL = "https://bigmodel.cn/coding-plan/personal/overview";
+/** Coding-plan host; the Responses endpoint is `<base>/responses`. */
+export declare const GLM_API_BASE = "https://open.bigmodel.cn/api/coding/paas/v4";
+/** Origin the account-level endpoints hang off, without the coding path. */
+export declare const GLM_ORIGIN = "https://open.bigmodel.cn";
+/** Path appended to the API base for a streaming request. */
+export declare const GLM_RESPONSES_PATH = "/responses";
+/** Path appended to the API base to list the models an account can reach. */
+export declare const GLM_MODELS_PATH = "/models";
+/**
+ * Account allowance endpoint.
+ *
+ * It sits on the host root rather than under the coding prefix, and BigModel
+ * authenticates it with the bare key — no `Bearer` scheme, which the host refuses.
+ */
+export declare const GLM_QUOTA_PATH = "/api/monitor/usage/quota/limit";
+/** Model the picker preselects. */
+export declare const GLM_DEFAULT_MODEL = "glm-5.3";
+/** Context capacity of the GLM 5.x family. */
+export declare const GLM_CONTEXT_WINDOW = 1048576;
+/** Output budget used when the caller sets no cap. */
+export declare const GLM_DEFAULT_MAX_TOKENS = 131072;
+/**
+ * The catalog this build ships, so a signed-in route is usable with no discovery.
+ *
+ * Ids are the wire ids, lowercase: the coding plan answers `glm-5.3`, not the
+ * `GLM-5.3` display name its own client shows. `glm-5.3-flash` is the multimodal
+ * member of the family; the rest read text only.
+ */
+export declare const GLM_MODELS: readonly CatalogEntry[];
+/** One signed-in BigModel account. */
+export interface GlmSession extends SessionBase {
+    /** ZCode JWT the coding plan is bound to; presented as the API key. */
+    zcodeJwt: string;
+    /** API base recorded at login time (diagnostics only). */
+    apiBase?: string;
+}
+/**
+ * Coerce one decoded credential entry into a GLM session.
+ *
+ * @param value - decoded JSON value for one account.
+ * @returns the session, or undefined when required fields are missing.
+ */
+export declare function parseGlmSession(value: unknown): GlmSession | undefined;
+/** Everything the adapter needs from the route. */
+export interface GlmAdapterOptions {
+    /** Request base; `<base>/responses` is the endpoint. */
+    apiBase: string;
+    /** Consult the endpoint's live model list. */
+    discovery: boolean;
+    /** Abandon a stream after this much silence. */
+    streamIdleTimeoutMs: number;
+    /** Token manager owning refresh. */
+    tokens: TokenManager<GlmSession>;
+    /** Model ids the user hid from the picker. */
+    hiddenModels?: () => Promise<ReadonlySet<string>> | ReadonlySet<string>;
+    /** Ids the user added by hand. */
+    userModels?: () => Promise<readonly string[]> | readonly string[];
+    /** Extra ids published without shipped metadata. */
+    extraModels?: readonly string[];
+    /** Resolve the attachment service per request. */
+    resolveAttachments?: () => AttachmentStore | undefined;
+    onWarn?: (message: string) => void;
+    onCredentialRejected?: (account: string) => void;
+    /** Fetch implementation; defaults to the proxy-aware fetch. */
+    fetchFn?: FetchFn;
+}
+/**
+ * Read the two windows a coding-plan allowance reports.
+ *
+ * The host lists one row per metered window and names it by a `unit`/`number`
+ * pair: `(3, 5)` is the rolling five-hour window and `(6, 1)` the weekly one.
+ * Rows of any other type — MCP tool usage, for instance — are not model quota and
+ * are skipped rather than shown as an allowance.
+ *
+ * @param payload - the decoded `quota/limit` body.
+ * @returns one window per metered allowance, rolling first.
+ */
+export declare function parseGlmQuota(payload: unknown): UsageWindow[];
+/**
+ * Read an account's coding-plan allowance.
+ *
+ * @param input - host, bearer, and fetch.
+ * @returns the windows the host reported; an empty list when it stated none.
+ */
+export declare function readGlmUsage(input: {
+    origin: string;
+    accessToken: string;
+    fetchFn: FetchFn;
+    signal?: AbortSignal;
+}): Promise<UsageRead>;
+/** The adapter behind the `glm` route. */
+export declare class GlmAdapter extends LlmAdapter {
+    private readonly options;
+    /** Live catalog ids, once discovery succeeded this session. */
+    private live;
+    constructor(options: GlmAdapterOptions);
+    providerInfo(provider: string): LlmProviderInfo;
+    providerRetryPolicy(): undefined;
+    listModels(_provider: string): Promise<readonly LlmModelInfo[]>;
+    resolveModel(_provider: string, model: string): Promise<LlmResolvedModelInfo>;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    /** Translate an auth failure into the message a user can act on. */
+    private refreshHint;
+    /** The catalog served: the shipped list, the live one, then hand-added ids. */
+    private catalog;
+    /** The route's own catalog, without ids the user added by hand. */
+    private shippedCatalog;
+    /** Ids the user published by hand that this route does not already serve. */
+    private addedEntries;
+    /** The ids the picker must currently omit. */
+    private hidden;
+    /**
+     * Adopt the endpoint's live catalog.
+     *
+     * @param ids - model ids the endpoint reported.
+     */
+    discover(ids: readonly string[]): void;
+    /**
+     * Read the live model list.
+     *
+     * @param accessToken - bearer for the account.
+     * @param signal - optional cancellation.
+     * @returns the ids the endpoint serves, or undefined when it cannot be read.
+     */
+    fetchCatalog(accessToken: string, signal?: AbortSignal): Promise<readonly string[] | undefined>;
+    /** Send one streaming request over the Responses wire. */
+    private request;
+    /** Resolve image blocks through the attachment service, when it is present. */
+    private imageResolver;
+    /** The catalog the controller publishes without hand-added ids. */
+    ownCatalogEntries(): readonly CatalogEntry[];
+    /** The catalog the controller publishes. */
+    catalogEntries(): readonly CatalogEntry[];
+}