@pikku/inspector 0.12.16 → 0.12.18

package/CHANGELOG.md

@@ -1,3 +1,42 @@
+## 0.12.18
+
+### Patch Changes
+
+- 20750fd: feat(workflow): decide step dispatch purely per-function
+
+  Workflow step execution (inline vs queue dispatch) is now decided entirely by
+  the step's function `inline` flag — the workflow-level / run-level `inline`
+  meta no longer participates in per-step dispatch.
+  - Steps default to **inline**, so a normally-started (queue-backed) workflow
+    runs its whole chain in one orchestrator pass instead of one queue
+    round-trip per step.
+  - A function marked `inline: false` is dispatched via the queue (its own
+    worker, retry isolation). When `inline: false` but no `queueService` is
+    configured, the step falls back to inline and emits a `logger.warn` instead
+    of silently swallowing the misconfiguration.
+  - Removed the now-unused workflow-level `inline` from `WorkflowsMeta` /
+    `WorkflowRuntimeMeta`, the inspector's workflow extraction, the DSL→graph
+    converter, and the deploy analyzer / service inference (which now key off
+    the per-function flag). Run-level `inline` is retained: it still controls
+    whether a whole run executes in-process without queue infrastructure.
+
+- Updated dependencies [cd101a5]
+- Updated dependencies [ac16265]
+- Updated dependencies [a05e864]
+- Updated dependencies [20750fd]
+  - @pikku/core@0.12.30
+
+## 0.12.17
+
+### Patch Changes
+
+- 2cf67be: Add inline option to pikkuFunc/pikkuSessionlessFunc for workflow step dispatch
+
+  By default, workflow steps now run inline (no queue hop). Set inline: false on a function to force dispatch through the queue for that step.
+
+- Updated dependencies [2cf67be]
+  - @pikku/core@0.12.28
+
 ## 0.12.16
 
 ### Patch Changes

package/dist/add/add-functions.js

@@ -277,6 +277,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
     let deploy;
     let approvalRequired;
     let approvalDescription;
+    let inline;
     let version;
     let objectNode;
     let nodeDisplayName = null;
@@ -344,6 +345,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         readonly_ = getPropertyValue(firstArg, 'readonly');
         deploy = getPropertyValue(firstArg, 'deploy');
         approvalRequired = getPropertyValue(firstArg, 'approvalRequired');
+        inline = getPropertyValue(firstArg, 'inline');
         // Extract approvalDescription identifier reference
         for (const prop of firstArg.properties) {
             if (ts.isPropertyAssignment(prop) &&
@@ -486,6 +488,12 @@ export const addFunctions = (logger, node, checker, state, options) => {
     const genericTypes = (typeArguments ?? [])
         .map((tn) => checker.getTypeFromTypeNode(tn))
         .map((t) => unwrapPromise(checker, t));
+    // pikkuChannelConnectionFunc<Out> declares a single generic that is the
+    // OUTPUT type — its input is always void (PikkuFunctionSessionless<void, Out>).
+    // Every other wrapper reads generic[0] as INPUT, so without this guard the
+    // connect handler's output generic is mis-recorded as inputSchemaName and the
+    // empty WS handshake fails input validation at connect (1008/403).
+    const isChannelConnectionFunc = /ChannelConnection/i.test(expression.text);
     const capitalizedName = funcIdToTypeName(name);
     // --- Input Extraction ---
     let inputNames = [];
@@ -511,7 +519,10 @@ export const addFunctions = (logger, node, checker, state, options) => {
             inputTypes = [filterType];
         }
     }
-    else if (!isListFunc && genericTypes.length >= 1 && genericTypes[0]) {
+    else if (!isChannelConnectionFunc &&
+        !isListFunc &&
+        genericTypes.length >= 1 &&
+        genericTypes[0]) {
         // Fall back to extracting from generic type arguments
         const result = getNamesAndTypes(checker, state.functions.typesMap, 'Input', name, genericTypes[0]);
         inputNames = result.names;
@@ -716,6 +727,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         deploy: deploy || undefined,
         approvalRequired: approvalRequired || undefined,
         approvalDescription: approvalDescription || undefined,
+        inline: inline === false ? false : undefined,
         implementationHash,
         version,
         title,

package/dist/add/add-keyed-wiring.js

@@ -2,6 +2,7 @@ import * as ts from 'typescript';
 import { getPropertyValue, assertStringLiteralProperty, } from '../utils/get-property-value.js';
 import { ErrorCode } from '../error-codes.js';
 import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
+import { parseDurationString } from '@pikku/core';
 export const createAddKeyedWiring = (config) => {
     return (logger, node, checker, state, _options) => {
         if (!ts.isCallExpression(node)) {
@@ -24,6 +25,7 @@ export const createAddKeyedWiring = (config) => {
             const nameValue = getPropertyValue(obj, 'name');
             const displayNameValue = getPropertyValue(obj, 'displayName');
             const descriptionValue = getPropertyValue(obj, 'description');
+            const rotationPeriodValue = getPropertyValue(obj, 'rotationPeriod');
             const idValue = getPropertyValue(obj, config.idField);
             let schemaVariableName = null;
             let schemaSourceFile = null;
@@ -74,6 +76,15 @@ export const createAddKeyedWiring = (config) => {
                 logger.critical(ErrorCode.MISSING_NAME, `${config.label} '${nameValue}' is missing the required 'schema' property or schema is not a variable reference.`);
                 return;
             }
+            if (rotationPeriodValue) {
+                try {
+                    parseDurationString(rotationPeriodValue);
+                }
+                catch {
+                    logger.critical(ErrorCode.INVALID_VALUE, `${config.label} '${nameValue}' has an invalid 'rotationPeriod': '${rotationPeriodValue}'. Use a duration like '1d', '30day', or '1w'.`);
+                    return;
+                }
+            }
             const sourceFile = node.getSourceFile().fileName;
             const wiringState = config.getState(state);
             wiringState.files.add(sourceFile);
@@ -90,6 +101,7 @@ export const createAddKeyedWiring = (config) => {
                 name: nameValue,
                 displayName: displayNameValue,
                 description: descriptionValue || undefined,
+                rotationPeriod: rotationPeriodValue || undefined,
                 [config.idField]: idValue,
                 schema: schemaLookupName,
                 sourceFile,

package/dist/add/add-workflow.js

@@ -182,7 +182,6 @@ export const addWorkflow = (logger, node, checker, state) => {
     let summary;
     let description;
     let errors;
-    let inline;
     let expose;
     if (ts.isObjectLiteralExpression(firstArg)) {
         const metadata = getCommonWireMetaData(firstArg, 'Workflow', workflowName, logger, checker);
@@ -192,10 +191,6 @@ export const addWorkflow = (logger, node, checker, state) => {
         summary = metadata.summary;
         description = metadata.description;
         errors = metadata.errors;
-        const inlineProp = getPropertyValue(firstArg, 'inline');
-        if (inlineProp === true) {
-            inline = true;
-        }
         expose = getPropertyValue(firstArg, 'expose');
     }
     // Validate that we got a valid function
@@ -279,7 +274,6 @@ export const addWorkflow = (logger, node, checker, state) => {
         description,
         errors,
         tags,
-        inline,
         expose,
     };
     // Workflow functions require platform services that aren't visible

package/dist/utils/custom-types-generator.js

@@ -7,6 +7,53 @@
 export function sanitizeTypeName(name) {
     return name.replace(/[^a-zA-Z0-9_$]/g, '_');
 }
+const CLASSIFICATION_WRAPPERS = new Set(['Private', 'Pii', 'Secret']);
+function findMatchingAngleBracket(type, startIndex) {
+    let depth = 0;
+    for (let i = startIndex; i < type.length; i += 1) {
+        const char = type[i];
+        if (char === '<') {
+            depth += 1;
+            continue;
+        }
+        if (char === '>' && (i === 0 || type[i - 1] !== '=')) {
+            depth -= 1;
+            if (depth === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+function stripClassificationWrappers(type) {
+    let output = '';
+    let index = 0;
+    while (index < type.length) {
+        const char = type[index];
+        if (!/[A-Za-z_$]/.test(char)) {
+            output += char;
+            index += 1;
+            continue;
+        }
+        let end = index + 1;
+        while (end < type.length && /[A-Za-z0-9_$]/.test(type[end])) {
+            end += 1;
+        }
+        const identifier = type.slice(index, end);
+        if (CLASSIFICATION_WRAPPERS.has(identifier) && type[end] === '<') {
+            const closingIndex = findMatchingAngleBracket(type, end);
+            if (closingIndex !== -1) {
+                const inner = type.slice(end + 1, closingIndex);
+                output += stripClassificationWrappers(inner);
+                index = closingIndex + 1;
+                continue;
+            }
+        }
+        output += identifier;
+        index = end;
+    }
+    return output;
+}
 export function generateCustomTypes(typesMap, requiredTypes) {
     const typeDeclarations = Array.from(typesMap.customTypes.entries())
         .sort(([a], [b]) => a.localeCompare(b))
@@ -17,11 +64,13 @@ export function generateCustomTypes(typesMap, requiredTypes) {
         .map(([originalName, { type, references }]) => {
         const name = sanitizeTypeName(originalName);
         references.forEach((refName) => {
-            if (refName !== '__object' && !refName.startsWith('__object_')) {
+            if (refName !== '__object' &&
+                !refName.startsWith('__object_') &&
+                !CLASSIFICATION_WRAPPERS.has(refName)) {
                 requiredTypes.add(refName);
             }
         });
-        const typeString = type;
+        const typeString = stripClassificationWrappers(type);
         const typeNameRegex = /\b[A-Z][a-zA-Z0-9]*\b/g;
         const potentialTypes = typeString.match(typeNameRegex) || [];
         potentialTypes.forEach((typeName) => {
@@ -46,12 +95,14 @@ export function generateCustomTypes(typesMap, requiredTypes) {
                 // Type not found in map (ambient/builtin type)
             }
         });
-        if (name === type)
+        if (name === typeString)
             return null;
-        return `export type ${name} = ${type}`;
+        return `export type ${name} = ${typeString}`;
     });
     const importsByPath = new Map();
     for (const typeName of requiredTypes) {
+        if (CLASSIFICATION_WRAPPERS.has(typeName))
+            continue;
         try {
             const typeMeta = typesMap.getTypeMeta(typeName);
             if (typeMeta.path) {

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

@@ -760,10 +760,15 @@ export function filterInspectorState(state, filters, logger) {
         }
         filteredState.requiredSchemas = prunedSchemas;
     }
-    // If any surviving function is a non-inline workflow step, the unit needs
-    // workflowService + queueService even though the function doesn't use them.
-    // Check the ORIGINAL graph meta (before filtering pruned it).
+    // Step dispatch is decided purely per-function: a workflow step runs via the
+    // queue only when its function opts out of inline execution (inline: false).
+    // Such a unit needs workflowService + queueService injected even though the
+    // function itself doesn't reference them. Check the ORIGINAL graph meta
+    // (before filtering pruned it).
     const survivingFuncIds = new Set(Object.keys(filteredState.functions.meta));
+    const resolveFuncId = (rpcName) => filteredState.rpc.internalMeta[rpcName] ??
+        filteredState.rpc.exposedMeta[rpcName] ??
+        rpcName;
     // Use the snapshot taken before filtering
     for (const graph of Object.values(originalGraphMeta)) {
         if (!graph.nodes)
@@ -772,11 +777,12 @@ export function filterInspectorState(state, filters, logger) {
             if (!('rpcName' in node) || !node.rpcName)
                 continue;
             const rpcName = node.rpcName;
-            if (!survivingFuncIds.has(rpcName))
+            const funcId = resolveFuncId(rpcName);
+            if (!survivingFuncIds.has(funcId) && !survivingFuncIds.has(rpcName))
                 continue;
-            const isInline = node.options?.async !== true &&
-                graph.inline === true;
-            if (!isInline) {
+            const funcMeta = (filteredState.functions.meta[funcId] ??
+                filteredState.functions.meta[rpcName]);
+            if (funcMeta?.inline === false) {
                 filteredState.serviceAggregation.requiredServices.add('workflowService');
                 filteredState.serviceAggregation.requiredServices.add('queueService');
             }

package/dist/utils/schema-generator.js

@@ -212,7 +212,9 @@ async function batchImportWithRegister(logger, sourceFiles) {
         return null;
     }
     finally {
-        await unregister?.();
+        void Promise.resolve(unregister?.()).catch((e) => {
+            logger.debug(`tsx unregister() failed: ${e.message}`);
+        });
     }
 }
 async function importWithRegister(sourceFile) {
@@ -221,7 +223,7 @@ async function importWithRegister(sourceFile) {
         return await import(sourceFile);
     }
     finally {
-        await unregister();
+        void Promise.resolve(unregister()).catch(() => { });
     }
 }
 function processZodSchema(schemaName, zodSchema, schemas, typesMap, auxiliaryTypeStore, printer, fakeSourceFile, logger) {

package/dist/utils/workflow/dsl/extract-dsl-workflow.js

@@ -1040,6 +1040,29 @@ function extractReturn(statement, context) {
     if (!statement.expression) {
         return null;
     }
+    if (ts.isAwaitExpression(statement.expression) &&
+        ts.isCallExpression(statement.expression.expression)) {
+        const call = statement.expression.expression;
+        if (isWorkflowDoCall(call, context.checker)) {
+            return isInlineDoCall(call)
+                ? extractInlineStep(call, context)
+                : extractRpcStep(call, context);
+        }
+        if (isWorkflowSleepCall(call, context.checker)) {
+            return extractSleepStep(call, context);
+        }
+    }
+    if (ts.isCallExpression(statement.expression)) {
+        const call = statement.expression;
+        if (isWorkflowDoCall(call, context.checker)) {
+            return isInlineDoCall(call)
+                ? extractInlineStep(call, context)
+                : extractRpcStep(call, context);
+        }
+        if (isWorkflowSleepCall(call, context.checker)) {
+            return extractSleepStep(call, context);
+        }
+    }
     if (!ts.isObjectLiteralExpression(statement.expression)) {
         return null;
     }

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

@@ -301,7 +301,6 @@ export function convertDslToGraph(workflowName, meta) {
         source,
         description: meta.description,
         tags: meta.tags,
-        inline: meta.inline,
         context: meta.context,
         nodes: nodesRecord,
         entryNodeIds,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.16",
+  "version": "0.12.18",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "type": "module",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
-    "@pikku/core": "^0.12.27",
+    "@pikku/core": "^0.12.30",
     "path-to-regexp": "^8.3.0",
     "ts-json-schema-generator": "^2.5.0",
     "tsx": "^4.21.0",

package/src/add/add-functions.test.ts

@@ -316,3 +316,55 @@ describe('addFunctions implementationHash', () => {
     }
   })
 })
+
+describe('pikkuChannelConnectionFunc generic mapping', () => {
+  // Regression: pikkuChannelConnectionFunc<Out> has a single generic that is the
+  // OUTPUT type (input is always void). The inspector must NOT record that generic
+  // as inputSchemaName — otherwise the empty WS handshake is validated against an
+  // input schema requiring the send-payload shape and the connect is rejected 403.
+  test('does not map the output generic to inputSchemaName', async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-channel-connect-'))
+    const file = join(rootDir, 'channel.ts')
+
+    await writeFile(
+      file,
+      [
+        'type Sessionless<In, Out> = (',
+        '  services: any,',
+        '  data: In,',
+        '  interaction: any',
+        ') => Promise<Out>',
+        'export const pikkuChannelConnectionFunc = <Out = unknown>(',
+        '  func: Sessionless<void, Out>',
+        ') => ({ func })',
+        'export const onCardsConnect = pikkuChannelConnectionFunc<{',
+        "  type: 'hello'",
+        '  count: number',
+        '}>(async (_services, _data, _interaction) => {})',
+      ].join('\n')
+    )
+
+    const logger: InspectorLogger = {
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+      critical: () => {},
+      hasCriticalErrors: () => false,
+    }
+
+    try {
+      const state = await inspect(logger, [file], { rootDir })
+      const meta = state.functions.meta['onCardsConnect']
+      assert.ok(meta, 'onCardsConnect meta should exist')
+      assert.strictEqual(
+        meta!.inputSchemaName,
+        null,
+        'connect input must be void (no input schema), not the output generic'
+      )
+      assert.deepStrictEqual(meta!.inputs, [])
+    } finally {
+      await rm(rootDir, { recursive: true, force: true })
+    }
+  })
+})

package/src/add/add-functions.ts

@@ -392,6 +392,7 @@ export const addFunctions: AddWiring = (
   let deploy: 'serverless' | 'server' | 'auto' | undefined
   let approvalRequired: boolean | undefined
   let approvalDescription: string | undefined
+  let inline: boolean | undefined
   let version: number | undefined
   let objectNode: ts.ObjectLiteralExpression | undefined
   let nodeDisplayName: string | null = null
@@ -487,6 +488,7 @@ export const addFunctions: AddWiring = (
     approvalRequired = getPropertyValue(firstArg, 'approvalRequired') as
       | boolean
       | undefined
+    inline = getPropertyValue(firstArg, 'inline') as boolean | undefined
 
     // Extract approvalDescription identifier reference
     for (const prop of firstArg.properties) {
@@ -669,6 +671,13 @@ export const addFunctions: AddWiring = (
     .map((tn) => checker.getTypeFromTypeNode(tn))
     .map((t) => unwrapPromise(checker, t))
 
+  // pikkuChannelConnectionFunc<Out> declares a single generic that is the
+  // OUTPUT type — its input is always void (PikkuFunctionSessionless<void, Out>).
+  // Every other wrapper reads generic[0] as INPUT, so without this guard the
+  // connect handler's output generic is mis-recorded as inputSchemaName and the
+  // empty WS handshake fails input validation at connect (1008/403).
+  const isChannelConnectionFunc = /ChannelConnection/i.test(expression.text)
+
   const capitalizedName = funcIdToTypeName(name)
 
   // --- Input Extraction ---
@@ -706,7 +715,12 @@ export const addFunctions: AddWiring = (
     } else {
       inputTypes = [filterType]
     }
-  } else if (!isListFunc && genericTypes.length >= 1 && genericTypes[0]) {
+  } else if (
+    !isChannelConnectionFunc &&
+    !isListFunc &&
+    genericTypes.length >= 1 &&
+    genericTypes[0]
+  ) {
     // Fall back to extracting from generic type arguments
     const result = getNamesAndTypes(
       checker,
@@ -1004,6 +1018,7 @@ export const addFunctions: AddWiring = (
     deploy: deploy || undefined,
     approvalRequired: approvalRequired || undefined,
     approvalDescription: approvalDescription || undefined,
+    inline: inline === false ? false : undefined,
     implementationHash,
     version,
     title,

package/src/add/add-keyed-wiring.ts

@@ -6,6 +6,7 @@ import {
 import type { AddWiring, InspectorState } from '../types.js'
 import { ErrorCode } from '../error-codes.js'
 import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js'
+import { parseDurationString } from '@pikku/core'
 
 export interface KeyedWiringConfig {
   functionName: string
@@ -52,6 +53,9 @@ export const createAddKeyedWiring = (config: KeyedWiringConfig): AddWiring => {
       const descriptionValue = getPropertyValue(obj, 'description') as
         | string
         | null
+      const rotationPeriodValue = getPropertyValue(obj, 'rotationPeriod') as
+        | string
+        | null
       const idValue = getPropertyValue(obj, config.idField) as string | null
 
       let schemaVariableName: string | null = null
@@ -123,6 +127,18 @@ export const createAddKeyedWiring = (config: KeyedWiringConfig): AddWiring => {
         return
       }
 
+      if (rotationPeriodValue) {
+        try {
+          parseDurationString(rotationPeriodValue)
+        } catch {
+          logger.critical(
+            ErrorCode.INVALID_VALUE,
+            `${config.label} '${nameValue}' has an invalid 'rotationPeriod': '${rotationPeriodValue}'. Use a duration like '1d', '30day', or '1w'.`
+          )
+          return
+        }
+      }
+
       const sourceFile = node.getSourceFile().fileName
 
       const wiringState = config.getState(state)
@@ -148,6 +164,7 @@ export const createAddKeyedWiring = (config: KeyedWiringConfig): AddWiring => {
         name: nameValue,
         displayName: displayNameValue,
         description: descriptionValue || undefined,
+        rotationPeriod: rotationPeriodValue || undefined,
         [config.idField]: idValue,
         schema: schemaLookupName,
         sourceFile,

package/src/add/add-workflow.ts

@@ -209,7 +209,6 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
   let summary: string | undefined
   let description: string | undefined
   let errors: string[] | undefined
-  let inline: boolean | undefined
   let expose: boolean | undefined
 
   if (ts.isObjectLiteralExpression(firstArg)) {
@@ -226,11 +225,6 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
     description = metadata.description
     errors = metadata.errors
 
-    const inlineProp = getPropertyValue(firstArg, 'inline')
-    if (inlineProp === true) {
-      inline = true
-    }
-
     expose = getPropertyValue(firstArg, 'expose') as boolean | undefined
   }
 
@@ -337,7 +331,6 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
     description,
     errors,
     tags,
-    inline,
     expose,
   }
 

package/src/utils/custom-types-generator.test.ts

@@ -0,0 +1,99 @@
+import { test, describe } from 'node:test'
+import { strict as assert } from 'node:assert'
+import { generateCustomTypes } from './custom-types-generator.js'
+import { TypesMap } from '../types-map.js'
+
+function makeTypesMap(
+  entries: Record<string, { type: string; references: string[] }>
+): TypesMap {
+  const tm = new TypesMap()
+  for (const [name, { type, references }] of Object.entries(entries)) {
+    tm.addCustomType(name, type, references)
+  }
+  return tm
+}
+
+describe('generateCustomTypes — classification wrapper stripping', () => {
+  test('strips Private<T> wrapper from type alias', () => {
+    const tm = makeTypesMap({
+      UserEmail: { type: 'Private<string>', references: ['Private'] },
+    })
+    const result = generateCustomTypes(tm, new Set())
+    assert.match(result, /UserEmail/, 'should emit UserEmail alias')
+    assert.match(
+      result,
+      /= string/,
+      'Private<string> should be stripped to string'
+    )
+    assert.doesNotMatch(result, /Private/, 'Private wrapper must be removed')
+  })
+
+  test('strips Secret<T> wrapper from type alias', () => {
+    const tm = makeTypesMap({
+      HashedPw: { type: 'Secret<string>', references: ['Secret'] },
+    })
+    const result = generateCustomTypes(tm, new Set())
+    assert.match(result, /HashedPw/)
+    assert.match(
+      result,
+      /= string/,
+      'Secret<string> should be stripped to string'
+    )
+    assert.doesNotMatch(result, /Secret/, 'Secret wrapper must be removed')
+  })
+
+  test('strips Pii<T> wrapper from type alias', () => {
+    const tm = makeTypesMap({
+      UserPhone: { type: 'Pii<string>', references: ['Pii'] },
+    })
+    const result = generateCustomTypes(tm, new Set())
+    assert.match(result, /UserPhone/)
+    assert.match(result, /= string/, 'Pii<string> should be stripped to string')
+    assert.doesNotMatch(result, /Pii/, 'Pii wrapper must be removed')
+  })
+
+  test('strips nested classification wrappers', () => {
+    const tm = makeTypesMap({
+      Combo: {
+        type: 'Private<Secret<string>>',
+        references: ['Private', 'Secret'],
+      },
+    })
+    const result = generateCustomTypes(tm, new Set())
+    assert.match(result, /Combo/)
+    assert.match(
+      result,
+      /= string/,
+      'nested wrappers should resolve to inner type'
+    )
+    assert.doesNotMatch(
+      result,
+      /Private|Secret/,
+      'all wrappers must be removed'
+    )
+  })
+
+  test('does not strip non-classification type names', () => {
+    const tm = makeTypesMap({
+      MyType: { type: 'SomeOtherType', references: ['SomeOtherType'] },
+    })
+    const required = new Set<string>()
+    generateCustomTypes(tm, required)
+    assert.ok(
+      required.has('SomeOtherType'),
+      'non-classification references must remain in requiredTypes'
+    )
+  })
+
+  test('classification wrapper references are not added to requiredTypes', () => {
+    const tm = makeTypesMap({
+      SensitiveField: { type: 'Private<string>', references: ['Private'] },
+    })
+    const required = new Set<string>()
+    generateCustomTypes(tm, required)
+    assert.ok(
+      !required.has('Private'),
+      'Private must not be added to requiredTypes'
+    )
+  })
+})