@pikku/inspector 0.12.106 → 0.12.108

package/dist/index.js

@@ -1,18 +1,19 @@
-export { inspect, getInitialInspectorState } from './inspector.js';
+export { inspect, analyzeProgram } from './inspector.js';
+export { getInitialInspectorState } from './initial-state.js';
+export { finalizeInspectorState } from './finalize.js';
 export { ErrorCode } from './error-codes.js';
-export { AUTH_HANDLER_FUNC_ID } from './add/add-auth.js';
+export { AUTH_HANDLER_FUNC_ID } from './utils/inspector-constants.js';
 export { SCENARIO_INSTRUMENTATION_FUNCTIONS, isScenarioInstrumentationFunction, } from './add/scenario-instrumentation.js';
 export { serializeInspectorState, deserializeInspectorState, } from './utils/serialize-inspector-state.js';
 export { filterInspectorState } from './utils/filter-inspector-state.js';
 export { incompatibleServicesFor, resolveDeployTarget, } from './utils/resolve-deploy-target.js';
-export { generateCustomTypes, sanitizeTypeName, } from './utils/custom-types-generator.js';
+export { generateCustomTypes, customTypeNames, sanitizeTypeName, } from './utils/custom-types-generator.js';
 export { unresolvedSchemaReferences } from './utils/post-process.js';
 export { createEmptyManifest, serializeManifest, } from './utils/contract-hashes.js';
 export { serializeMCPJson } from './utils/serialize-mcp-json.js';
-export { deserializeDslWorkflow, deserializeGraphWorkflow, deserializeAllDslWorkflows, } from './utils/workflow/dsl/index.js';
+export { deserializeDslWorkflow, deserializeGraphWorkflow, deserializeAllDslWorkflows, } from './utils/workflow/dsl/deserialize-dsl-workflow.js';
 export { getFilesAndMethods } from './utils/get-files-and-methods.js';
 export { resolveFunctionMeta } from './utils/resolve-function-meta.js';
-export { resolveCoreType } from './utils/resolve-core-type.js';
 export { readModuleSpecifiers } from './utils/read-module-specifiers.js';
 export { readJsxLiteralText } from './utils/read-jsx-literal-text.js';
 export { readTsconfigOutDir } from './utils/read-tsconfig-out-dir.js';

package/dist/initial-state.d.ts

@@ -0,0 +1,7 @@
+import type { InspectorState } from './types.js';
+/**
+ * Creates an initial/empty inspector state with all required properties initialized
+ * @param rootDir - The root directory for the project
+ * @returns A fresh InspectorState with empty collections
+ */
+export declare function getInitialInspectorState(rootDir: string): InspectorState;

package/dist/initial-state.js

@@ -0,0 +1,216 @@
+import { TypesMap } from './types-map.js';
+/**
+ * Creates an initial/empty inspector state with all required properties initialized
+ * @param rootDir - The root directory for the project
+ * @returns A fresh InspectorState with empty collections
+ */
+export function getInitialInspectorState(rootDir) {
+    return {
+        rootDir,
+        singletonServicesTypeImportMap: new Map(),
+        wireServicesTypeImportMap: new Map(),
+        userSessionTypeImportMap: new Map(),
+        configTypeImportMap: new Map(),
+        singletonServicesFactories: new Map(),
+        wireServicesFactories: new Map(),
+        wireServicesMeta: new Map(),
+        addonRequiredParentServices: [],
+        addonCreatedServices: [],
+        addonServicesFactorySeen: false,
+        addonServerlessIncompatible: new Map(),
+        configFactories: new Map(),
+        serverLifecycleFactories: new Map(),
+        filesAndMethods: {},
+        filesAndMethodsErrors: new Map(),
+        typesLookup: new Map(),
+        schemaLookup: new Map(),
+        schemas: {},
+        functions: {
+            typesMap: new TypesMap(),
+            meta: {},
+            files: new Map(),
+            approvalDescriptions: {},
+            dynamicImportIds: new Set(),
+        },
+        http: {
+            metaInputTypes: new Map(),
+            meta: {
+                get: {},
+                post: {},
+                put: {},
+                delete: {},
+                head: {},
+                patch: {},
+                options: {},
+            },
+            files: new Set(),
+            routeMiddleware: new Map(),
+        },
+        channels: {
+            files: new Set(),
+            meta: {},
+        },
+        gateways: {
+            meta: {},
+            files: new Set(),
+        },
+        triggers: {
+            meta: {},
+            sourceMeta: {},
+            webhookSourceMeta: {},
+            files: new Set(),
+        },
+        scheduledTasks: {
+            meta: {},
+            files: new Set(),
+        },
+        queueWorkers: {
+            meta: {},
+            files: new Set(),
+        },
+        workflows: {
+            meta: {},
+            files: new Map(),
+            graphMeta: {},
+            graphFiles: new Map(),
+            featureFiles: new Map(),
+            invokedWorkflows: new Set(),
+        },
+        rpc: {
+            internalMeta: {},
+            internalFiles: new Map(),
+            exposedMeta: {},
+            exposedFiles: new Map(),
+            remoteMeta: {},
+            remoteFiles: new Map(),
+            invokedFunctions: new Set(),
+            invokedFunctionsByFile: new Map(),
+            usedAddons: new Set(),
+            wireAddonDeclarations: new Map(),
+            wireAddonFiles: new Set(),
+        },
+        mcpEndpoints: {
+            resourcesMeta: {},
+            toolsMeta: {},
+            promptsMeta: {},
+            files: new Set(),
+            surfaces: {},
+        },
+        agents: {
+            agentsMeta: {},
+            files: new Map(),
+            invokedAgentsByFile: new Map(),
+        },
+        scorers: {
+            scorersMeta: {},
+            files: new Map(),
+        },
+        cli: {
+            meta: {
+                programs: {},
+                renderers: {},
+            },
+            files: new Set(),
+        },
+        nodes: {
+            meta: {},
+            files: new Set(),
+        },
+        auth: {
+            providers: [],
+            plugins: [],
+            files: new Set(),
+            definition: null,
+        },
+        secrets: {
+            definitions: [],
+            files: new Set(),
+            usage: new Map(),
+        },
+        surfaceUsage: {},
+        credentials: {
+            definitions: [],
+            files: new Set(),
+        },
+        scopes: {
+            definitions: [],
+            files: new Set(),
+        },
+        systemRoles: {
+            definitions: [],
+            files: new Set(),
+        },
+        featureFlags: {
+            definitions: [],
+            files: new Set(),
+        },
+        virtualUsers: {
+            definitions: [],
+            files: new Set(),
+        },
+        variables: {
+            definitions: [],
+            files: new Set(),
+        },
+        manifest: {
+            initial: null,
+            current: null,
+            errors: [],
+        },
+        middleware: {
+            definitions: {},
+            instances: {},
+            tagMiddleware: new Map(),
+            globalFiles: new Set(),
+        },
+        channelMiddleware: {
+            definitions: {},
+            instances: {},
+            tagMiddleware: new Map(),
+        },
+        agentMiddleware: {
+            definitions: {},
+        },
+        permissions: {
+            definitions: {},
+            instances: {},
+            global: [],
+        },
+        serviceAggregation: {
+            requiredServices: new Set(),
+            usedFunctions: new Set(),
+            usedMiddleware: new Set(),
+            usedPermissions: new Set(),
+            allSingletonServices: [],
+            allWireServices: [],
+        },
+        resolvedIOTypes: {},
+        middlewareGroupsMeta: {
+            definitions: {},
+            instances: {},
+            httpGroups: {},
+            tagGroups: {},
+            channelMiddleware: {
+                definitions: {},
+                instances: {},
+                tagGroups: {},
+            },
+        },
+        permissionsGroupsMeta: {
+            definitions: {},
+        },
+        requiredSchemas: new Set(),
+        openAPISpec: null,
+        diagnostics: [],
+        addonFunctions: {},
+        exportedContracts: {
+            http: {},
+            cli: {},
+            channel: {},
+            addonHttp: {},
+            addonCli: {},
+            addonChannel: {},
+        },
+        program: null,
+    };
+}

package/dist/inspector.d.ts

@@ -1,8 +1,10 @@
 import type { InspectorState, InspectorLogger, InspectorOptions } from './types.js';
+import { getInitialInspectorState } from './initial-state.js';
+export { getInitialInspectorState };
 /**
- * Creates an initial/empty inspector state with all required properties initialized
- * @param rootDir - The root directory for the project
- * @returns A fresh InspectorState with empty collections
+ * The engine-specific half of an inspection: builds the program, walks it with
+ * the checker and generates the schemas. What it returns is the pre-finalize
+ * state that `finalizeInspectorState` completes.
  */
-export declare function getInitialInspectorState(rootDir: string): InspectorState;
+export declare const analyzeProgram: (logger: InspectorLogger, routeFiles: string[], options?: InspectorOptions) => Promise<InspectorState>;
 export declare const inspect: (logger: InspectorLogger, routeFiles: string[], options?: InspectorOptions) => Promise<InspectorState>;

package/dist/inspector.js

@@ -1,244 +1,21 @@
 import * as ts from 'typescript';
-import { applyDeclaredScopes } from './add/add-scope.js';
 import { performance } from 'perf_hooks';
 import { dirname, relative, resolve } from 'path';
 import { visitSetup, visitFunctions, visitRoutes } from './visit.js';
-import { TypesMap } from './types-map.js';
-import { getFilesAndMethods } from './utils/get-files-and-methods.js';
 import { findCommonAncestor } from './utils/find-root-dir.js';
 import { createSourceFileCacheHost } from './source-file-cache.js';
 import { createNestedProjectFilter } from './utils/nested-project-filter.js';
 import { toProgramPath } from './utils/program-path.js';
-import { aggregateRequiredServices, stampAuthHandlerServices, validateAgentModels, validateAgentToolReferences, validateAgentScorerReferences, validateSecretOverrides, validateVariableOverrides, validateCredentialOverrides, validateAddonUses, validateAddonContentGrants, validateRemoteAddonDependencies, validateRemoteAddonAuth, validateScopeReferences, validateSystemRoleScopes, validateVirtualUserRoles, computeResolvedIOTypes, computeMiddlewareGroupsMeta, computePermissionsGroupsMeta, computeRequiredSchemas, validateNoSecretAliasServices, registerDerivedOAuth2AppSecrets, validateSecretUsage, computeDiagnostics, validateSchemaReferences, validateSchemaWiringSeparation, validateScenarioServices, validateScenarioSteps, validateScenarioFeatures, validateWorkflowGraphAddons, } from './utils/post-process.js';
-import { validateExposedFunctionsGated } from './utils/validate-exposed-functions-gated.js';
-import { validateTagsResolveToMiddleware } from './utils/validate-tags-resolve-to-middleware.js';
-import { validateSingleStepWorkflows } from './utils/validate-single-step-workflows.js';
-import { annotateHttpRouteAuth } from './utils/annotate-http-route-auth.js';
-import { generateOpenAPISpec } from './utils/serialize-openapi-json.js';
-import { pikkuState } from '@pikku/core/state';
 import { resolveLatestVersions } from './utils/resolve-versions.js';
 import { validateWebhookSourceTriggers } from './add/add-trigger.js';
-import { finalizeWorkflows } from './utils/workflow/graph/finalize-workflows.js';
-import { finalizeWorkflowHelperTypes, finalizeWorkflowWires, } from './utils/workflow/graph/finalize-workflow-wires.js';
 import { generateAllSchemas } from './utils/schema-generator.js';
 import { extractSecretUsage } from './utils/extract-secret-usage.js';
 import { accumulateSurfaceUsage, surfaceUsageArea, } from './utils/extract-surface-usage.js';
-import { loadAddonFunctionsMeta, loadAddonSchemas, } from './utils/load-addon-functions-meta.js';
-import { computeContractHashes, extractContractsFromMeta, updateManifest, createEmptyManifest, validateContracts, } from './utils/contract-hashes.js';
-/**
- * Creates an initial/empty inspector state with all required properties initialized
- * @param rootDir - The root directory for the project
- * @returns A fresh InspectorState with empty collections
- */
-export function getInitialInspectorState(rootDir) {
-    return {
-        rootDir,
-        singletonServicesTypeImportMap: new Map(),
-        wireServicesTypeImportMap: new Map(),
-        userSessionTypeImportMap: new Map(),
-        configTypeImportMap: new Map(),
-        singletonServicesFactories: new Map(),
-        wireServicesFactories: new Map(),
-        wireServicesMeta: new Map(),
-        addonRequiredParentServices: [],
-        addonCreatedServices: [],
-        addonServicesFactorySeen: false,
-        addonServerlessIncompatible: new Map(),
-        configFactories: new Map(),
-        serverLifecycleFactories: new Map(),
-        filesAndMethods: {},
-        filesAndMethodsErrors: new Map(),
-        typesLookup: new Map(),
-        schemaLookup: new Map(),
-        schemas: {},
-        functions: {
-            typesMap: new TypesMap(),
-            meta: {},
-            files: new Map(),
-            approvalDescriptions: {},
-            dynamicImportIds: new Set(),
-        },
-        http: {
-            metaInputTypes: new Map(),
-            meta: {
-                get: {},
-                post: {},
-                put: {},
-                delete: {},
-                head: {},
-                patch: {},
-                options: {},
-            },
-            files: new Set(),
-            routeMiddleware: new Map(),
-        },
-        channels: {
-            files: new Set(),
-            meta: {},
-        },
-        gateways: {
-            meta: {},
-            files: new Set(),
-        },
-        triggers: {
-            meta: {},
-            sourceMeta: {},
-            webhookSourceMeta: {},
-            files: new Set(),
-        },
-        scheduledTasks: {
-            meta: {},
-            files: new Set(),
-        },
-        queueWorkers: {
-            meta: {},
-            files: new Set(),
-        },
-        workflows: {
-            meta: {},
-            files: new Map(),
-            graphMeta: {},
-            graphFiles: new Map(),
-            featureFiles: new Map(),
-            invokedWorkflows: new Set(),
-        },
-        rpc: {
-            internalMeta: {},
-            internalFiles: new Map(),
-            exposedMeta: {},
-            exposedFiles: new Map(),
-            remoteMeta: {},
-            remoteFiles: new Map(),
-            invokedFunctions: new Set(),
-            invokedFunctionsByFile: new Map(),
-            usedAddons: new Set(),
-            wireAddonDeclarations: new Map(),
-            wireAddonFiles: new Set(),
-        },
-        mcpEndpoints: {
-            resourcesMeta: {},
-            toolsMeta: {},
-            promptsMeta: {},
-            files: new Set(),
-            surfaces: {},
-        },
-        agents: {
-            agentsMeta: {},
-            files: new Map(),
-            invokedAgentsByFile: new Map(),
-        },
-        scorers: {
-            scorersMeta: {},
-            files: new Map(),
-        },
-        cli: {
-            meta: {
-                programs: {},
-                renderers: {},
-            },
-            files: new Set(),
-        },
-        nodes: {
-            meta: {},
-            files: new Set(),
-        },
-        auth: {
-            providers: [],
-            plugins: [],
-            files: new Set(),
-            definition: null,
-        },
-        secrets: {
-            definitions: [],
-            files: new Set(),
-            usage: new Map(),
-        },
-        surfaceUsage: {},
-        credentials: {
-            definitions: [],
-            files: new Set(),
-        },
-        scopes: {
-            definitions: [],
-            files: new Set(),
-        },
-        systemRoles: {
-            definitions: [],
-            files: new Set(),
-        },
-        featureFlags: {
-            definitions: [],
-            files: new Set(),
-        },
-        virtualUsers: {
-            definitions: [],
-            files: new Set(),
-        },
-        variables: {
-            definitions: [],
-            files: new Set(),
-        },
-        manifest: {
-            initial: null,
-            current: null,
-            errors: [],
-        },
-        middleware: {
-            definitions: {},
-            instances: {},
-            tagMiddleware: new Map(),
-            globalFiles: new Set(),
-        },
-        channelMiddleware: {
-            definitions: {},
-            instances: {},
-            tagMiddleware: new Map(),
-        },
-        agentMiddleware: {
-            definitions: {},
-        },
-        permissions: {
-            definitions: {},
-            instances: {},
-        },
-        serviceAggregation: {
-            requiredServices: new Set(),
-            usedFunctions: new Set(),
-            usedMiddleware: new Set(),
-            usedPermissions: new Set(),
-            allSingletonServices: [],
-            allWireServices: [],
-        },
-        resolvedIOTypes: {},
-        middlewareGroupsMeta: {
-            definitions: {},
-            instances: {},
-            httpGroups: {},
-            tagGroups: {},
-            channelMiddleware: {
-                definitions: {},
-                instances: {},
-                tagGroups: {},
-            },
-        },
-        permissionsGroupsMeta: {
-            definitions: {},
-        },
-        requiredSchemas: new Set(),
-        openAPISpec: null,
-        diagnostics: [],
-        addonFunctions: {},
-        exportedContracts: {
-            http: {},
-            cli: {},
-            channel: {},
-            addonHttp: {},
-            addonCli: {},
-            addonChannel: {},
-        },
-        program: null,
-    };
-}
+import { loadAddonFunctionsMeta } from './utils/load-addon-functions-meta.js';
+import { resolveServiceTypes } from './utils/resolve-service-types.js';
+import { finalizeInspectorState } from './finalize.js';
+import { getInitialInspectorState } from './initial-state.js';
+export { getInitialInspectorState };
 /**
  * The path mappings the inspector's program has to share with the project.
  *
@@ -272,7 +49,12 @@ const readProjectPathMappings = (logger, tsconfig) => {
         ...(pathsBasePath !== undefined ? { pathsBasePath } : {}),
     };
 };
-export const inspect = async (logger, routeFiles, options = {}) => {
+/**
+ * The engine-specific half of an inspection: builds the program, walks it with
+ * the checker and generates the schemas. What it returns is the pre-finalize
+ * state that `finalizeInspectorState` completes.
+ */
+export const analyzeProgram = async (logger, routeFiles, options = {}) => {
     const normalizedRouteFiles = routeFiles.map((file) => resolve(file));
     const compilerOptions = {
         ...readProjectPathMappings(logger, options.tsconfig),
@@ -364,81 +146,11 @@ export const inspect = async (logger, routeFiles, options = {}) => {
             const startSchemas = performance.now();
             state.schemas = await generateAllSchemas(logger, options.schemaConfig, state);
             logger.debug(`generateAllSchemas took ${(performance.now() - startSchemas).toFixed(0)}ms`);
-            computeContractHashes(state.schemas, state.functions.typesMap, state.functions.meta);
-            computeRequiredSchemas(state, options);
-        }
-        // Re-load addon schemas (generateAllSchemas replaces state.schemas)
-        await loadAddonSchemas(logger, state);
-        // After the addon merge, not before: an addon supplies its own schemas here,
-        // and checking earlier would report every one of them as unresolved.
-        if (options.schemaConfig) {
-            validateSchemaReferences(logger, state);
         }
-        state.manifest.initial = options.manifest ?? null;
-        const contracts = extractContractsFromMeta(state.functions.meta);
-        const baseManifest = state.manifest.initial ?? createEmptyManifest();
-        state.manifest.current = updateManifest(baseManifest, contracts);
-        state.manifest.errors = validateContracts(baseManifest, contracts).errors;
-        finalizeWorkflows(state);
-        finalizeWorkflowHelperTypes(state);
-        finalizeWorkflowWires(state);
-    }
-    // Populate filesAndMethods
-    const startFilesAndMethods = performance.now();
-    const { result, errors } = getFilesAndMethods(state, options.types);
-    state.filesAndMethods = result;
-    state.filesAndMethodsErrors = errors;
-    logger.debug(`Get files and methods completed in ${(performance.now() - startFilesAndMethods).toFixed(2)}ms`);
-    if (!options.setupOnly) {
-        // Everything below re-derives from the state this pass just built, so it
-        // supersedes whatever an earlier pass concluded about a source graph the
-        // run has since finished generating into.
-        logger.beginValidationPass?.();
-        const startAggregate = performance.now();
-        // Apply the inspected auth handler service set before aggregation so it
-        // flows into requiredServices (the generated handler's own func is opaque).
-        stampAuthHandlerServices(state);
-        aggregateRequiredServices(state);
-        logger.debug(`Aggregate required services completed in ${(performance.now() - startAggregate).toFixed(2)}ms`);
-        computeResolvedIOTypes(state);
-        computeMiddlewareGroupsMeta(state);
-        computePermissionsGroupsMeta(state);
-        validateNoSecretAliasServices(logger, checker, state);
-        registerDerivedOAuth2AppSecrets(state);
-        validateSecretUsage(logger, state);
-        computeDiagnostics(state);
-        validateSchemaWiringSeparation(logger, state);
-        validateWorkflowGraphAddons(logger, state);
-        validateSingleStepWorkflows(logger, state);
-        validateScenarioServices(logger, state);
-        validateScenarioSteps(logger, state);
-        validateScenarioFeatures(logger, state);
-        // Needs every route, every function and every wireAddon declaration
-        // together, so it can only run once the whole program is inspected.
-        annotateHttpRouteAuth(state);
-        // Last of the validators: they read function meta and every wireAddon
-        // declaration together, so they need the whole program inspected.
-        validateExposedFunctionsGated(logger, state);
-        validateTagsResolveToMiddleware(logger, state);
-        if (options.openAPI) {
-            state.openAPISpec = await generateOpenAPISpec(logger, state.functions.meta, state.http.meta, state.schemas, options.openAPI.additionalInfo, pikkuState(null, 'misc', 'errors'));
-        }
-        validateAgentModels(logger, state, options.modelAliases);
-        validateAgentToolReferences(logger, state, options);
-        validateAgentScorerReferences(logger, state);
-        validateSecretOverrides(logger, state);
-        validateVariableOverrides(logger, state);
-        validateCredentialOverrides(logger, state);
-        validateAddonUses(logger, state);
-        validateAddonContentGrants(logger, state);
-        validateRemoteAddonDependencies(logger, state);
-        validateRemoteAddonAuth(logger, state);
-        applyDeclaredScopes(state);
-        validateScopeReferences(logger, state);
-        validateSystemRoleScopes(logger, state);
-        validateVirtualUserRoles(logger, state);
-        logger.endValidationPass?.();
     }
+    // On a setup-only pass too: the CLI reads the singleton service names off
+    // a setup-only state to decide whether workflows have a workflowService.
+    state.serviceTypes = resolveServiceTypes(state, checker);
     const cpu = process.cpuUsage(cpuStart);
     state.stats = {
         files: program.getSourceFiles().length,
@@ -454,3 +166,17 @@ export const inspect = async (logger, routeFiles, options = {}) => {
     state.program = program;
     return state;
 };
+export const inspect = async (logger, routeFiles, options = {}) => {
+    const cpuStart = process.cpuUsage();
+    const start = performance.now();
+    const state = await analyzeProgram(logger, routeFiles, options);
+    await finalizeInspectorState(logger, state, options);
+    const cpu = process.cpuUsage(cpuStart);
+    state.stats = {
+        ...state.stats,
+        cpuMs: Math.round((cpu.user + cpu.system) / 1000),
+        wallMs: Math.round(performance.now() - start),
+        heapUsedMb: Math.round(process.memoryUsage().heapUsed / 1048576),
+    };
+    return state;
+};

package/dist/lite.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The inspector's exports that never load the TypeScript compiler.
+ *
+ * `@pikku/inspector` itself pulls in `typescript` and `ts-json-schema-generator`
+ * at module load, which costs a CLI command that only wants an error code or a
+ * serializer most of its startup time, and costs the native engine the
+ * compiler's memory for nothing. Everything a consumer of an `InspectorState`
+ * needs is here and safe to import eagerly; `lite.test.ts` fails if anything
+ * reachable from this file imports `typescript`.
+ */
+export { getInitialInspectorState } from './initial-state.js';
+export { ErrorCode } from './error-codes.js';
+export type { DiagnosticSeverity, CodedDiagnostic } from './error-codes.js';
+export { AUTH_HANDLER_FUNC_ID } from './utils/inspector-constants.js';
+export { SCENARIO_INSTRUMENTATION_FUNCTIONS, isScenarioInstrumentationFunction, } from './add/scenario-instrumentation.js';
+export { serializeInspectorState, deserializeInspectorState, } from './utils/serialize-inspector-state.js';
+export { filterInspectorState } from './utils/filter-inspector-state.js';
+export { incompatibleServicesFor, resolveDeployTarget, } from './utils/resolve-deploy-target.js';
+export { customTypeNames, generateCustomTypes, sanitizeTypeName, } from './utils/custom-types-generator.js';
+export { unresolvedSchemaReferences } from './utils/post-process.js';
+export { createEmptyManifest, serializeManifest, } from './utils/contract-hashes.js';
+export { serializeMCPJson } from './utils/serialize-mcp-json.js';
+export { deserializeDslWorkflow, deserializeGraphWorkflow, deserializeAllDslWorkflows, } from './utils/workflow/dsl/deserialize-dsl-workflow.js';
+export { resolveFunctionMeta } from './utils/resolve-function-meta.js';
+export { resolveCoreType } from './utils/resolve-core-type.js';
+export { addonResolutionDirs, createAddonResolver, } from './utils/addon-resolution.js';

package/dist/lite.js

@@ -0,0 +1,25 @@
+/**
+ * The inspector's exports that never load the TypeScript compiler.
+ *
+ * `@pikku/inspector` itself pulls in `typescript` and `ts-json-schema-generator`
+ * at module load, which costs a CLI command that only wants an error code or a
+ * serializer most of its startup time, and costs the native engine the
+ * compiler's memory for nothing. Everything a consumer of an `InspectorState`
+ * needs is here and safe to import eagerly; `lite.test.ts` fails if anything
+ * reachable from this file imports `typescript`.
+ */
+export { getInitialInspectorState } from './initial-state.js';
+export { ErrorCode } from './error-codes.js';
+export { AUTH_HANDLER_FUNC_ID } from './utils/inspector-constants.js';
+export { SCENARIO_INSTRUMENTATION_FUNCTIONS, isScenarioInstrumentationFunction, } from './add/scenario-instrumentation.js';
+export { serializeInspectorState, deserializeInspectorState, } from './utils/serialize-inspector-state.js';
+export { filterInspectorState } from './utils/filter-inspector-state.js';
+export { incompatibleServicesFor, resolveDeployTarget, } from './utils/resolve-deploy-target.js';
+export { customTypeNames, generateCustomTypes, sanitizeTypeName, } from './utils/custom-types-generator.js';
+export { unresolvedSchemaReferences } from './utils/post-process.js';
+export { createEmptyManifest, serializeManifest, } from './utils/contract-hashes.js';
+export { serializeMCPJson } from './utils/serialize-mcp-json.js';
+export { deserializeDslWorkflow, deserializeGraphWorkflow, deserializeAllDslWorkflows, } from './utils/workflow/dsl/deserialize-dsl-workflow.js';
+export { resolveFunctionMeta } from './utils/resolve-function-meta.js';
+export { resolveCoreType } from './utils/resolve-core-type.js';
+export { addonResolutionDirs, createAddonResolver, } from './utils/addon-resolution.js';