@vertesia/common 1.6.0-dev.20260923.085325Z → 1.6.0-dev.20261008.064737Z

package/src/api-schemas/response-pruning.test.ts

@@ -1,260 +0,0 @@
-import { Ajv2020 } from 'ajv/dist/2020.js';
-import { describe, expect, it } from 'vitest';
-import { AccountType, BillingMethod } from '../user.js';
-import { findUnprunablePaths, type JsonObject, pruneToSchema, toOpenApiComponents } from './adapter.js';
-import {
-    type ApiComponentType,
-    ApiSchemaComponents,
-    apiComponentRef,
-    pruneAndValidateApiResponse,
-    pruneApiResponse,
-} from './registry.js';
-
-function compile(name: string) {
-    const ajv = new Ajv2020({ strictSchema: false, allErrors: true });
-    ajv.addSchema({ $id: 'vertesia://openapi', components: { schemas: ApiSchemaComponents } });
-    return ajv.compile({ $ref: `vertesia://openapi${apiComponentRef(name as never)}` });
-}
-
-const ACCOUNT: ApiComponentType<'Account'> = {
-    id: 'acc_1',
-    name: 'Acme',
-    email_domains: ['acme.com'],
-    onboarding: { completed: true, completed_at: '2026-07-29T10:00:00.000Z' },
-    datacenter: 'gcp',
-    account_type: AccountType.customer,
-    billing: { method: BillingMethod.stripe, stripe_customer_id: 'cus_1' },
-    feature_flags: { new_editor: true, beta_agents: 'on' },
-    created_by: 'u1',
-    updated_by: 'u1',
-    created_at: '2026-07-29T10:00:00.000Z',
-    updated_at: '2026-07-29T10:00:00.000Z',
-};
-
-/**
- * An Account carrying extra runtime fields — what a Mongo document actually is. The cast models
- * the gap the pruner exists to close: the value is typed as the component, but at runtime it has
- * more than the component declares.
- */
-const withExtras = (extra: Record<string, unknown>): ApiComponentType<'Account'> =>
-    ({ ...ACCOUNT, ...extra }) as ApiComponentType<'Account'>;
-
-describe('response pruning narrows payloads to the published contract', () => {
-    it('drops undeclared top-level fields', () => {
-        const pruned = pruneApiResponse(
-            'Account',
-            withExtras({ __v: 3, internal_notes: 'do not ship', stripe_secret: 'sk_live_leak' }),
-        );
-        expect(pruned).toEqual(ACCOUNT);
-        expect('stripe_secret' in pruned).toBe(false);
-    });
-
-    it('drops undeclared fields nested inside a declared object', () => {
-        const pruned = pruneApiResponse(
-            'Account',
-            withExtras({
-                onboarding: { ...ACCOUNT.onboarding, internal_step: 7 },
-                billing: { ...ACCOUNT.billing, stripe_secret_key: 'sk_live_leak' },
-            }),
-        );
-        expect(pruned.onboarding).toEqual(ACCOUNT.onboarding);
-        expect(pruned.billing).toEqual(ACCOUNT.billing);
-    });
-
-    it('PRESERVES the contents of freeform maps', () => {
-        // The regression this design exists to avoid: AJV's removeAdditional:'all' strips keys
-        // from objects that declare additionalProperties too, which is how launch_workstream's
-        // `data` was emptied. `feature_flags` is `{additionalProperties:{}}` with no `properties`,
-        // so every operator flag would vanish under a blanket removal mode.
-        const pruned = pruneApiResponse('Account', ACCOUNT);
-        expect(pruned.feature_flags).toEqual({ new_editor: true, beta_agents: 'on' });
-    });
-
-    it('leaves a conforming payload byte-identical', () => {
-        expect(pruneApiResponse('Account', ACCOUNT)).toEqual(ACCOUNT);
-    });
-
-    it('never mutates the payload it is given', () => {
-        const input = withExtras({ rogue: 1 });
-        const pristine = structuredClone(input);
-        pruneApiResponse('Account', input);
-        expect(input).toEqual(pristine);
-    });
-
-    it('produces output that validates against the published schema', () => {
-        const validate = compile('Account');
-        const pruned = pruneApiResponse('Account', withExtras({ leaked: 'x' }));
-        expect(validate(pruned)).toBe(true);
-    });
-
-    it('does not throw on a payload that is missing required fields', () => {
-        // Pruning is not validation. A malformed document still reaches the client rather than
-        // becoming a 500 — surfacing drift is the validator's job, not the pruner's.
-        const malformed = { id: 'acc_1', junk: true } as unknown as ApiComponentType<'Account'>;
-        expect(() => pruneApiResponse('Account', malformed)).not.toThrow();
-        expect(pruneApiResponse('Account', malformed)).toEqual({ id: 'acc_1' });
-    });
-});
-
-describe('pruneAndValidateApiResponse is the sound entry point for untyped payloads', () => {
-    it('returns the component type only on the valid branch', () => {
-        const result = pruneAndValidateApiResponse('Account', withExtras({ leaked: 'x' }));
-        expect(result.valid).toBe(true);
-        if (result.valid) {
-            // Reachable as the component type only after validation succeeded.
-            const id: string = result.data.id;
-            expect(id).toBe('acc_1');
-            expect('leaked' in result.data).toBe(false);
-        }
-    });
-
-    it('reports errors instead of typing an incomplete payload as complete', () => {
-        // The unsoundness this replaces: narrowing `{id}` and handing it back as a full Account.
-        const result = pruneAndValidateApiResponse('Account', { id: 'acc_1', junk: true });
-        expect(result.valid).toBe(false);
-        if (!result.valid) {
-            expect(result.errors.join(' ')).toContain("must have required property 'name'");
-            // The pruned value is still available, so the caller chooses ship-and-log or fail.
-            expect(result.data).toEqual({ id: 'acc_1' });
-        }
-    });
-
-    it('flags a legacy account missing created_by/updated_by', () => {
-        // Real migration hazard: the Mongo schema declares these without `required`, and the
-        // BackfillAccountCreatedBy migration skips ownerless accounts by design.
-        const { created_by: _c, updated_by: _u, ...legacy } = ACCOUNT;
-        const result = pruneAndValidateApiResponse('Account', legacy);
-        expect(result.valid).toBe(false);
-        if (!result.valid) {
-            expect(result.errors.join(' ')).toContain('created_by');
-            expect(result.errors.join(' ')).toContain('updated_by');
-        }
-    });
-});
-
-describe('response pruning through structural schema features', () => {
-    it('follows the discriminator to the matching union branch', () => {
-        const enabled = pruneApiResponse('StripeBillingStatusResponse', {
-            status: 'enabled',
-            billing_method: 'stripe',
-            portal_url: 'https://billing',
-            internal_session_id: 'leak',
-        } as never);
-        expect(enabled).toEqual({ status: 'enabled', billing_method: 'stripe', portal_url: 'https://billing' });
-
-        const disabled = pruneApiResponse('StripeBillingStatusResponse', {
-            status: 'disabled',
-            billing_method: null,
-            reason: 'No billing method',
-            internal_trace: 'leak',
-        } as never);
-        expect(disabled).toEqual({ status: 'disabled', billing_method: null, reason: 'No billing method' });
-    });
-
-    it('prunes inside arrays', () => {
-        const components = toOpenApiComponents({
-            Page: {
-                type: 'object',
-                properties: {
-                    items: {
-                        type: 'array',
-                        items: { $id: 'Row', type: 'object', properties: { id: { type: 'string' } } },
-                    },
-                },
-            },
-        });
-        const pruned = pruneToSchema(
-            {
-                items: [
-                    { id: 'a', secret: 1 },
-                    { id: 'b', secret: 2 },
-                ],
-                extra: true,
-            },
-            { $ref: '#/components/schemas/Page' },
-            components,
-        ) as JsonObject;
-        expect(pruned).toEqual({ items: [{ id: 'a' }, { id: 'b' }] });
-    });
-
-    it('leaves ambiguous schemas untouched rather than guessing', () => {
-        // An undiscriminated union and an allOf could each drop fields that belong to a branch we
-        // cannot identify, so the payload passes through intact.
-        const components = toOpenApiComponents({
-            Loose: { anyOf: [{ type: 'object', properties: { a: { type: 'string' } } }, { type: 'object' }] },
-            Merged: { allOf: [{ type: 'object', properties: { a: { type: 'string' } } }] },
-        });
-        const payload = { a: 'x', b: 'keep' };
-        expect(pruneToSchema(payload, { $ref: '#/components/schemas/Loose' }, components)).toEqual(payload);
-        expect(pruneToSchema(payload, { $ref: '#/components/schemas/Merged' }, components)).toEqual(payload);
-    });
-
-    it('keeps extras where a component explicitly declares itself extensible', () => {
-        const components = toOpenApiComponents({
-            Open: { type: 'object', properties: { a: { type: 'string' } }, additionalProperties: true },
-        });
-        expect(pruneToSchema({ a: 'x', b: 'keep' }, { $ref: '#/components/schemas/Open' }, components)).toEqual({
-            a: 'x',
-            b: 'keep',
-        });
-    });
-
-    it('keeps properties documented on a $ref sibling', () => {
-        // 2020-12 applies $ref siblings as additional constraints, so `extra` is declared here
-        // and must survive pruning rather than being dropped as unknown.
-        const components = toOpenApiComponents({
-            Wrapper: {
-                type: 'object',
-                properties: {
-                    inner: {
-                        $ref: '#/$defs/Base',
-                        properties: { extra: { type: 'string' } },
-                        required: ['extra'],
-                    },
-                },
-                $defs: { Base: { type: 'object', properties: { a: { type: 'string' } }, required: ['a'] } },
-            },
-        });
-        const pruned = pruneToSchema(
-            { inner: { a: 'x', extra: 'documented', undeclared: 'drop' } },
-            { $ref: '#/components/schemas/Wrapper' },
-            components,
-        );
-        expect(pruned).toEqual({ inner: { a: 'x', extra: 'documented' } });
-    });
-
-    it('follows a chain of aliased references to the terminal schema', () => {
-        // A component that is itself a reference is an alias. Resolving only one hop would leave a
-        // node whose `properties` lists just `extra`, so pruning would read that as the entire
-        // shape and drop `a` — which Base requires, making the pruned response fail validation.
-        const components = toOpenApiComponents({
-            Alias: {
-                $ref: '#/components/schemas/Base',
-                properties: { extra: { type: 'string' } },
-                required: ['extra'],
-            },
-            Base: { type: 'object', properties: { a: { type: 'string' } }, required: ['a'] },
-        });
-        const ref = { $ref: '#/components/schemas/Alias' };
-
-        const pruned = pruneToSchema({ a: 'x', extra: 'documented', undeclared: 'drop' }, ref, components);
-        expect(pruned).toEqual({ a: 'x', extra: 'documented' });
-        // The detector recurses through references, so it must reach the same terminal schema —
-        // a divergence here means it certifies a component the pruner then mangles.
-        expect(findUnprunablePaths(ref, components)).toEqual([]);
-
-        const ajv = new Ajv2020({ strictSchema: false, allErrors: true });
-        ajv.addSchema({ $id: 'vertesia://chain', components: { schemas: components } });
-        expect(ajv.validate({ $ref: 'vertesia://chain#/components/schemas/Alias' }, pruned)).toBe(true);
-    });
-
-    it('strips undeclared fields on a component closed with additionalProperties:false', () => {
-        const components = toOpenApiComponents(
-            { Closed: { type: 'object', properties: { a: { type: 'string' } } } },
-            { strictComponents: new Set(['Closed']) },
-        );
-        expect(pruneToSchema({ a: 'x', b: 'drop' }, { $ref: '#/components/schemas/Closed' }, components)).toEqual({
-            a: 'x',
-        });
-    });
-});

package/src/api-schemas/store.contract.test.ts

@@ -1,378 +0,0 @@
-import { Ajv } from 'ajv';
-import { describe, expect, it } from 'vitest';
-import { ContentTypeIntakePolicySchema as GeneratedIntakePolicySchema } from '../store/intake-policy-schema.generated.js';
-import type { ContentObjectTypeRef, ContentTypeIntakePolicy, IntakePageRanges } from '../store/store.js';
-import type { JsonObject } from './adapter.js';
-import { ApiSchemaComponents, bundleCanonicalComponent, validateApiResponse } from './registry.js';
-import { ContentTypeIntakePolicySchema } from './store.js';
-
-/** Exact type identity — `extends` in both directions is too weak (any/unknown slip through). */
-type Equals<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
-function assertType<T extends true>(_ok: T): void {}
-
-/**
- * The intake policy is now stated once, in Zod, and reaches its consumers three ways: as the
- * canonical component, as the checked-in JSON artifact consumers compile, and as the TypeScript
- * type. This file keeps those package-owned contracts aligned. Downstream consumers test their
- * published API documents and generated-client fixtures separately.
- *
- * It also pins the behaviour changes the conversion makes, because the schema it replaced was
- * hand-written and disagreed with the contract in both directions. Each is asserted rather than
- * described: the whole point of the migration is that a disagreement fails a build instead of
- * shipping.
- */
-const ajv = new Ajv({ strict: false, allErrors: true });
-const validate = ajv.compile<ContentTypeIntakePolicy>(GeneratedIntakePolicySchema);
-
-function errors(): string {
-    return ajv.errorsText(validate.errors, { separator: '\n' });
-}
-
-describe('generated artifact and canonical component', () => {
-    it('is the exact bundle the registry emits, so the artifact is compiled output', () => {
-        // Deep equality, not a spot check: the file is generated by `pnpm run gen:schemas` from this
-        // same function, so any difference means someone hand-edited it or forgot to regenerate.
-        expect(GeneratedIntakePolicySchema).toEqual(bundleCanonicalComponent('ContentTypeIntakePolicy'));
-    });
-
-    it('registers the component the alias claims, under the id the alias name requires', () => {
-        expect(Object.keys(ApiSchemaComponents)).toContain('ContentTypeIntakePolicy');
-        assertType<Equals<ContentTypeIntakePolicy, (typeof ContentTypeIntakePolicySchema)['_zod']['output']>>(true);
-    });
-});
-
-describe('content object response classification', () => {
-    it('accepts the current sensitivity and compartments fields', () => {
-        const result = validateApiResponse('ContentObjectApiResponse', {
-            id: 'content-object-id',
-            name: 'Classified document',
-            updated_by: 'user-id',
-            created_by: 'user-id',
-            created_at: '2026-08-06T09:00:00.000Z',
-            updated_at: '2026-08-06T09:00:00.000Z',
-            location: '/',
-            status: 'completed',
-            properties: {},
-            revision: { root: 'content-object-id', head: true },
-            sensitivity: 3,
-            compartments: ['legal'],
-        });
-
-        expect(result).toMatchObject({ valid: true });
-    });
-});
-
-/**
- * Bodies that probe where the two validators could disagree.
- *
- * The gate above compares the artifact to the component, and both are produced by the SAME adapter
- * from the SAME Zod schema — so any transform applied on the way out is invisible to it. That blind
- * spot shipped once: an adapter pass stripped the bounds `z.int()` attaches for the JavaScript
- * safe-integer range, on the reasoning that no JSON value could fall outside them. `1e20` does, and
- * the Zod schema rejected it while the generated schema accepted it. Nothing in a
- * schema-versus-schema comparison can see that; only running both validators over the same value can.
- */
-const PROBES: unknown[] = [
-    // Numeric range, including the values that made the sentinel-stripping bug observable.
-    {},
-    { extraction: { max_pages: 1 } },
-    { extraction: { max_pages: 0 } },
-    { extraction: { max_pages: 2.5 } },
-    { extraction: { max_pages: 1e20 } },
-    { extraction: { max_pages: 2147483647 } },
-    { extraction: { max_pages: 2147483648 } },
-    { extraction: { max_pages: Number.MAX_SAFE_INTEGER + 1 } },
-    { extraction: { max_pages: -1 } },
-    { locate: { instructions: 'x', min_pages: 0 } },
-    { locate: { instructions: 'x', min_pages: -1 } },
-    { locate: { instructions: 'x', min_pages: 1e20 } },
-    { locate: { detail: 8 } },
-    { text_conversion: { render_dpi: 72 } },
-    { text_conversion: { render_dpi: 71 } },
-    { text_conversion: { render_dpi: 1e20 } },
-    { extraction: { verification: { threshold: 0 } } },
-    { extraction: { verification: { threshold: 1 } } },
-    { extraction: { verification: { threshold: 1.000001 } } },
-    { extraction: { verification: { max_retries: 1e20 } } },
-    { extraction: { vision: { max_image_tokens: 1e20, max_payload_mb: 1e20 } } },
-    { extraction: { grounding: { window_pages: 1e20, grid_cell_pt: 1e20 } } },
-    { extraction: { grounding: { hardness_threshold: 1e20 } } },
-    // Page ranges: length, element type, and element magnitude.
-    { extraction: { page_ranges: [[1, 2]] } },
-    { extraction: { page_ranges: [[-1, -1]] } },
-    { extraction: { page_ranges: [[1]] } },
-    { extraction: { page_ranges: [[1, 2, 3]] } },
-    { extraction: { page_ranges: [[1.5, 2]] } },
-    { extraction: { page_ranges: [[1e20, 2]] } },
-    // Nullability, unknown keys, and the enums.
-    { generate_toc: null },
-    { extraction: null },
-    { extraction: { max_pages: null } },
-    { grounded_extraction: { enabled: true } },
-    { locate: { instructions: 'x', dpi: 300 } },
-    { extraction: { scope: 'first-two' } },
-    { extraction: { vision: { default_detail: 'ultra' } } },
-    { default_view: 'pdf' },
-    { mode: 'agentic' },
-    // The execution config: closedness, the option union, the two enums.
-    { extraction: { config: { model: 'm' } } },
-    { extraction: { config: { temperature: 0.5 } } },
-    { extraction: { config: { http_timeout: { bodyTimeout: 1000 } } } },
-    { extraction: { config: { http_timeout: { socketTimeout: 1000 } } } },
-    { extraction: { config: { model_options: { _option_id: 'openai-text', temperature: 0.5 } } } },
-    { extraction: { config: { model_options: { temperature: 0.5 } } } },
-    { extraction: { config: { model_options: { _option_id: 'not-a-driver' } } } },
-    { extraction: { config: { run_data: 'STANDARD' } } },
-    { extraction: { config: { run_data: 'WHATEVER' } } },
-    { extraction: { config: { configMode: 'RUN_CONFIG_ONLY' } } },
-    // Wrong types where a shape is expected.
-    { extraction: 'nope' },
-    { embeddings: { text: 'yes' } },
-    { identification: { examples: 'not-a-list' } },
-];
-
-describe('gate — the artifact accepts exactly what the Zod schema accepts', () => {
-    it.each(PROBES.map((probe) => [JSON.stringify(probe), probe] as const))('agrees on %s', (_label, probe) => {
-        // The point of the migration is that ONE schema is enforced. Two validators built from it
-        // that disagree on a value means one of the consumers is enforcing something the source
-        // never said, which is the drift this whole exercise removes.
-        expect(validate(probe)).toBe(ContentTypeIntakePolicySchema.safeParse(probe).success);
-    });
-});
-
-describe('the TypeScript type says what the schema says', () => {
-    it('widens page ranges to number[][], which is what the component has always described', () => {
-        // `[number, number][]` is what the interface used to claim. The published component is
-        // `items: {type: integer}` with `minItems`/`maxItems` — a two-element ARRAY, not a tuple —
-        // because a Zod tuple emits `prefixItems`, which generated Java and Go clients read
-        // differently. The wire shape is unchanged; the SDK type is corrected to match it.
-        assertType<Equals<IntakePageRanges, number[][]>>(true);
-        expect(validate({ extraction: { page_ranges: [[1, 2]] } }), errors()).toBe(true);
-    });
-
-    it('keeps the two type refs’ default_view in step with the policy', () => {
-        // Those refs spell the union out rather than writing `ContentTypeIntakePolicy['default_view']`,
-        // because indexing into a canonical alias makes the generator DROP the property instead of
-        // failing. This is what stops the restatement from drifting.
-        assertType<
-            Equals<
-                NonNullable<ContentObjectTypeRef['default_view']>,
-                NonNullable<ContentTypeIntakePolicy['default_view']>
-            >
-        >(true);
-    });
-});
-
-describe('parity with the hand-written AJV schema it replaces', () => {
-    it('still accepts a full policy across every block', () => {
-        const policy: ContentTypeIntakePolicy = {
-            mode: 'programmatic',
-            identification: { guidance: 'Investor reports' },
-            locate: { instructions: 'allocation tables', detail: 8, min_pages: 10 },
-            text_conversion: { method: 'llm', scope: 'located', render_dpi: 150 },
-            extraction: {
-                source: 'vision',
-                page_ranges: [
-                    [1, 2],
-                    [-1, -1],
-                ],
-                max_pages: 6,
-                vision: { default_detail: 'high', max_image_tokens: 9000, max_payload_mb: 12 },
-                verification: { threshold: 0.7, max_retries: 2 },
-                grounding: {
-                    enabled: true,
-                    max_pages: 12,
-                    hardness_threshold: 0.5,
-                    config: { model: 'claude-sonnet-4-5' },
-                    review: { threshold: 0.7, coverage_threshold: 0.2 },
-                },
-            },
-            embeddings: { text: true, properties: true },
-            default_view: 'pdf',
-        };
-        expect(validate(policy), errors()).toBe(true);
-    });
-
-    it('keeps every numeric bound the hand-written schema enforced', () => {
-        // These were NOT in the published component — the interface carried no `@minimum` tags — so
-        // converting to Zod dropped all eighteen of them until this test caught it. They are restored
-        // in the schema, which means the document now publishes constraints the server has enforced
-        // all along.
-        expect(validate({ locate: { instructions: 'x', min_pages: -1 } })).toBe(false);
-        expect(validate({ text_conversion: { render_dpi: 71 } })).toBe(false);
-        expect(validate({ extraction: { max_pages: 0 } })).toBe(false);
-        expect(validate({ extraction: { verification: { threshold: 1.2 } } })).toBe(false);
-        expect(validate({ extraction: { verification: { max_retries: -1 } } })).toBe(false);
-        expect(validate({ extraction: { vision: { max_image_tokens: 0 } } })).toBe(false);
-        expect(validate({ extraction: { vision: { max_payload_mb: 0 } } })).toBe(false);
-        expect(validate({ extraction: { vision: { max_pages_per_call: 0 } } })).toBe(false);
-        expect(validate({ extraction: { grounding: { max_pages: 0 } } })).toBe(false);
-        expect(validate({ extraction: { grounding: { window_pages: 0 } } })).toBe(false);
-        expect(validate({ extraction: { grounding: { grid_cell_pt: 0 } } })).toBe(false);
-        expect(validate({ extraction: { grounding: { hardness_threshold: -0.1 } } })).toBe(false);
-        expect(validate({ extraction: { grounding: { min_citation_density: 1.1 } } })).toBe(false);
-        expect(validate({ extraction: { grounding: { review: { threshold: 1.1 } } } })).toBe(false);
-        expect(validate({ extraction: { grounding: { review: { coverage_threshold: -0.1 } } } })).toBe(false);
-    });
-
-    it('keeps the page and DPI counters integral', () => {
-        // `type: 'integer'`, which the published component also never stated. A fractional page cap
-        // was rejected before this conversion and is rejected after it.
-        expect(validate({ extraction: { max_pages: 2.5 } })).toBe(false);
-        expect(validate({ text_conversion: { render_dpi: 150.5 } })).toBe(false);
-        expect(validate({ extraction: { page_ranges: [[1.5, 2]] } })).toBe(false);
-        expect(validate({ extraction: { page_ranges: [[1]] } })).toBe(false);
-        expect(validate({ locate: { instructions: 'x', min_pages: 8.5 } })).toBe(false);
-    });
-
-    it('keeps rejecting unknown keys and the obsolete root block', () => {
-        expect(validate({ grounded_extraction: { enabled: true } })).toBe(false);
-        expect(validate({ locate: { instructions: 'x', dpi: 300 } })).toBe(false);
-        expect(validate({ extraction: { vision: { default_detail: 'ultra' } } })).toBe(false);
-    });
-});
-
-describe('runtime tightenings — recorded as operation 25 of the 1.5 runbook', () => {
-    it('rejects an explicit null where the hand-written schema accepted one', () => {
-        // The replaced schema carried `nullable: true` on 112 subschemas and AJV honours that keyword
-        // for OpenAPI compatibility, so 101 of them accepted `null` — which neither the TypeScript
-        // type nor the published component has ever allowed. The fields are optional, not nullable.
-        expect(validate({ generate_toc: null })).toBe(false);
-        expect(validate({ rendering_template: null })).toBe(false);
-        expect(validate({ extraction: { max_pages: null } })).toBe(false);
-        expect(validate({ extraction: null })).toBe(false);
-        // Omission is still how you say "inherit", which is what every one of those fields meant.
-        expect(validate({}), errors()).toBe(true);
-        expect(validate({ extraction: {} }), errors()).toBe(true);
-    });
-
-    it('closes the execution config, which the published component already described closed', () => {
-        // `config` was `additionalProperties: true` in the hand-written schema while
-        // `InteractionExecutionConfiguration` has always been published closed. A stored policy
-        // carrying an undeclared key there is now rejected at write time.
-        expect(ApiSchemaComponents.InteractionExecutionConfiguration.additionalProperties).toBe(false);
-        expect(validate({ extraction: { config: { model: 'claude-sonnet-4-5' } } }), errors()).toBe(true);
-        expect(
-            validate({ extraction: { config: { prompt_cache_mode: 'required', prompt_cache_ttl_seconds: 3600 } } }),
-            errors(),
-        ).toBe(true);
-        expect(validate({ extraction: { config: { prompt_cache_ttl_seconds: 59 } } })).toBe(false);
-        expect(validate({ extraction: { config: { temperature: 0.5 } } })).toBe(false);
-        expect(validate({ extraction: { config: { http_timeout: { socketTimeout: 1000 } } } })).toBe(false);
-    });
-
-    it('validates model_options against the union instead of accepting any object', () => {
-        // Same class: `model_options` was `{type: object, additionalProperties: true}` in the
-        // hand-written schema and `$ref: ModelOptions` in the published component. The family hint
-        // is optional, but known field types and supplied IDs remain validated.
-        expect(ApiSchemaComponents.ContentTypeIntakePolicy).toBeDefined();
-        expect(
-            validate({
-                extraction: { config: { model_options: { _option_id: 'openai-text', temperature: 0.5 } } },
-            }),
-            errors(),
-        ).toBe(true);
-        expect(validate({ extraction: { config: { model_options: { temperature: 0.5 } } } })).toBe(true);
-        expect(validate({ extraction: { config: { model_options: { _option_id: 'not-a-driver' } } } })).toBe(false);
-        expect(validate({ extraction: { config: { model_options: {} } } })).toBe(true);
-        expect(validate({ extraction: { config: { model_options: { temperature: 'hot' } } } })).toBe(false);
-        expect(validate({ extraction: { config: { model_options: { unknown_option: true } } } })).toBe(false);
-    });
-
-    it('constrains the two config enums that were unconstrained strings', () => {
-        expect(validate({ extraction: { config: { run_data: 'STANDARD' } } }), errors()).toBe(true);
-        expect(validate({ extraction: { config: { run_data: 'WHATEVER' } } })).toBe(false);
-        expect(validate({ extraction: { config: { configMode: 'RUN_CONFIG_ONLY' } } }), errors()).toBe(true);
-        expect(validate({ extraction: { config: { configMode: 'WHATEVER' } } })).toBe(false);
-    });
-});
-
-describe('the five content-type shapes are composed, not repeated', () => {
-    const properties = (name: string) =>
-        Object.keys((ApiSchemaComponents[name] as { properties: Record<string, unknown> }).properties);
-    const property = (name: string, key: string) =>
-        (ApiSchemaComponents[name] as { properties: Record<string, JsonObject> }).properties[key];
-
-    it('gives every shape the same definition for a shared field', () => {
-        // The drift this guards: five hand-transcribed copies of `table_layout` could disagree about
-        // its item type or its description and nothing would notice. They come from one dictionary now.
-        const shapes = [
-            'ContentObjectTypeItem',
-            'ContentObjectType',
-            'ContentObjectTypeCatalogEntry',
-            'InCodeTypeDefinition',
-            'CreateContentObjectTypePayload',
-        ];
-        for (const field of ['table_layout', 'object_schema', 'strict_mode', 'intake', 'editing', 'status']) {
-            const rendered = shapes.map((shape) => JSON.stringify(property(shape, field)));
-            expect(new Set(rendered).size, `${field} differs across the content-type shapes`).toBe(1);
-        }
-    });
-
-    it('keeps the published property order, which composition must not reshuffle', () => {
-        // Order is contract: it decides the order of the generated clients' constructor arguments and
-        // model fields. The five orders differ because they were derived from five different types.
-        expect(properties('ContentObjectTypeItem')).toEqual(properties('ContentObjectType'));
-        expect(properties('ContentObjectTypeCatalogEntry').slice(0, 12)).toEqual(properties('InCodeTypeDefinition'));
-        expect(properties('CreateContentObjectTypePayload')).toEqual([
-            'status',
-            'is_chunkable',
-            'intake',
-            'editing',
-            'table_layout',
-            'object_schema',
-            'strict_mode',
-            'name',
-            'description',
-            'tags',
-        ]);
-    });
-
-    it('keeps the audit fields required on a stored type and optional in the catalog', () => {
-        // Not a detail: a catalog entry may be an in-code type contributed by a plugin, which nobody
-        // created and nobody has modified. Requiring the four there would reject a legitimate entry.
-        const audit = ['updated_by', 'created_by', 'created_at', 'updated_at'];
-        const required = (name: string) => (ApiSchemaComponents[name] as { required?: string[] }).required ?? [];
-
-        expect(required('ContentObjectTypeItem')).toEqual(expect.arrayContaining(audit));
-        expect(required('ContentObjectType')).toEqual(expect.arrayContaining(audit));
-        for (const field of audit) {
-            expect(required('ContentObjectTypeCatalogEntry')).not.toContain(field);
-            expect(property('ContentObjectTypeCatalogEntry', field)).toEqual({ type: 'string' });
-        }
-    });
-
-    it('accepts a catalog entry for an in-code type that has no audit trail', () => {
-        expect(
-            validateApiResponse('ContentObjectTypeCatalogEntry', {
-                id: 'sys:Invoice',
-                name: 'Invoice',
-                is_chunkable: false,
-            }).valid,
-        ).toBe(true);
-    });
-
-    it('publishes `title` on the app-contribution shapes and withholds it from the stored ones', () => {
-        // An app package contributes a display title alongside the app-local `name`, exactly as
-        // `InCodeViewDefinition` and `InCodeProcessDefinition` do. Only the two shapes that carry a
-        // contribution get it; a type someone stored through the API has no `title` to publish.
-        for (const shape of ['InCodeTypeDefinition', 'ContentObjectTypeCatalogEntry']) {
-            expect(property(shape, 'title'), `${shape} should publish title`).toBeDefined();
-        }
-        for (const shape of ['ContentObjectTypeItem', 'ContentObjectType', 'CreateContentObjectTypePayload']) {
-            expect(property(shape, 'title'), `${shape} should not publish title`).toBeUndefined();
-        }
-    });
-
-    it('accepts an app-contributed type that carries a title', () => {
-        // The regression: deployed app packages send `title`, the shape was strict and did not
-        // declare it, so every `GET /projects/:projectId/app-types` failed its own response contract.
-        expect(
-            validateApiResponse('InCodeTypeDefinition', {
-                id: 'invoice',
-                name: 'invoice',
-                title: 'Invoice',
-            }).valid,
-        ).toBe(true);
-    });
-});