@pikku/inspector 0.12.109 → 0.12.111

package/dist/utils/remote-addon-sdk.d.ts

@@ -0,0 +1,57 @@
+/** Committed beside pikku.config.json: the SDK version and integrity each versioned `wireRemoteAddon` resolved to. */
+export declare const ADDONS_LOCK_FILE = "pikku-addons.lock";
+/** Where `pikku all` extracts SDKs, relative to the project root. Gitignored with the rest of `.pikku`. */
+export declare const REMOTE_SDK_DIR: string;
+/** Written into an extracted SDK: the integrity of the tarball it came from. */
+export declare const SDK_INTEGRITY_MARKER = ".integrity";
+export type AddonsLockEntry = {
+    /** The range the spec asked for when this entry was written. */
+    range: string;
+    version: string;
+    /** `sha512-<base64>` of the SDK tarball. */
+    integrity: string;
+};
+export type AddonsLock = {
+    lockfileVersion: 1;
+    sdks: Record<string, AddonsLockEntry>;
+};
+/** `manifest.json` at the root of an SDK. */
+export type RemoteAddonSdkManifest = {
+    name: string;
+    version: string;
+    /** The @pikku/core range the SDK's types were generated against. */
+    pikkuCore?: string;
+    contractHash?: string;
+};
+export type RemoteAddonPackageSpec = {
+    name: string;
+    range?: string;
+};
+/**
+ * `@scope/name@^1.4.0` → name and range, split at the last `@` after the first
+ * character. Mirrors `parseRemoteAddonPackage` in @pikku/core, which the
+ * runtime uses on the same literal.
+ */
+export declare const parseRemoteAddonPackage: (spec: string) => RemoteAddonPackageSpec;
+export declare const emptyAddonsLock: () => AddonsLock;
+/** The project's lock, an empty one when there is none. Throws when the file is not a lock. */
+export declare const readAddonsLock: (rootDir: string) => AddonsLock;
+/** Sorted by package name, each entry's keys in a fixed order, so the same lock always writes the same bytes. */
+export declare const serializeAddonsLock: (lock: AddonsLock) => string;
+export declare const remoteSdkDir: (rootDir: string, name: string, version: string) => string;
+export declare const readSdkManifest: (dir: string) => RemoteAddonSdkManifest | null;
+export type LockedSdk = {
+    ok: true;
+    entry: AddonsLockEntry;
+    dir: string;
+    manifest: RemoteAddonSdkManifest;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Whether the SDK for `name@range` is on disk exactly as the lock pins it: the
+ * lock was written for this range, the extracted directory carries the lock's
+ * integrity, and its manifest names this package and version.
+ */
+export declare const checkLockedSdk: (rootDir: string, name: string, range: string, lock?: AddonsLock) => LockedSdk;

package/dist/utils/remote-addon-sdk.js

@@ -0,0 +1,111 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+/** Committed beside pikku.config.json: the SDK version and integrity each versioned `wireRemoteAddon` resolved to. */
+export const ADDONS_LOCK_FILE = 'pikku-addons.lock';
+/** Where `pikku all` extracts SDKs, relative to the project root. Gitignored with the rest of `.pikku`. */
+export const REMOTE_SDK_DIR = join('.pikku', 'remote');
+/** Written into an extracted SDK: the integrity of the tarball it came from. */
+export const SDK_INTEGRITY_MARKER = '.integrity';
+/**
+ * `@scope/name@^1.4.0` → name and range, split at the last `@` after the first
+ * character. Mirrors `parseRemoteAddonPackage` in @pikku/core, which the
+ * runtime uses on the same literal.
+ */
+export const parseRemoteAddonPackage = (spec) => {
+    const trimmed = spec.trim();
+    const at = trimmed.lastIndexOf('@');
+    if (at <= 0) {
+        if (!trimmed || trimmed === '@') {
+            throw new Error(`'${spec}' is not a package name`);
+        }
+        return { name: trimmed };
+    }
+    const name = trimmed.slice(0, at);
+    const range = trimmed.slice(at + 1).trim();
+    if (!range) {
+        throw new Error(`'${spec}' ends in '@' with no version range after it. Write '${name}@^1.0.0', or drop the '@'.`);
+    }
+    return { name, range };
+};
+export const emptyAddonsLock = () => ({
+    lockfileVersion: 1,
+    sdks: {},
+});
+/** The project's lock, an empty one when there is none. Throws when the file is not a lock. */
+export const readAddonsLock = (rootDir) => {
+    const path = join(rootDir, ADDONS_LOCK_FILE);
+    if (!existsSync(path))
+        return emptyAddonsLock();
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch (e) {
+        throw new Error(`${path} is not valid JSON: ${e?.message ?? e}`);
+    }
+    if (!parsed ||
+        typeof parsed !== 'object' ||
+        typeof parsed.sdks !== 'object') {
+        throw new Error(`${path} has no "sdks" object`);
+    }
+    return { lockfileVersion: 1, sdks: parsed.sdks ?? {} };
+};
+/** Sorted by package name, each entry's keys in a fixed order, so the same lock always writes the same bytes. */
+export const serializeAddonsLock = (lock) => {
+    const sdks = {};
+    for (const name of Object.keys(lock.sdks).sort()) {
+        const { range, version, integrity } = lock.sdks[name];
+        sdks[name] = { range, version, integrity };
+    }
+    return `${JSON.stringify({ lockfileVersion: 1, sdks }, null, 2)}\n`;
+};
+export const remoteSdkDir = (rootDir, name, version) => join(rootDir, REMOTE_SDK_DIR, `${name}@${version}`);
+export const readSdkManifest = (dir) => {
+    try {
+        return JSON.parse(readFileSync(join(dir, 'manifest.json'), 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Whether the SDK for `name@range` is on disk exactly as the lock pins it: the
+ * lock was written for this range, the extracted directory carries the lock's
+ * integrity, and its manifest names this package and version.
+ */
+export const checkLockedSdk = (rootDir, name, range, lock = readAddonsLock(rootDir)) => {
+    const entry = lock.sdks[name];
+    if (!entry) {
+        return { ok: false, reason: `${ADDONS_LOCK_FILE} has no entry for it` };
+    }
+    if (entry.range !== range) {
+        return {
+            ok: false,
+            reason: `${ADDONS_LOCK_FILE} was resolved for '${entry.range}', not '${range}'`,
+        };
+    }
+    const dir = remoteSdkDir(rootDir, name, entry.version);
+    let integrity = null;
+    try {
+        integrity = readFileSync(join(dir, SDK_INTEGRITY_MARKER), 'utf-8').trim();
+    }
+    catch {
+        return { ok: false, reason: `${dir} is missing` };
+    }
+    if (integrity !== entry.integrity) {
+        return {
+            ok: false,
+            reason: `${dir} was extracted from a different tarball than ${ADDONS_LOCK_FILE} pins`,
+        };
+    }
+    const manifest = readSdkManifest(dir);
+    if (!manifest ||
+        manifest.name !== name ||
+        manifest.version !== entry.version) {
+        return {
+            ok: false,
+            reason: `${dir}/manifest.json does not name ${name}@${entry.version}`,
+        };
+    }
+    return { ok: true, entry, dir, manifest };
+};

package/dist/utils/resolve-addon-package.d.ts

@@ -1,5 +1,6 @@
 import type { CredentialOverrideMeta } from '../types.js';
 import * as ts from 'typescript';
+export declare const findPackageNameForFile: (filePath: string) => string | null;
 /**
  * Resolve the addon package name from an imported identifier.
  * Checks if the identifier's import module specifier matches any

package/dist/utils/resolve-addon-package.js

@@ -2,7 +2,7 @@ import * as ts from 'typescript';
 import { existsSync, readFileSync } from 'fs';
 import { dirname, join, parse } from 'path';
 const packageNameCache = new Map();
-const findPackageNameForFile = (filePath) => {
+export const findPackageNameForFile = (filePath) => {
     if (packageNameCache.has(filePath)) {
         return packageNameCache.get(filePath);
     }

package/dist/utils/resolve-versions.js

@@ -90,6 +90,24 @@ export function resolveLatestVersions(state, logger) {
                 }
             }
         }
+        // A remote caller names a version the same way: `fn` is the latest remote
+        // version, and every remote `fn@vN` stays callable by its own id.
+        const remote = [
+            ...group.explicit,
+            ...(group.unversioned
+                ? [{ id: state.rpc.internalMeta[baseName], version: maxVersion + 1 }]
+                : []),
+        ].filter(({ id }) => functionsMeta[id]?.remote === true);
+        if (remote.length > 0) {
+            state.rpc.remoteMeta[baseName] = remote.reduce((a, b) => a.version > b.version ? a : b).id;
+            for (const { id } of remote) {
+                state.rpc.remoteMeta[id] = id;
+                const fileEntry = state.rpc.internalFiles.get(id);
+                if (fileEntry) {
+                    state.rpc.remoteFiles.set(id, fileEntry);
+                }
+            }
+        }
         for (const entry of group.explicit) {
             state.rpc.invokedFunctions.add(entry.id);
         }

package/dist/utils/serialize-inspector-state.d.ts

@@ -118,6 +118,7 @@ export interface SerializableInspectorState {
         }]>;
         approvalDescriptions: InspectorState['functions']['approvalDescriptions'];
         dynamicImportIds?: string[];
+        disabled?: InspectorState['functions']['disabled'];
     };
     http: {
         metaInputTypes: Array<[
@@ -194,6 +195,7 @@ export interface SerializableInspectorState {
             string,
             {
                 package: string;
+                range?: string;
                 file?: string;
                 rpcEndpoint?: string;
                 remote?: boolean;
@@ -326,8 +328,9 @@ export interface SerializableInspectorState {
     openAPISpec: Record<string, any> | null;
     diagnostics: InspectorDiagnostic[];
     addonFunctions: InspectorState['addonFunctions'];
-    screensManifest?: InspectorState['screensManifest'];
-    addonScreens?: InspectorState['addonScreens'];
+    remoteAddonFunctions?: InspectorState['remoteAddonFunctions'];
+    studio?: InspectorState['studio'];
+    addonStudio?: InspectorState['addonStudio'];
     addonContributors?: InspectorState['addonContributors'];
     exportedContracts: InspectorState['exportedContracts'];
 }

package/dist/utils/serialize-inspector-state.js

@@ -41,6 +41,9 @@ export function serializeInspectorState(state) {
             files: Array.from(state.functions.files.entries()),
             approvalDescriptions: state.functions.approvalDescriptions,
             dynamicImportIds: Array.from(state.functions.dynamicImportIds ?? []),
+            ...(Object.keys(state.functions.disabled ?? {}).length > 0
+                ? { disabled: state.functions.disabled }
+                : {}),
         },
         http: {
             metaInputTypes: Array.from(state.http.metaInputTypes.entries()),
@@ -190,8 +193,9 @@ export function serializeInspectorState(state) {
         openAPISpec: state.openAPISpec,
         diagnostics: state.diagnostics,
         addonFunctions: state.addonFunctions,
-        screensManifest: state.screensManifest,
-        addonScreens: state.addonScreens,
+        remoteAddonFunctions: state.remoteAddonFunctions,
+        studio: state.studio,
+        addonStudio: state.addonStudio,
         addonContributors: state.addonContributors,
         exportedContracts: state.exportedContracts,
     };
@@ -239,6 +243,7 @@ export function deserializeInspectorState(data) {
             files: new Map(data.functions.files),
             approvalDescriptions: data.functions.approvalDescriptions || {},
             dynamicImportIds: new Set(data.functions.dynamicImportIds ?? []),
+            disabled: data.functions.disabled ?? {},
         },
         http: {
             metaInputTypes: new Map(data.http.metaInputTypes),
@@ -396,8 +401,11 @@ export function deserializeInspectorState(data) {
         openAPISpec: data.openAPISpec || null,
         diagnostics: data.diagnostics || [],
         addonFunctions: data.addonFunctions || {},
-        screensManifest: data.screensManifest,
-        addonScreens: data.addonScreens,
+        ...(data.remoteAddonFunctions
+            ? { remoteAddonFunctions: data.remoteAddonFunctions }
+            : {}),
+        studio: data.studio,
+        addonStudio: data.addonStudio,
         addonContributors: data.addonContributors,
         exportedContracts: data.exportedContracts || {
             http: {},

package/dist/utils/validate-addon-zod-contract.d.ts

@@ -0,0 +1,23 @@
+import type { TypesMap } from '../types-map.js';
+/**
+ * The named, source-declared types a function's input or output resolves to:
+ * every name the typed maps would have to import rather than declare inline.
+ * A custom alias (a union, an array of rows) is followed through to the names
+ * it references.
+ */
+export declare const namedSourceTypes: (typesMap: TypesMap, names: string[]) => string[];
+export interface AddonContractTypeSource {
+    name: string;
+    usesGenerics: boolean;
+    hasInputSchema: boolean;
+    hasOutputSchema: boolean;
+    inputNames: string[];
+    outputNames: string[];
+}
+/**
+ * Why a `remote: true` addon function cannot ship in an SDK, or null when it
+ * can. Its input and output have to be zod schemas: a TS generic or a named
+ * source type makes codegen emit `import type { X } from '../../../src/...'`
+ * into the remote map, a path that does not exist on the consumer's machine.
+ */
+export declare const addonZodContractViolation: (typesMap: TypesMap, fn: AddonContractTypeSource) => string | null;

package/dist/utils/validate-addon-zod-contract.js

@@ -0,0 +1,70 @@
+import { findPackageNameForFile } from './resolve-addon-package.js';
+/**
+ * A type declared in `@pikku/core` is part of the SDK's allowed import set, so
+ * naming one (an MCP response, say) does not drag the addon's source along.
+ * Core is recognised by its install path or by the name in the nearest
+ * package.json, never by a directory name an addon could also use.
+ */
+const isPikkuCorePath = (path) => /[\\/]node_modules[\\/]@pikku[\\/]core[\\/]/.test(path) ||
+    findPackageNameForFile(path) === '@pikku/core';
+/**
+ * The named, source-declared types a function's input or output resolves to:
+ * every name the typed maps would have to import rather than declare inline.
+ * A custom alias (a union, an array of rows) is followed through to the names
+ * it references.
+ */
+export const namedSourceTypes = (typesMap, names) => {
+    const found = new Set();
+    const visit = (name, seen) => {
+        if (seen.has(name))
+            return;
+        seen.add(name);
+        const custom = typesMap.customTypes.get(name);
+        if (custom) {
+            for (const ref of custom.references)
+                visit(ref, seen);
+            return;
+        }
+        let path = null;
+        let originalName = name;
+        try {
+            const meta = typesMap.getTypeMeta(name);
+            path = meta.path;
+            originalName = meta.originalName;
+        }
+        catch {
+            return;
+        }
+        if (path && !isPikkuCorePath(path))
+            found.add(originalName);
+    };
+    for (const name of names)
+        visit(name, new Set());
+    return [...found].sort();
+};
+/**
+ * Why a `remote: true` addon function cannot ship in an SDK, or null when it
+ * can. Its input and output have to be zod schemas: a TS generic or a named
+ * source type makes codegen emit `import type { X } from '../../../src/...'`
+ * into the remote map, a path that does not exist on the consumer's machine.
+ */
+export const addonZodContractViolation = (typesMap, fn) => {
+    const problems = [];
+    if (fn.usesGenerics) {
+        problems.push('declares its input/output with TypeScript generics');
+    }
+    const named = [
+        ...(fn.hasInputSchema ? [] : namedSourceTypes(typesMap, fn.inputNames)),
+        ...(fn.hasOutputSchema ? [] : namedSourceTypes(typesMap, fn.outputNames)),
+    ];
+    if (named.length > 0) {
+        problems.push(`types its input/output with named source types (${[...new Set(named)].join(', ')})`);
+    }
+    if (problems.length === 0)
+        return null;
+    return (`Addon function '${fn.name}' is remote: true but ${problems.join(' and ')}. ` +
+        `A remote addon's contract ships as a types-only SDK, so its input and output must be zod schemas: ` +
+        `export each schema as a zod variable from a file that does not import #pikku (a sibling <fn>.schemas.ts), ` +
+        `reference it as \`input:\` / \`output:\` on the function, and drop the generics. ` +
+        `TypeScript types would make the SDK import from the addon's src/, which the consumer does not have.`);
+};

package/dist/utils/validate-exposed-functions-gated.d.ts

@@ -11,4 +11,6 @@ import type { InspectorLogger, InspectorState } from '../types.js';
  *
  * knowledge: decisions/security/console-addon-privileged-functions-gate-themselves.md
  */
-export declare function validateExposedFunctionsGated(logger: InspectorLogger, state: InspectorState): void;
+export declare function validateExposedFunctionsGated(logger: InspectorLogger, state: InspectorState, { isAddon }?: {
+    isAddon?: boolean;
+}): void;

package/dist/utils/validate-exposed-functions-gated.js

@@ -11,9 +11,13 @@ import { ErrorCode } from '../error-codes.js';
  *
  * knowledge: decisions/security/console-addon-privileged-functions-gate-themselves.md
  */
-export function validateExposedFunctionsGated(logger, state) {
+export function validateExposedFunctionsGated(logger, state, { isAddon = false } = {}) {
     const ungated = [];
-    for (const [funcName, meta] of Object.entries(state.functions.meta)) {
+    // An addon's own `expose: true` only makes a function eligible: nothing is
+    // reachable until a host's `wireAddon` opts in, and that host is warned below.
+    for (const [funcName, meta] of isAddon
+        ? []
+        : Object.entries(state.functions.meta)) {
         if (!meta.expose)
             continue;
         if (gatesItself(meta))
@@ -22,23 +26,26 @@ export function validateExposedFunctionsGated(logger, state) {
             continue;
         ungated.push(funcName);
     }
-    // A `wireAddon` expose list can open an addon function its author never
-    // exposed, so the app that listed it is the one to tell. The namespaced call
-    // is governed by that instance's config alone.
+    // An addon function is exposed only when the app's `wireAddon` opts in, so
+    // the app that opted in is the one to tell. The namespaced call is governed
+    // by that instance's config alone.
     //
     // knowledge: decisions/security/wire-addon-expose-selects-the-rpc-surface.md
     for (const [namespace, declaration] of state.rpc?.wireAddonDeclarations ??
         []) {
-        if (!Array.isArray(declaration.expose))
+        if (!declaration.expose)
             continue;
         if (declaration.auth === true)
             continue;
         if (declaration.scopes && declaration.scopes.length > 0)
             continue;
         const addonMeta = state.addonFunctions?.[namespace] ?? {};
-        for (const funcName of declaration.expose) {
+        const selected = Array.isArray(declaration.expose)
+            ? declaration.expose
+            : Object.keys(addonMeta);
+        for (const funcName of selected) {
             const meta = addonMeta[funcName];
-            if (!meta || gatesItself(meta))
+            if (!meta?.expose || gatesItself(meta))
                 continue;
             ungated.push(`${namespace}:${funcName}`);
         }

package/dist/visit.js

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { addFileWithFactory } from './add/add-file-with-factory.js';
+import { addFileWithFactory, checkHiddenFactory, } from './add/add-file-with-factory.js';
 import { addFileExtendsCoreType } from './add/add-file-extends-core-type.js';
 import { addHTTPRoute } from './add/add-http-route.js';
 import { addHTTPRoutes } from './add/add-http-routes.js';
@@ -15,7 +15,7 @@ import { addChannel } from './add/add-channel.js';
 import { addGateway } from './add/add-gateway.js';
 import { addRPCInvocations } from './add/add-rpc-invocations.js';
 import { addWireAddon } from './add/add-wire-addon.js';
-import { addDefineScreens } from './add/add-define-screens.js';
+import { addPikkuStudio } from './add/add-pikku-studio.js';
 import { addWireRemoteAddon } from './add/add-wire-remote-addon.js';
 import { addMiddleware } from './add/add-middleware.js';
 import { addPermission } from './add/add-permission.js';
@@ -36,6 +36,7 @@ import { addOutgoingWebhook } from './add/add-outgoing-webhook.js';
 import { addAgentScorer } from './add/add-agent-scorer.js';
 import { addApprovalDescription } from './add/add-approval-description.js';
 import { checkIndirectRegistrations } from './add/check-indirect-registrations.js';
+import { checkDisabledReferences } from './add/check-disabled-references.js';
 export const visitSetup = (logger, checker, node, state, options) => {
     addFileExtendsCoreType(node, checker, state.singletonServicesTypeImportMap, 'CoreSingletonServices', state);
     addFileExtendsCoreType(node, checker, state.wireServicesTypeImportMap, 'CoreServices', state);
@@ -45,11 +46,12 @@ export const visitSetup = (logger, checker, node, state, options) => {
     addFileWithFactory(node, checker, state.wireServicesFactories, 'CreateWireServices', state);
     addFileWithFactory(node, checker, state.configFactories, 'CreateConfig');
     addFileWithFactory(node, checker, state.serverLifecycleFactories, 'ServerLifecycle');
+    checkHiddenFactory(logger, node, state);
     addAnalytics(logger, node, checker, state);
     addOutgoingWebhook(logger, node, checker, state);
     addRPCInvocations(node, state, logger);
     addWireAddon(node, state, logger);
-    addDefineScreens(node, state, logger);
+    addPikkuStudio(node, state, logger);
     addWireRemoteAddon(node, state, logger);
     addMiddleware(logger, node, checker, state, options);
     addPermission(logger, node, checker, state, options);
@@ -100,5 +102,6 @@ export const visitRoutes = (logger, checker, node, state, options) => {
     addFeature(logger, node, checker, state, nextOptions);
     addAgent(logger, node, checker, state, nextOptions);
     addAgentScorer(logger, node, checker, state, nextOptions);
+    checkDisabledReferences(logger, node, checker, state, nextOptions);
     ts.forEachChild(node, (child) => visitRoutes(logger, checker, child, state, nextOptions));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.109",
+  "version": "0.12.111",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/pikkujs/pikku.git",
@@ -70,10 +70,10 @@
     "zod": "^4.6.7"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.145"
+    "@pikku/core": "^0.12.147"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.145",
+    "@pikku/core": "^0.12.147",
     "@types/node": "^26.6.5"
   },
   "engines": {

package/dist/add/add-define-screens.d.ts

@@ -1,8 +0,0 @@
-import * as ts from 'typescript';
-import type { InspectorState, InspectorLogger } from '../types.js';
-/**
- * Detect `defineScreens({ title, icon, screens })` and record the manifest.
- * A screen with a field that is not a literal is reported and left out: a
- * navigation entry the host cannot read would otherwise vanish with no sign.
- */
-export declare function addDefineScreens(node: ts.Node, state: InspectorState, logger: InspectorLogger): void;

package/dist/add/add-define-screens.js

@@ -1,140 +0,0 @@
-import * as ts from 'typescript';
-import { ErrorCode } from '../error-codes.js';
-const propName = (prop) => {
-    if (!ts.isPropertyAssignment(prop))
-        return undefined;
-    return ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)
-        ? prop.name.text
-        : undefined;
-};
-const stringArray = (node) => {
-    if (!ts.isArrayLiteralExpression(node))
-        return undefined;
-    const values = [];
-    for (const element of node.elements) {
-        if (!ts.isStringLiteral(element))
-            return undefined;
-        values.push(element.text);
-    }
-    return values;
-};
-/**
- * The module specifier of `() => import('./screens/x')`. Anything else cannot
- * be handed to the host's bundler as a lazy import, so it is not read.
- */
-const lazyImportSpecifier = (node) => {
-    if (!ts.isArrowFunction(node))
-        return undefined;
-    const body = node.body;
-    if (!ts.isCallExpression(body) ||
-        body.expression.kind !== ts.SyntaxKind.ImportKeyword)
-        return undefined;
-    const [specifier] = body.arguments;
-    return specifier && ts.isStringLiteral(specifier) ? specifier.text : undefined;
-};
-/**
- * Detect `defineScreens({ title, icon, screens })` and record the manifest.
- * A screen with a field that is not a literal is reported and left out: a
- * navigation entry the host cannot read would otherwise vanish with no sign.
- */
-export function addDefineScreens(node, state, logger) {
-    if (!ts.isCallExpression(node))
-        return;
-    const { expression, arguments: args } = node;
-    if (!ts.isIdentifier(expression) || expression.text !== 'defineScreens')
-        return;
-    const [firstArg] = args;
-    if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
-        return;
-    const fail = (message) => logger.critical(ErrorCode.ADDON_SCREENS_NOT_STATIC, message);
-    let title;
-    let icon;
-    const screens = [];
-    for (const prop of firstArg.properties) {
-        const key = propName(prop);
-        if (!key || !ts.isPropertyAssignment(prop))
-            continue;
-        if (key === 'title' && ts.isStringLiteral(prop.initializer)) {
-            title = prop.initializer.text;
-        }
-        else if (key === 'icon' && ts.isStringLiteral(prop.initializer)) {
-            icon = prop.initializer.text;
-        }
-        else if (key === 'screens') {
-            if (!ts.isArrayLiteralExpression(prop.initializer)) {
-                fail(`defineScreens's screens must be an array literal, got: ${prop.initializer.getText()}`);
-                continue;
-            }
-            for (const element of prop.initializer.elements) {
-                if (!ts.isObjectLiteralExpression(element)) {
-                    fail(`A defineScreens screen must be an object literal, got: ${element.getText()}`);
-                    continue;
-                }
-                let path;
-                let screenTitle;
-                let nav;
-                let scopes;
-                let component;
-                let app;
-                for (const field of element.properties) {
-                    const fieldKey = propName(field);
-                    if (!fieldKey || !ts.isPropertyAssignment(field))
-                        continue;
-                    const value = field.initializer;
-                    if (fieldKey === 'path' && ts.isStringLiteral(value)) {
-                        path = value.text;
-                    }
-                    else if (fieldKey === 'title' && ts.isStringLiteral(value)) {
-                        screenTitle = value.text;
-                    }
-                    else if (fieldKey === 'nav' &&
-                        (value.kind === ts.SyntaxKind.TrueKeyword ||
-                            value.kind === ts.SyntaxKind.FalseKeyword)) {
-                        nav = value.kind === ts.SyntaxKind.TrueKeyword;
-                    }
-                    else if (fieldKey === 'scopes') {
-                        scopes = stringArray(value);
-                        if (!scopes) {
-                            fail(`A screen's scopes must be an array of string literals, got: ${value.getText()}`);
-                        }
-                    }
-                    else if (fieldKey === 'component') {
-                        component = lazyImportSpecifier(value);
-                        if (!component) {
-                            fail(`A screen's component must be () => import('<literal>'), got: ${value.getText()}`);
-                        }
-                    }
-                    else if (fieldKey === 'app' && ts.isStringLiteral(value)) {
-                        app = value.text;
-                    }
-                }
-                if (!path || !screenTitle || (!component && !app)) {
-                    fail(`A defineScreens screen needs a literal path and title, and either a lazy component or an app: ${element.getText()}`);
-                    continue;
-                }
-                if (component && app) {
-                    fail(`Screen '${path}' sets both component and app; a screen is one or the other`);
-                    continue;
-                }
-                screens.push({
-                    path,
-                    title: screenTitle,
-                    ...(nav !== undefined ? { nav } : {}),
-                    ...(scopes ? { scopes } : {}),
-                    ...(component ? { component } : { app: app }),
-                });
-            }
-        }
-    }
-    if (!title) {
-        fail(`defineScreens needs a literal title`);
-        return;
-    }
-    logger.debug(`• Found defineScreens: ${title} (${screens.length} screens)`);
-    state.screensManifest = {
-        title,
-        ...(icon ? { icon } : {}),
-        file: node.getSourceFile().fileName,
-        screens,
-    };
-}