@inventarch/compliance 0.0.0-stage → 1.0.0

package/fixtures/refusals.ts

@@ -0,0 +1,434 @@
+/** Executable boundary fixtures over the actual native corpus. These mutate
+ * typed products to exercise refusal APIs; they are not substitute providers. */
+import { KERNEL_DIGEST, LANGUAGE_VERSION } from '@inventarch/language';
+import type { CompiledRecord, FrozenRegistry, SchemaField } from '@inventarch/language';
+import {
+  GraphUsageError,
+  canonicalRoot,
+  load,
+  resolve,
+  traverse,
+  validateCoordinate,
+  variants,
+} from '@inventarch/graph';
+import type { Graph, Node, RevisionSource } from '@inventarch/graph';
+import {
+  renderHostArtifacts,
+  validateAdoption,
+  validateCheck,
+  validateCoverage,
+  validateFragments,
+  validateParse,
+  validateSchema,
+  validateSelectors,
+  validateSystems,
+  validateVariants,
+  runLanguageFixture,
+} from '../src/index.js';
+import type { AdoptionEvaluators, Finding, FixtureResult, SystemFolder } from '../src/index.js';
+import { assess } from '../src/types.js';
+
+export function runRefusalFixtures(
+  graph: Graph,
+  inputs: readonly RevisionSource[],
+  folders: readonly SystemFolder[],
+): readonly FixtureResult[] {
+  const records = [...graph.nodes.values()],
+    registry = graph.registry;
+  const agent = records.find((r) => r.discriminator === 'agent')!,
+    method = records.find((r) => r.name === 'sample-procedure')!;
+  const law = records.find((r) => r.discriminator === 'law')!,
+    contract = records.find((r) => r.name === 'foundation-authoring-contract')!,
+    check = records.find((r) => r.discriminator === 'check')!;
+  const ambiguous: Node = {
+    ...law,
+    variants: [
+      {
+        key: 'requires',
+        value: { kind: 'string', text: 'one' },
+        condition: [{ axis: 'phase', value: 'act' }],
+        span: { line: 10, endLine: 10 },
+      },
+      {
+        key: 'requires',
+        value: { kind: 'string', text: 'two' },
+        condition: [{ axis: 'primitive', value: 'Memory' }],
+        span: { line: 11, endLine: 11 },
+      },
+    ],
+  };
+  const rebuild = (changed: readonly CompiledRecord[] = records, vocabulary: FrozenRegistry = registry) =>
+    load(changed, vocabulary, {
+      sources: inputs,
+      languageVersion: LANGUAGE_VERSION,
+      kernelDigest: KERNEL_DIGEST,
+      location: '',
+    });
+  const schemaFindings = (changed: CompiledRecord = agent, vocabulary = registry) =>
+    validateSchema(changed, vocabulary, records).findings;
+  const systemFindings = (changed = folders, vocabulary = registry, pool: readonly CompiledRecord[] = records) =>
+    validateSystems(changed, vocabulary, pool).flatMap((a) => a.findings);
+  const rule = {
+    predicate: 'cite' as const,
+    target: 'playbook',
+    must: true,
+    cardinality: 'one' as const,
+    span: { line: 1, endLine: 1 },
+  };
+  const schemas = new Map(registry.schemas);
+  schemas.set('agent', { ...schemas.get('agent')!, edges: [rule] });
+  // W0 narrowing rows: the agent's `meaning.says` value re-typed, and its schema re-declared to narrow that one field.
+  const saying = (value: CompiledRecord['head'][number]['value']): CompiledRecord => ({
+    ...agent,
+    sections: agent.sections.map((s) =>
+      s.name !== 'meaning'
+        ? s
+        : { ...s, fields: s.fields.map((f) => ('key' in f && f.key === 'says' ? { ...f, value } : f)) },
+    ),
+  });
+  const narrowed = (field: Partial<SchemaField>): FrozenRegistry => {
+    const declared = new Map(registry.schemas),
+      original = declared.get('agent')!;
+    declared.set('agent', {
+      ...original,
+      fields: [{ section: 'meaning', key: 'says', type: 'text', must: true, span: original.span, ...field }],
+    });
+    return { ...registry, schemas: declared };
+  };
+  const edge = {
+    predicate: 'cite' as const,
+    direction: 'out' as const,
+    reference: { kind: 'ref' as const, discriminator: 'playbook', name: 'missing' },
+    target: null,
+    span: agent.source,
+  };
+  const examples: readonly [Finding['code'], () => readonly Finding[]][] = [
+    [
+      'IA-GRAPH-IDENTITY-TIE',
+      () => rebuild([...records, { ...method, source: { ...method.source, line: 1000 } }]).diagnostics,
+    ],
+    ['IA-GRAPH-TARGET-MISSING', () => rebuild(records.filter((r) => r.identity !== contract.identity)).diagnostics],
+    [
+      'IA-GRAPH-TARGET-AMBIGUOUS',
+      () => {
+        const result = resolve(
+          { kind: 'ref', discriminator: method.discriminator, name: method.name },
+          [method, { ...method, source: { ...method.source, line: 1000 } }],
+          registry,
+        );
+        return result.ok
+          ? []
+          : [
+              {
+                code: result.code,
+                path: method.source.path,
+                line: 1,
+                severity: 'error',
+                message: 'Ambiguous boundary reference',
+              },
+            ];
+      },
+    ],
+    ['IA-GRAPH-EDGE-UNCONSENTED', () => rebuild(records, { ...registry, consent: new Map() }).diagnostics],
+    [
+      'IA-GRAPH-DIMENSION-UNKNOWN',
+      () =>
+        rebuild(
+          records.map((r) =>
+            r !== method
+              ? r
+              : { ...r, head: [{ key: 'artifact-set', value: { kind: 'scalar', text: 'unknown' }, span: r.source }] },
+          ),
+        ).diagnostics,
+    ],
+    [
+      'IA-GRAPH-COORDINATE-VALUE-UNKNOWN',
+      () => {
+        validateCoordinate({ phase: 'unknown' });
+        return [];
+      },
+    ],
+    [
+      'IA-GRAPH-VERB-UNKNOWN',
+      () => {
+        traverse(graph, { start: [], follow: ['imagines'] });
+        return [];
+      },
+    ],
+    [
+      'IA-GRAPH-TRAVERSAL-INVALID',
+      () => {
+        traverse(graph, { start: [], depth: 9 });
+        return [];
+      },
+    ],
+    ['IA-GRAPH-VARIANT-AMBIGUOUS', () => variants(ambiguous, { phase: 'act', primitive: 'Memory' }).diagnostics],
+    [
+      'IA-GRAPH-SCOPE-INVALID',
+      () => {
+        canonicalRoot('../escape');
+        return [];
+      },
+    ],
+    ['IA-COMP-SCHEMA-MISSING', () => schemaFindings(agent, { ...registry, schemas: new Map() })],
+    ['IA-COMP-SCHEMA-KIND-MISMATCH', () => schemaFindings({ ...agent, kind: 'definition' })],
+    [
+      'IA-COMP-SECTION-MISSING',
+      () => schemaFindings({ ...agent, sections: agent.sections.filter((s) => s.name !== 'meaning') }),
+    ],
+    [
+      'IA-COMP-SECTION-UNKNOWN',
+      () =>
+        schemaFindings({
+          ...agent,
+          sections: [...agent.sections, { name: 'unknown', span: agent.source, fields: [] }],
+        }),
+    ],
+    [
+      'IA-COMP-FIELD-MISSING',
+      () =>
+        schemaFindings({
+          ...agent,
+          sections: agent.sections.map((s) => (s.name !== 'meaning' ? s : { ...s, fields: [] })),
+        }),
+    ],
+    [
+      'IA-COMP-FIELD-DUPLICATE',
+      () =>
+        schemaFindings({
+          ...agent,
+          sections: agent.sections.map((s) =>
+            s.name !== 'meaning'
+              ? s
+              : { ...s, fields: [...s.fields, ...s.fields.filter((f) => 'key' in f && f.key === 'says')] },
+          ),
+        }),
+    ],
+    [
+      'IA-COMP-FIELD-UNKNOWN',
+      () =>
+        schemaFindings({
+          ...agent,
+          sections: agent.sections.map((s) =>
+            s.name !== 'meaning'
+              ? s
+              : {
+                  ...s,
+                  fields: [...s.fields, { key: 'ready', value: { kind: 'scalar', text: 'true' }, span: agent.source }],
+                },
+          ),
+        }),
+    ],
+    [
+      'IA-COMP-FIELD-TYPE',
+      () =>
+        schemaFindings({
+          ...agent,
+          sections: agent.sections.map((s) =>
+            s.name !== 'meaning'
+              ? s
+              : {
+                  ...s,
+                  fields: s.fields.map((f) =>
+                    'key' in f && f.key === 'says' ? { ...f, value: { kind: 'list', items: [] } } : f,
+                  ),
+                },
+          ),
+        }),
+    ],
+    [
+      'IA-COMP-FIELD-VALUE',
+      () => schemaFindings(saying({ kind: 'scalar', text: 'nope' }), narrowed({ type: 'id', values: ['yes'] })),
+    ],
+    [
+      'IA-COMP-FIELD-REF-TARGET',
+      () =>
+        schemaFindings(
+          saying({ kind: 'ref', discriminator: 'playbook', name: 'sample-procedure' }),
+          narrowed({ type: 'ref', target: 'agent' }),
+        ),
+    ],
+    [
+      'IA-COMP-FIELD-REF-MISSING',
+      () =>
+        schemaFindings(
+          saying({ kind: 'ref', discriminator: 'playbook', name: 'missing' }),
+          narrowed({ type: 'ref', target: 'playbook' }),
+        ),
+    ],
+    ['IA-COMP-FIELD-FORM', () => schemaFindings(agent, narrowed({ type: 'text', form: 'iso-date' }))],
+    ['IA-COMP-EDGE-CARDINALITY', () => schemaFindings(agent, { ...registry, schemas })],
+    ['IA-COMP-EDGE-UNRESOLVED', () => schemaFindings({ ...agent, edges: [edge] }, { ...registry, schemas })],
+    ['IA-COMP-SYSTEM-MALFORMED', () => systemFindings([{ name: 'empty', path: 'empty', sources: [], records: [] }])],
+    [
+      'IA-COMP-DISCRIMINATOR-FOREIGN',
+      () =>
+        systemFindings(folders.map((f) => (f.name !== 'agent-system' ? f : { ...f, records: [...f.records, method] }))),
+    ],
+    ['IA-COMP-BOOTSTRAP-ORDER', () => systemFindings(folders, { ...registry, order: [...registry.order].reverse() })],
+    [
+      'IA-COMP-STEWARD-MISSING',
+      () =>
+        systemFindings(
+          folders,
+          registry,
+          records.filter((r) => r.discriminator !== 'agent'),
+        ),
+    ],
+    [
+      'IA-COMP-CONSENT-EMPTY',
+      () =>
+        systemFindings(folders, {
+          ...registry,
+          systems: new Map([...registry.systems].map(([key, value]) => [key, { ...value, consent: [] }])),
+        }),
+    ],
+    [
+      'IA-COMP-SCHEMA-UNREFERENCED',
+      () =>
+        systemFindings(folders, {
+          ...registry,
+          registrations: new Map([...registry.registrations].filter(([key]) => key !== 'agent')),
+        }),
+    ],
+    [
+      'IA-COMP-SCHEMA-MULTIPLE',
+      () =>
+        systemFindings(folders, {
+          ...registry,
+          registrations: new Map([
+            ...registry.registrations,
+            ['duplicate', { ...registry.registrations.get('agent')!, keyword: 'duplicate' }],
+          ]),
+        }),
+    ],
+    [
+      'IA-COMP-FRAGMENT-MISSING',
+      () =>
+        validateFragments(
+          rebuild(
+            records.map((r) =>
+              r.discriminator !== 'case'
+                ? r
+                : {
+                    ...r,
+                    edges: r.edges.map((e) => ({
+                      ...e,
+                      fragment: 'REQ-MISSING',
+                      reference: { ...e.reference, fragment: 'REQ-MISSING' },
+                    })),
+                  },
+            ),
+          ),
+        ).findings,
+    ],
+    [
+      'IA-COMP-COVERAGE-MISSING',
+      () => {
+        const g = rebuild(records.filter((r) => r.name !== 'valid-native-record'));
+        return validateCoverage(g.nodes.get(contract.identity)!, g).findings;
+      },
+    ],
+    [
+      'IA-COMP-COVERAGE-KIND',
+      () => {
+        const g = rebuild(
+          records.map((r) =>
+            r.discriminator !== 'case'
+              ? r
+              : {
+                  ...r,
+                  sections: r.sections.map((s) =>
+                    s.name !== 'scenario'
+                      ? s
+                      : {
+                          ...s,
+                          fields: s.fields.map((f) =>
+                            'key' in f && f.key === 'kind' ? { ...f, value: { kind: 'scalar', text: 'success' } } : f,
+                          ),
+                        },
+                  ),
+                },
+          ),
+        );
+        return validateCoverage(g.nodes.get(contract.identity)!, g).findings;
+      },
+    ],
+    [
+      'IA-COMP-SELECTOR-INVALID',
+      () => validateSelectors({ ...method, selectors: [[{ axis: 'phase', value: 'unknown' }]] }).findings,
+    ],
+    ['IA-COMP-CHECK-UNKNOWN', () => validateCheck({ ...check, sections: [] }).findings],
+    ['IA-COMP-VARIANT-AMBIGUOUS', () => validateVariants(ambiguous).findings],
+    [
+      'IA-COMP-ADOPTION-FAILED',
+      () => {
+        const evaluators: AdoptionEvaluators = new Map([
+          [
+            contract.identity,
+            new Map(
+              contract.requirements.map((r) => [
+                r.id,
+                () => ({ outcome: 'fail' as const, message: 'Fixture rejects the structural claim' }),
+              ]),
+            ),
+          ],
+        ]);
+        return validateAdoption(graph, evaluators).flatMap((a) => a.findings);
+      },
+    ],
+    ['IA-COMP-NOT-EVALUATED', () => validateParse(undefined).findings],
+    ['IA-COMP-PROJECTION-INVALID', () => renderHostArtifacts(records, '').assessment.findings],
+    [
+      'IA-COMP-FIXTURE-MISMATCH',
+      () =>
+        runLanguageFixture({
+          path: 'fixture.ia',
+          clause: 'parser',
+          mode: 'fail',
+          source: '#! ia 1.0\n',
+          diagnostics: [],
+        }).assessment.findings,
+    ],
+  ];
+  return Object.freeze(
+    examples.map(([code, run]): FixtureResult => {
+      let observed: readonly Finding[];
+      let unexpected = false;
+      try {
+        observed = run();
+      } catch (error) {
+        if (error instanceof GraphUsageError)
+          observed = [{ code: error.code, path: '', line: 1, severity: 'error', message: error.message }];
+        else {
+          unexpected = true;
+          observed = [
+            {
+              code: 'IA-COMP-FIXTURE-MISMATCH',
+              path: '',
+              line: 1,
+              severity: 'error',
+              message: `Boundary fixture threw: ${error instanceof Error ? error.message : String(error)}`,
+            },
+          ];
+        }
+      }
+      const findings: Finding[] =
+        !unexpected && observed.some((d) => d.code === code)
+          ? []
+          : [
+              {
+                code: 'IA-COMP-FIXTURE-MISMATCH',
+                path: '',
+                line: 1,
+                severity: 'error',
+                message: `${code} boundary fixture produced ${observed.map((d) => `${d.code}: ${d.message}`).join(', ')}`,
+              },
+            ];
+      return Object.freeze({
+        assessment: assess('COMP-FIXTURES', `boundary/${code}`, findings),
+        observedCodes: Object.freeze([...new Set(observed.map((d) => d.code))].sort()),
+      });
+    }),
+  );
+}

package/package.json

@@ -1,6 +1,132 @@
 {
   "name": "@inventarch/compliance",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./internal/adoption": {
+      "types": "./dist/adoption.d.ts",
+      "default": "./dist/adoption.js"
+    },
+    "./internal/catalog": {
+      "types": "./dist/catalog.d.ts",
+      "default": "./dist/catalog.js"
+    },
+    "./internal/check-ids": {
+      "types": "./dist/check-ids.d.ts",
+      "default": "./dist/check-ids.js"
+    },
+    "./internal/evidence": {
+      "types": "./dist/evidence.d.ts",
+      "default": "./dist/evidence.js"
+    },
+    "./internal/fixtures": {
+      "types": "./dist/fixtures.d.ts",
+      "default": "./dist/fixtures.js"
+    },
+    "./internal/graph-checks": {
+      "types": "./dist/graph-checks.d.ts",
+      "default": "./dist/graph-checks.js"
+    },
+    "./internal/host-plugin": {
+      "types": "./dist/host-plugin.d.ts",
+      "default": "./dist/host-plugin.js"
+    },
+    "./internal/index": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./internal/obligations": {
+      "types": "./dist/obligations.d.ts",
+      "default": "./dist/obligations.js"
+    },
+    "./internal/profiles": {
+      "types": "./dist/profiles.d.ts",
+      "default": "./dist/profiles.js"
+    },
+    "./internal/projections": {
+      "types": "./dist/projections.d.ts",
+      "default": "./dist/projections.js"
+    },
+    "./internal/record-text": {
+      "types": "./dist/record-text.d.ts",
+      "default": "./dist/record-text.js"
+    },
+    "./internal/report": {
+      "types": "./dist/report.d.ts",
+      "default": "./dist/report.js"
+    },
+    "./internal/schema": {
+      "types": "./dist/schema.d.ts",
+      "default": "./dist/schema.js"
+    },
+    "./internal/shape": {
+      "types": "./dist/shape.d.ts",
+      "default": "./dist/shape.js"
+    },
+    "./internal/steward-profile": {
+      "types": "./dist/steward-profile.d.ts",
+      "default": "./dist/steward-profile.js"
+    },
+    "./internal/systems": {
+      "types": "./dist/systems.d.ts",
+      "default": "./dist/systems.js"
+    },
+    "./internal/types": {
+      "types": "./dist/types.d.ts",
+      "default": "./dist/types.js"
+    },
+    "./internal/values": {
+      "types": "./dist/values.d.ts",
+      "default": "./dist/values.js"
+    },
+    "./internal/variants": {
+      "types": "./dist/variants.d.ts",
+      "default": "./dist/variants.js"
+    },
+    "./internal/workspace-projection": {
+      "types": "./dist/workspace-projection.d.ts",
+      "default": "./dist/workspace-projection.js"
+    }
+  },
+  "files": [
+    "dist",
+    "fixtures",
+    "README.md",
+    "SPEC.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "dependencies": {
+    "@inventarch/language": "1.0.0",
+    "@inventarch/graph": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.4"
+  },
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "engines": {
+    "node": ">=22.22.0 <23"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/inventarch/ia.git",
+    "directory": "packages/compliance"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc -p tsconfig.tests.json",
+    "test": "vitest run --config vitest.config.mts"
+  }
 }