@pikku/inspector 0.12.107 → 0.12.109

package/dist/add/add-cli.js

@@ -363,6 +363,11 @@ function processCommand(logger, inspectorState, options, name, node, sourceFile,
                     meta.isDefault = prop.initializer.kind === ts.SyntaxKind.TrueKeyword;
                 }
                 break;
+            case 'hidden':
+                if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                    meta.hidden = true;
+                }
+                break;
         }
     }
     // --- validate auth/sessionless ---

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { inspect, analyzeProgram } from './inspector.js';
 export { getInitialInspectorState } from './initial-state.js';
 export { finalizeInspectorState } from './finalize.js';
 export type { TypesMap } from './types-map.js';
-export type { AddonConfig, AuthDefinition, CredentialOverrideMeta, ScreensManifestMeta, AddonScreenMeta, InspectorDiagnostic, InspectorFilters, InspectorHTTPState, InspectorLogger, InspectorMiddlewareState, InspectorOptions, InspectorPermissionState, InspectorServiceTypes, InspectorState, MetaInputTypes, MiddlewareGroupMeta, MiddlewareRegistration, SchemaRef, } from './types.js';
+export type { AddonConfig, AuthDefinition, CredentialOverrideMeta, ScreensManifestMeta, AddonScreenMeta, AddonContributorRef, AddonContributorsMeta, InspectorDiagnostic, InspectorFilters, InspectorHTTPState, InspectorLogger, InspectorMiddlewareState, InspectorOptions, InspectorPermissionState, InspectorServiceTypes, InspectorState, MetaInputTypes, MiddlewareGroupMeta, MiddlewareRegistration, SchemaRef, } from './types.js';
 export type { FilesAndMethodsErrors } from './utils/get-files-and-methods.js';
 export { ErrorCode } from './error-codes.js';
 export type { DiagnosticSeverity, CodedDiagnostic } from './error-codes.js';

package/dist/types.d.ts

@@ -544,11 +544,26 @@ export interface InspectorServiceTypes {
     /** Singleton services that are a `SecretService` under another name. */
     secretAliases: string[];
 }
+export interface AddonContributorRef {
+    module: string;
+    export?: string;
+}
+export interface AddonContributorsMeta {
+    packageName: string;
+    packageDir: string;
+    contributors: AddonContributorRef[];
+}
 export interface InspectorState {
     /** Set when this package calls `defineScreens`: the screens it ships. */
     screensManifest?: ScreensManifestMeta;
     /** The screens of the addons this project wires with `ui: true`, by namespace. */
     addonScreens?: Record<string, ScreensManifestMeta>;
+    /**
+     * Platform service contributors each wired, non-remote addon declares in its
+     * `package.json` under `pikku.contributors`, by namespace. `module` resolves
+     * from `packageDir`.
+     */
+    addonContributors?: Record<string, AddonContributorsMeta>;
     rootDir: string;
     singletonServicesTypeImportMap: PathToNameAndType;
     wireServicesTypeImportMap: PathToNameAndType;

package/dist/utils/load-addon-functions-meta.d.ts

@@ -1,4 +1,4 @@
-import type { InspectorState, InspectorLogger } from '../types.js';
+import type { AddonContributorsMeta, InspectorState, InspectorLogger } from '../types.js';
 import type { WebhookSourcesMeta } from '@pikku/core/trigger';
 export declare const describeMissingAddonMeta: (namespace: string, packageName: string, dirs: string[], declFile?: string) => string;
 /**
@@ -8,6 +8,13 @@ export declare const describeMissingAddonMeta: (namespace: string, packageName:
  * Every source starts off: the app turns one on at runtime.
  */
 export declare const namespaceAddonWebhookSources: (sources: WebhookSourcesMeta, namespace: string) => WebhookSourcesMeta;
+/**
+ * The platform service contributors an addon declares in its package.json,
+ * `"pikku": { "contributors": [{ "module", "export" }] }` — the same shape as
+ * `dev.contributors`. `wireAddon` has no place for them: a contributor emits
+ * code into the host's entry, so it belongs to the package, not the wiring.
+ */
+export declare const readAddonContributors: (dirs: string[], packageName: string) => Promise<AddonContributorsMeta | null>;
 export declare function loadAddonFunctionsMeta(logger: InspectorLogger, state: InspectorState): Promise<void>;
 /**
  * Load addon schemas into state.schemas. Called after generateAllSchemas

package/dist/utils/load-addon-functions-meta.js

@@ -203,6 +203,42 @@ const readAddonNeeds = async (dirs, packageName) => {
         return [];
     }
 };
+const isContributorRef = (value) => !!value &&
+    typeof value === 'object' &&
+    typeof value.module === 'string' &&
+    (value.export === undefined ||
+        typeof value.export === 'string');
+/**
+ * The platform service contributors an addon declares in its package.json,
+ * `"pikku": { "contributors": [{ "module", "export" }] }` — the same shape as
+ * `dev.contributors`. `wireAddon` has no place for them: a contributor emits
+ * code into the host's entry, so it belongs to the package, not the wiring.
+ */
+export const readAddonContributors = async (dirs, packageName) => {
+    const packageDir = findInstalledPackageDir(dirs, packageName);
+    if (!packageDir)
+        return null;
+    let declared;
+    try {
+        const pkg = JSON.parse(await readFile(join(packageDir, 'package.json'), 'utf-8'));
+        declared = pkg?.pikku?.contributors;
+    }
+    catch {
+        return null;
+    }
+    if (declared === undefined)
+        return null;
+    if (!Array.isArray(declared) || !declared.every(isContributorRef)) {
+        throw new Error(`${packageName} declares pikku.contributors in its package.json, but it is not a list of { module, export? }.`);
+    }
+    if (declared.length === 0)
+        return null;
+    return {
+        packageName,
+        packageDir,
+        contributors: declared.map(({ module, export: name }) => name === undefined ? { module } : { module, export: name }),
+    };
+};
 export async function loadAddonFunctionsMeta(logger, state) {
     const { wireAddonDeclarations } = state.rpc;
     if (wireAddonDeclarations.size === 0)
@@ -216,6 +252,16 @@ export async function loadAddonFunctionsMeta(logger, state) {
         const dirs = addonResolutionDirs(state.rootDir, decl.file);
         const require = createAddonResolver(dirs);
         try {
+            try {
+                const contributors = await readAddonContributors(dirs, decl.package);
+                if (contributors) {
+                    ;
+                    (state.addonContributors ??= {})[namespace] = contributors;
+                }
+            }
+            catch (error) {
+                logger.error(`wireAddon('${namespace}'): ${error instanceof Error ? error.message : error}`);
+            }
             for (const needed of await readAddonNeeds(dirs, decl.package)) {
                 if (!decl.uses?.[needed]) {
                     logger.critical(ErrorCode.ADDON_NEEDS_NOT_MAPPED, `${decl.package} needs ${needed}, but wireAddon('${namespace}') does not map it. Wire ${needed} and add uses: { '${needed}': '<name>' } to this wireAddon.`);

package/dist/utils/read-jsx-literal-text.js

@@ -42,6 +42,34 @@ const NON_TEXT_ATTRIBUTES = new Set([
     'value',
     'key',
 ]);
+/**
+ * Calls whose string arguments are class lists. A literal anywhere inside one —
+ * `cva('…', { variants: { size: { heading: 'font-heading text-xl' } } })` — is
+ * styling, even under a key like `heading` that would otherwise read as text.
+ */
+const CLASS_BUILDERS = new Set([
+    'cn',
+    'cva',
+    'clsx',
+    'cx',
+    'classNames',
+    'classnames',
+    'tv',
+    'twMerge',
+    'twJoin',
+]);
+const isInsideClassBuilder = (node) => {
+    for (let at = node.parent; at; at = at.parent) {
+        if (ts.isJsxElement(at) || ts.isJsxSelfClosingElement(at))
+            return false;
+        if (ts.isCallExpression(at) &&
+            ts.isIdentifier(at.expression) &&
+            CLASS_BUILDERS.has(at.expression.text)) {
+            return true;
+        }
+    }
+    return false;
+};
 const isProse = (text) => /^\p{Lu}[^\s]*(\s+[^\s]+)+/u.test(text.trim()) &&
     !/[:/[\]=_#]/.test(text.split(/\s+/)[0] ?? '');
 const isSentence = (text) => /\p{L}+\s+\p{L}+/u.test(text);
@@ -72,7 +100,9 @@ export const readJsxLiteralText = (fileName, content) => {
     const found = [];
     const seen = new Set();
     const add = (node, text) => {
-        if (!hasLetter(text) || seen.has(node.getStart(source)))
+        if (!hasLetter(text) ||
+            seen.has(node.getStart(source)) ||
+            isInsideClassBuilder(node))
             return;
         seen.add(node.getStart(source));
         const { line } = source.getLineAndCharacterOfPosition(node.getStart(source));

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

@@ -328,6 +328,7 @@ export interface SerializableInspectorState {
     addonFunctions: InspectorState['addonFunctions'];
     screensManifest?: InspectorState['screensManifest'];
     addonScreens?: InspectorState['addonScreens'];
+    addonContributors?: InspectorState['addonContributors'];
     exportedContracts: InspectorState['exportedContracts'];
 }
 /**

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

@@ -192,6 +192,7 @@ export function serializeInspectorState(state) {
         addonFunctions: state.addonFunctions,
         screensManifest: state.screensManifest,
         addonScreens: state.addonScreens,
+        addonContributors: state.addonContributors,
         exportedContracts: state.exportedContracts,
     };
 }
@@ -397,6 +398,7 @@ export function deserializeInspectorState(data) {
         addonFunctions: data.addonFunctions || {},
         screensManifest: data.screensManifest,
         addonScreens: data.addonScreens,
+        addonContributors: data.addonContributors,
         exportedContracts: data.exportedContracts || {
             http: {},
             cli: {},

package/dist/utils/workflow/graph/convert-dsl-to-graph.js

@@ -413,6 +413,7 @@ export function convertDslToGraph(workflowName, meta) {
         name: workflowName,
         pikkuFuncId: meta.pikkuFuncId,
         source,
+        scenario: meta.scenario || undefined,
         title: meta.title,
         description: meta.description,
         tags: meta.tags,

package/dist/utils/workflow/graph/workflow-graph.types.d.ts

@@ -156,6 +156,8 @@ export interface SerializedWorkflowGraph {
     pikkuFuncId: string;
     /** Source type: 'dsl' for pikkuWorkflowFunc, 'graph' for pikkuWorkflowGraph */
     source: WorkflowSourceType;
+    /** True for a scenario, so meta readers can tell it from a real workflow */
+    scenario?: boolean;
     /** Optional short display name */
     title?: string;
     /** Optional description */

package/package.json

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