@pikku/inspector 0.12.110 → 0.12.112

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()),
@@ -191,9 +194,10 @@ export function serializeInspectorState(state) {
         diagnostics: state.diagnostics,
         addonFunctions: state.addonFunctions,
         remoteAddonFunctions: state.remoteAddonFunctions,
-        screensManifest: state.screensManifest,
-        addonScreens: state.addonScreens,
-        addonContributors: state.addonContributors,
+        studio: state.studio,
+        addonStudio: state.addonStudio,
+        contributorsManifest: state.contributorsManifest,
+        optedInContributors: state.optedInContributors,
         exportedContracts: state.exportedContracts,
     };
 }
@@ -240,6 +244,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),
@@ -400,9 +405,10 @@ export function deserializeInspectorState(data) {
         ...(data.remoteAddonFunctions
             ? { remoteAddonFunctions: data.remoteAddonFunctions }
             : {}),
-        screensManifest: data.screensManifest,
-        addonScreens: data.addonScreens,
-        addonContributors: data.addonContributors,
+        studio: data.studio,
+        addonStudio: data.addonStudio,
+        contributorsManifest: data.contributorsManifest,
+        optedInContributors: data.optedInContributors,
         exportedContracts: data.exportedContracts || {
             http: {},
             cli: {},

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,8 @@ 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 { addDefineContributors } from './add/add-define-contributors.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 +37,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 +47,13 @@ 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);
+    addDefineContributors(logger, node, checker, state);
     addWireRemoteAddon(node, state, logger);
     addMiddleware(logger, node, checker, state, options);
     addPermission(logger, node, checker, state, options);
@@ -100,5 +104,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.110",
+  "version": "0.12.112",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/pikkujs/pikku.git",
@@ -70,10 +70,10 @@
     "zod": "^4.6.7"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.146"
+    "@pikku/core": "^0.12.148"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.146",
+    "@pikku/core": "^0.12.148",
     "@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,
-    };
-}