ts-procedures 8.6.0 → 9.0.0

package/src/schema/compute-schema.test.ts

@@ -1,16 +1,28 @@
-import { describe, it, expect } from 'vitest'
+import { describe, expect, it } from 'vitest'
 import { Type } from 'typebox'
-import { v } from 'suretype'
 import { computeSchema } from './compute-schema.js'
-import { ProcedureRegistrationError } from '../errors.js'
+import { createValidatorCompiler } from './compile.js'
+import { typeboxAdapter } from './typebox.js'
+import { ProcedureRegistrationError } from '../core/errors.js'
+
+const options = {
+  adapters: [typeboxAdapter],
+  compile: createValidatorCompiler(),
+}
 
 describe('computeSchema', () => {
   it('should return empty schema and validations when no schema provided', () => {
-    const result = computeSchema('test-procedure')
+    const result = computeSchema('test-procedure', undefined, options)
 
     expect(result).toEqual({
-      jsonSchema: { params: undefined, returnType: undefined },
-      validations: {}
+      jsonSchema: {
+        params: undefined,
+        returnType: undefined,
+        yieldType: undefined,
+        req: undefined,
+        res: undefined,
+      },
+      validations: {},
     })
   })
 
@@ -19,11 +31,11 @@ describe('computeSchema', () => {
       const schema = {
         params: Type.Object({
           name: Type.String(),
-          age: Type.Number()
-        })
+          age: Type.Number(),
+        }),
       }
 
-      const result = computeSchema('test-procedure', schema)
+      const result = computeSchema('test-procedure', schema, options)
 
       expect(result.jsonSchema.params).toBeDefined()
       expect(result.validations.params).toBeDefined()
@@ -33,45 +45,154 @@ describe('computeSchema', () => {
       expect(result.validations.params?.(validInput).errors).toBeUndefined()
 
       // Test invalid input
-      const invalidInput = { name: 123, age: 'invalid' }
+      const invalidInput = { name: { nested: true }, age: 'invalid' }
       expect(result.validations.params?.(invalidInput).errors).toBeDefined()
+      // allErrors: both failing fields reported
+      expect(result.validations.params?.(invalidInput).errors?.length).toEqual(2)
+    })
+
+    it('extracts params json-schema equal to the TypeBox schema (identity)', () => {
+      const params = Type.Object({ name: Type.String(), age: Type.Number() })
+      const result = computeSchema('test-procedure', { params }, options)
+
+      expect(result.jsonSchema.params).toEqual(params)
     })
 
-    it('should correctly process returnType schema', () => {
+    it('should correctly process returnType schema (documentation only, never validated)', () => {
       const schema = {
         returnType: Type.Object({
-          result: Type.Boolean()
-        })
+          result: Type.Boolean(),
+        }),
       }
 
-      const result = computeSchema('test-procedure', schema)
+      const result = computeSchema('test-procedure', schema, options)
 
       expect(result.jsonSchema.returnType).toBeDefined()
       expect(result.validations.params).toBeUndefined()
+      expect(result.validations).toEqual({})
+    })
+
+    it('should compile a validator for yieldType', () => {
+      const schema = {
+        yieldType: Type.Object({ chunk: Type.String() }),
+      }
+
+      const result = computeSchema('test-procedure', schema, options)
+
+      expect(result.jsonSchema.yieldType).toBeDefined()
+      expect(result.validations.yield).toBeDefined()
+      expect(result.validations.yield?.({ chunk: 'hello' }).errors).toBeUndefined()
+      expect(result.validations.yield?.({}).errors).toBeDefined()
     })
   })
 
-  describe('with Suretype schema', () => {
-    it('should correctly process params schema', () => {
+  describe('req channels (HTTP input)', () => {
+    it('extracts and validates each req channel independently', () => {
       const schema = {
-        params: v.object({
-          name: v.string(),
-          age: v.number()
-        })
+        req: {
+          pathParams: Type.Object({ id: Type.String() }),
+          query: Type.Object({ limit: Type.Number() }),
+          body: Type.Object({ name: Type.String() }),
+          headers: Type.Object({ 'x-api-key': Type.String() }),
+        },
       }
 
-      const result = computeSchema('test-procedure', schema)
+      const result = computeSchema('test-procedure', schema, options)
 
-      expect(result.jsonSchema.params).toBeDefined()
-      expect(result.validations.params).toBeDefined()
+      for (const channel of ['pathParams', 'query', 'body', 'headers']) {
+        expect(result.jsonSchema.req?.[channel]).toBeDefined()
+        expect(result.validations.req?.[channel]).toBeDefined()
+      }
 
-      // Test validation function
-      const validInput = { name: 'John', age: 30 }
-      expect(result.validations.params?.(validInput).errors).toBeUndefined()
+      expect(result.validations.req!.pathParams!({ id: 'abc' }).errors).toBeUndefined()
+      expect(result.validations.req!.pathParams!({}).errors).toBeDefined()
 
-      // Test invalid input
-      const invalidInput = { name: 123, age: 'invalid' }
-      expect(result.validations.params?.(invalidInput).errors).toBeDefined()
+      // coerceTypes applies per channel (query strings become numbers)
+      expect(result.validations.req!.query!({ limit: '10' }).errors).toBeUndefined()
+      expect(result.validations.req!.body!({ name: 42 }).errors).toBeUndefined() // coerced to '42'
+      expect(result.validations.req!.body!({}).errors).toBeDefined()
+    })
+
+    it('skips undefined req channel values', () => {
+      const schema = {
+        req: {
+          body: Type.Object({ name: Type.String() }),
+          query: undefined,
+        },
+      }
+
+      const result = computeSchema('test-procedure', schema, options)
+
+      expect(result.jsonSchema.req?.body).toBeDefined()
+      expect(result.jsonSchema.req && 'query' in result.jsonSchema.req).toBe(false)
+      expect(result.validations.req?.query).toBeUndefined()
+    })
+  })
+
+  describe('res channels (HTTP output, documentation only)', () => {
+    it('extracts res.body and res.headers without compiling validators', () => {
+      const schema = {
+        res: {
+          body: Type.Object({ id: Type.String() }),
+          headers: Type.Object({ 'x-rate-limit': Type.String() }),
+        },
+      }
+
+      const result = computeSchema('test-procedure', schema, options)
+
+      expect(result.jsonSchema.res?.body).toBeDefined()
+      expect(result.jsonSchema.res?.headers).toBeDefined()
+      expect(result.validations).toEqual({})
+    })
+
+    it('extracts only the res channels provided', () => {
+      const result = computeSchema(
+        'test-procedure',
+        { res: { body: Type.Object({ ok: Type.Boolean() }) } },
+        options,
+      )
+
+      expect(result.jsonSchema.res?.body).toBeDefined()
+      expect(result.jsonSchema.res?.headers).toBeUndefined()
+    })
+  })
+
+  describe('guards', () => {
+    it('throws ProcedureRegistrationError when schema.params and schema.req are both defined', () => {
+      const schema = {
+        params: Type.Object({ a: Type.String() }),
+        req: { body: Type.Object({ b: Type.String() }) },
+      }
+
+      expect(() => computeSchema('test-procedure', schema, options)).toThrow(
+        ProcedureRegistrationError,
+      )
+      expect(() => computeSchema('test-procedure', schema, options)).toThrow(
+        /schema\.params and schema\.req are mutually exclusive for procedure "test-procedure"/,
+      )
+    })
+
+    it('throws a migration error when the removed schema.input is used', () => {
+      const schema = {
+        input: { body: Type.Object({ b: Type.String() }) },
+      } as Parameters<typeof computeSchema>[1]
+
+      expect(() => computeSchema('test-procedure', schema, options)).toThrow(
+        ProcedureRegistrationError,
+      )
+      expect(() => computeSchema('test-procedure', schema, options)).toThrow(
+        /schema\.input was removed in v8\. Use CreateHttp \/ CreateHttpStream/,
+      )
+    })
+
+    it('does not trip the schema.input guard when input is explicitly undefined', () => {
+      const schema = {
+        input: undefined,
+        params: Type.Object({ a: Type.String() }),
+      }
+
+      const result = computeSchema('test-procedure', schema, options)
+      expect(result.jsonSchema.params).toBeDefined()
     })
   })
 
@@ -79,42 +200,73 @@ describe('computeSchema', () => {
     it('should throw ProcedureRegistrationError for invalid schema', () => {
       const invalidSchema = {
         params: {
-          type: 'invalid-schema-type'
-        }
+          type: 'invalid-schema-type',
+        },
       }
 
-      expect(() => computeSchema('test-procedure', invalidSchema))
-        .toThrow(ProcedureRegistrationError)
+      expect(() => computeSchema('test-procedure', invalidSchema, options)).toThrow(
+        ProcedureRegistrationError,
+      )
     })
 
-    it('should include procedure name in error message', () => {
+    it('should include procedure name and channel in the error message', () => {
       const invalidSchema = {
         params: {
-          type: 'invalid-schema-type'
-        }
+          type: 'invalid-schema-type',
+        },
       }
 
       try {
-        computeSchema('test-procedure', invalidSchema)
+        computeSchema('test-procedure', invalidSchema, options)
+        expect.unreachable('computeSchema should have thrown')
       } catch (error: any) {
         expect(error instanceof ProcedureRegistrationError).toBe(true)
         expect(error.message).toContain('test-procedure')
+        expect(error.message).toMatch(/Error parsing schema for test-procedure - schema\.params/)
+        expect(error.message).toMatch(/Error extracting json schema schema\.params/)
+        // The error names the registered adapters so the dev knows what was tried
+        expect(error.message).toContain('typebox')
       }
     })
+
+    it('throws a meaningful error for an unrecognized returnType', () => {
+      expect(() =>
+        computeSchema('test-procedure', { returnType: 'string value' as any }, options),
+      ).toThrow(/Error extracting json schema schema\.returnType/)
+    })
+
+    it('throws a meaningful error naming the failing req channel', () => {
+      expect(() =>
+        computeSchema(
+          'test-procedure',
+          { req: { query: { not: 'a schema' } } },
+          options,
+        ),
+      ).toThrow(/Error extracting json schema schema\.req\.query/)
+    })
+
+    it('throws a compile error when the schema is recognized but invalid JSON Schema', () => {
+      // Looks like a TypeBox schema (has ~kind) but AJV rejects it at compile time
+      const recognizedButInvalid = { '~kind': 'Object', type: 'not-a-real-type' }
+
+      expect(() =>
+        computeSchema('test-procedure', { params: recognizedButInvalid }, options),
+      ).toThrow(/Error compiling schema\.params for validator/)
+    })
   })
 
   describe('combined schemas', () => {
     it('should handle both params and returnType schemas', () => {
       const schema = {
         params: Type.Object({
-          input: Type.String()
+          input: Type.String(),
         }),
         returnType: Type.Object({
-          output: Type.Boolean()
-        })
+          output: Type.Boolean(),
+        }),
       }
 
-      const result = computeSchema('test-procedure', schema)
+      const result = computeSchema('test-procedure', schema, options)
 
       expect(result.jsonSchema.params).toBeDefined()
       expect(result.jsonSchema.returnType).toBeDefined()
@@ -124,5 +276,34 @@ describe('computeSchema', () => {
       const validInput = { input: 'test' }
       expect(result.validations.params?.(validInput).errors).toBeUndefined()
     })
+
+    it('compiles independent validators for separate computeSchema calls', () => {
+      const first = computeSchema(
+        'first',
+        {
+          params: Type.Object({ a: Type.String() }),
+          returnType: Type.Object({ b: Type.Null() }),
+        },
+        options,
+      )
+
+      const second = computeSchema(
+        'second',
+        {
+          params: Type.Object({ c: Type.String() }),
+          returnType: Type.Object({ d: Type.Number() }),
+        },
+        options,
+      )
+
+      expect(first.validations.params?.({}).errors?.[0]?.message).toMatch(
+        /must have required property 'a'/,
+      )
+      expect(second.validations.params?.({ c: 'test' })).toMatchObject({})
+      // first's validator is unaffected by second's compilation
+      expect(first.validations.params?.({}).errors?.[0]?.message).toMatch(
+        /must have required property 'a'/,
+      )
+    })
   })
 })

package/src/schema/compute-schema.ts

@@ -1,103 +1,177 @@
-import type { TSchemaValidationError } from './parser.js';
-import { schemaParser } from './parser.js'
-import { ProcedureRegistrationError } from '../errors.js'
-import type { TJSONSchema } from './types.js'
-import type { DefinitionInfo } from '../stack-utils.js'
+import { ProcedureRegistrationError } from '../core/errors.js'
+import type { DefinitionInfo } from '../core/definition-site.js'
+import { extractJsonSchema } from './adapter.js'
+import type { SchemaAdapter } from './adapter.js'
+import type { TJSONSchema } from './json-schema.js'
+import type { TSchemaValidationError, Validate, ValidatorCompiler } from './compile.js'
+
+export type ComputedJsonSchema = {
+  params?: TJSONSchema
+  returnType?: TJSONSchema
+  yieldType?: TJSONSchema
+  req?: Record<string, TJSONSchema>
+  res?: { body?: TJSONSchema; headers?: TJSONSchema }
+}
+
+export type ComputedValidations = {
+  params?: Validate
+  yield?: Validate
+  req?: Record<string, Validate>
+}
+
+export type ComputedSchema = {
+  jsonSchema: ComputedJsonSchema
+  validations: ComputedValidations
+}
+
+export type ComputeSchemaInput = {
+  params?: unknown
+  returnType?: unknown
+  yieldType?: unknown
+  req?: Record<string, unknown>
+  res?: { body?: unknown; headers?: unknown }
+}
+
+type ComputeContext = {
+  name: string
+  adapters: readonly SchemaAdapter[]
+  compile: ValidatorCompiler
+  definitionInfo?: DefinitionInfo
+}
+
+function fail(ctx: ComputeContext, channel: string, detail: string): never {
+  throw new ProcedureRegistrationError(
+    ctx.name,
+    `Error parsing schema for ${ctx.name} - ${channel}: ${detail}`,
+    ctx.definitionInfo,
+  )
+}
 
 /**
- * This function is used to compute the JSON schema and validation functions
- * for a given schema.
+ * Extracts JSON Schema for one channel via the adapter chain. Throws a
+ * `ProcedureRegistrationError` naming the channel when no adapter recognizes
+ * the value or the adapter itself throws.
+ */
+function extractChannel(ctx: ComputeContext, channel: string, raw: unknown): TJSONSchema {
+  let extracted: TJSONSchema | undefined
+  try {
+    extracted = extractJsonSchema(raw, ctx.adapters)
+  } catch (e: any) {
+    fail(ctx, channel, `Error extracting json schema ${channel} - ${e.message}`)
+  }
+  if (!extracted) {
+    const known = ctx.adapters.map((a) => a.name).join(', ')
+    fail(
+      ctx,
+      channel,
+      `Error extracting json schema ${channel} - it might be empty or not recognized by any schema adapter (registered: ${known})`,
+    )
+  }
+  return extracted
+}
+
+/** Extracts and compiles one validated channel. */
+function compileChannel(ctx: ComputeContext, channel: string, raw: unknown): { jsonSchema: TJSONSchema; validate: Validate } {
+  const jsonSchema = extractChannel(ctx, channel, raw)
+  try {
+    return { jsonSchema, validate: ctx.compile(jsonSchema) }
+  } catch (e: any) {
+    fail(ctx, channel, `Error compiling ${channel} for validator - ${e.message}`)
+  }
+}
+
+/**
+ * Computes JSON Schema and validators for a procedure's schema config.
+ *
+ * Channels:
+ * - `params` (RPC input) — validated
+ * - `yieldType` (stream output) — validated only when `validateYields: true`
+ * - `returnType` — documentation/codegen only, never validated
+ * - `req.{pathParams,query,body,headers}` (HTTP input) — each independently validated
+ * - `res.{body,headers}` (HTTP output) — documentation/codegen only
  *
- * @param name The name of the procedure
- * @param schema Procedure schema
- * @param definitionInfo Optional definition info for error reporting
+ * Guards:
+ * - `schema.params` and `schema.req` are mutually exclusive (RPC vs HTTP)
+ * - `schema.input` (removed in v8) gets a migration error
  */
-export function computeSchema<TParamsSchemaType, TReturnTypeSchemaType, TYieldTypeSchemaType = unknown>(
+export function computeSchema(
   name: string,
-  schema?: {
-    params?: TParamsSchemaType
-    returnType?: TReturnTypeSchemaType
-    yieldType?: TYieldTypeSchemaType
-    req?: Record<string, unknown>
-    res?: { body?: unknown; headers?: unknown }
+  schema: ComputeSchemaInput | undefined,
+  options: {
+    adapters: readonly SchemaAdapter[]
+    compile: ValidatorCompiler
+    definitionInfo?: DefinitionInfo
   },
-  // Used for error stack trace details
-  definitionInfo?: DefinitionInfo
-): {
-  jsonSchema: {
-    params?: TJSONSchema
-    returnType?: TJSONSchema
-    yieldType?: TJSONSchema
-    req?: Record<string, TJSONSchema>
-    res?: { body?: TJSONSchema; headers?: TJSONSchema }
-  }
-  validations: {
-    params?: (params?: any) => { errors?: TSchemaValidationError[] }
-    yield?: (value?: any) => { errors?: TSchemaValidationError[] }
-    req?: Record<string, (value?: any) => { errors?: TSchemaValidationError[] }>
-  }
-} {
-  const jsonSchema: {
-    params?: TJSONSchema
-    returnType?: TJSONSchema
-    yieldType?: TJSONSchema
-    req?: Record<string, TJSONSchema>
-    res?: { body?: TJSONSchema; headers?: TJSONSchema }
-  } = {
+): ComputedSchema {
+  const jsonSchema: ComputedJsonSchema = {
     params: undefined,
     returnType: undefined,
     yieldType: undefined,
     req: undefined,
     res: undefined,
   }
+  const validations: ComputedValidations = {}
+
+  if (!schema) return { jsonSchema, validations }
 
-  const validations: {
-    params?: (params?: any) => { errors?: TSchemaValidationError[] }
-    yield?: (value?: any) => { errors?: TSchemaValidationError[] }
-    req?: Record<string, (value?: any) => { errors?: TSchemaValidationError[] }>
-  } = {}
+  const ctx: ComputeContext = { name, ...options }
 
   // Migration guard: schema.input was removed in v8
-  if (schema && 'input' in schema && (schema as any).input !== undefined) {
+  if ('input' in schema && (schema as { input?: unknown }).input !== undefined) {
     throw new ProcedureRegistrationError(
       name,
       `schema.input was removed in v8. Use CreateHttp / CreateHttpStream for per-channel HTTP validation. Procedure: "${name}".`,
-      definitionInfo,
+      options.definitionInfo,
     )
   }
 
   // Mutual exclusivity: params and req cannot both be defined
-  if (schema?.params && schema?.req) {
+  if (schema.params && schema.req) {
     throw new ProcedureRegistrationError(
       name,
       `schema.params and schema.req are mutually exclusive for procedure "${name}". Use schema.params for RPC procedures or schema.req for HTTP procedures.`,
-      definitionInfo
+      options.definitionInfo,
     )
   }
 
-  if (schema) {
-    const {
-      jsonSchema: { params, returnType, yieldType, req, res },
-      validation,
-    } = schemaParser(schema, (errors) => {
-      throw new ProcedureRegistrationError(
-        name,
-        `Error parsing schema for ${name} - ${Object.entries(errors)
-          .map(([key, error]) => `${key}: ${error}`)
-          .join(', ')}`,
-        definitionInfo
-      )
-    })
-
-    jsonSchema.params = params
-    jsonSchema.returnType = returnType
-    jsonSchema.yieldType = yieldType
-    jsonSchema.req = req
-    jsonSchema.res = res
-    validations.params = validation.params
-    validations.yield = validation.yield
-    validations.req = validation.req
+  if (schema.params) {
+    const { jsonSchema: extracted, validate } = compileChannel(ctx, 'schema.params', schema.params)
+    jsonSchema.params = extracted
+    validations.params = validate
+  }
+
+  if (schema.returnType) {
+    jsonSchema.returnType = extractChannel(ctx, 'schema.returnType', schema.returnType)
+  }
+
+  if (schema.yieldType) {
+    const { jsonSchema: extracted, validate } = compileChannel(ctx, 'schema.yieldType', schema.yieldType)
+    jsonSchema.yieldType = extracted
+    validations.yield = validate
+  }
+
+  if (schema.req) {
+    jsonSchema.req = {}
+    validations.req = {}
+    for (const [channelName, channelSchema] of Object.entries(schema.req)) {
+      if (!channelSchema) continue
+      const { jsonSchema: extracted, validate } = compileChannel(ctx, `schema.req.${channelName}`, channelSchema)
+      jsonSchema.req[channelName] = extracted
+      validations.req[channelName] = validate
+    }
+  }
+
+  if (schema.res) {
+    jsonSchema.res = {}
+    if (schema.res.body) {
+      jsonSchema.res.body = extractChannel(ctx, 'schema.res.body', schema.res.body)
+    }
+    if (schema.res.headers) {
+      jsonSchema.res.headers = extractChannel(ctx, 'schema.res.headers', schema.res.headers)
+    }
   }
 
   return { jsonSchema, validations }
 }
+
+export type { TSchemaValidationError }

package/src/schema/json-schema.ts

@@ -0,0 +1,21 @@
+import type { Static, TSchema } from 'typebox'
+
+/** A plain JSON Schema object (the lingua franca of the whole library). */
+export type TJSONSchema = Record<string, any>
+
+/** Flattens an intersection type for readable IDE hovers. */
+export type Prettify<TObject> = {
+  [Key in keyof TObject]: TObject[Key]
+} & {}
+
+/**
+ * Infers the static TypeScript type from a schema-library value.
+ *
+ * TypeBox is the built-in schema library; a custom {@link SchemaAdapter} can
+ * make other libraries work at runtime, but compile-time inference is only
+ * provided for TypeBox (other schemas infer as `unknown`).
+ */
+export type Infer<SchemaType> = SchemaType extends TSchema ? Static<SchemaType> : unknown
+
+/** v8-compatible alias for {@link Infer}. */
+export type TSchemaLib<SchemaType> = Infer<SchemaType>

package/src/schema/typebox.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from 'vitest'
+import { Type } from 'typebox'
+import { isTypeboxSchema, typeboxAdapter } from './typebox.js'
+
+describe('typebox schema detection', () => {
+  const typebox = Type.Object({ name: Type.String() })
+
+  test('it recognizes TypeBox schema', () => {
+    expect(isTypeboxSchema(typebox)).toBe(true)
+  })
+
+  test('it rejects non-TypeBox values', () => {
+    expect(isTypeboxSchema({ type: 'object' })).toBe(false)
+    expect(isTypeboxSchema('string value')).toBe(false)
+    expect(isTypeboxSchema(123)).toBe(false)
+    expect(isTypeboxSchema(null)).toBe(false)
+    expect(isTypeboxSchema(undefined)).toBe(false)
+  })
+
+  test('it recognizes legacy @sinclair/typebox schemas (Symbol.for kind)', () => {
+    const legacy = { [Symbol.for('TypeBox.Kind')]: 'Object', type: 'object' }
+    expect(isTypeboxSchema(legacy)).toBe(true)
+  })
+
+  describe('typeboxAdapter', () => {
+    test('it exposes the adapter name used in registration errors', () => {
+      expect(typeboxAdapter.name).toBe('typebox')
+    })
+
+    test('detect matches isTypeboxSchema', () => {
+      expect(typeboxAdapter.detect(typebox)).toBe(true)
+      expect(typeboxAdapter.detect({ type: 'object' })).toBe(false)
+      expect(typeboxAdapter.detect(null)).toBe(false)
+    })
+
+    test('toJsonSchema is the identity (TypeBox schemas ARE JSON Schema)', () => {
+      expect(typeboxAdapter.toJsonSchema(typebox)).toBe(typebox)
+    })
+  })
+})

package/src/schema/typebox.ts

@@ -0,0 +1,27 @@
+import type { SchemaAdapter } from './adapter.js'
+import type { TJSONSchema } from './json-schema.js'
+
+const TYPEBOX_KIND = Symbol.for('TypeBox.Kind')
+
+/**
+ * Built-in adapter for TypeBox (`import { Type } from 'typebox'`).
+ *
+ * Detection covers both typebox v1 (`~kind` property) and legacy
+ * `@sinclair/typebox` 0.3x (`Symbol.for('TypeBox.Kind')`). TypeBox schemas
+ * already ARE JSON Schema, so conversion is the identity.
+ */
+export const typeboxAdapter: SchemaAdapter = {
+  name: 'typebox',
+  detect(schema: unknown): boolean {
+    if (typeof schema !== 'object' || schema === null) return false
+    return '~kind' in schema || TYPEBOX_KIND in schema
+  },
+  toJsonSchema(schema: unknown): TJSONSchema {
+    return schema as TJSONSchema
+  },
+}
+
+/** v8-compatible helper: is this value a TypeBox schema? */
+export function isTypeboxSchema(schema: unknown): boolean {
+  return typeboxAdapter.detect(schema)
+}