@astrale-os/sdk 0.5.0-beta.2 → 0.5.0-beta.21

package/dist/tooling/linter/policy/index.d.ts

@@ -0,0 +1,44 @@
+export { compileDomainPolicy } from './compile.js';
+export { compileProjectDomainPolicy, configureDomainPolicySource, DOMAIN_LINT_CONFIG, } from './configuration.js';
+export { domainPolicyDigest, domainPolicySource } from './generated.js';
+import type { RuleCatalog } from '../catalog/index.js';
+export type { DomainLintConfiguration, DomainLintLayerConfiguration } from './configuration.js';
+export interface DomainLayerPolicy {
+    readonly id: string;
+    readonly sourcePath: string;
+    readonly required: boolean;
+}
+export interface DomainRootFilePolicy {
+    readonly id: string;
+    readonly sourcePath: string;
+    readonly role: 'configuration' | 'composition' | 'package-facade' | 'tooling';
+    readonly required: boolean;
+}
+export interface DomainAliasPolicy {
+    readonly layer: string;
+    readonly kind: 'facade' | 'submodule';
+    readonly specifier: string;
+    readonly typescriptTarget: string;
+    readonly packageTarget: string;
+}
+export interface DomainDependencyPolicy {
+    readonly source: string;
+    readonly target: string;
+    readonly kind: 'runtime' | 'type-only' | 'composition' | 'evidence';
+    readonly condition: string;
+}
+export interface DomainPolicySource {
+    readonly rules: string;
+    readonly layers: readonly DomainLayerPolicy[];
+    readonly dependencies: readonly DomainDependencyPolicy[];
+    readonly rootFiles: readonly DomainRootFilePolicy[];
+    readonly aliases: readonly DomainAliasPolicy[];
+}
+export interface DomainPolicy {
+    readonly catalog: RuleCatalog;
+    readonly digest: string;
+    readonly layers: readonly DomainLayerPolicy[];
+    readonly dependencies: readonly DomainDependencyPolicy[];
+    readonly rootFiles: readonly DomainRootFilePolicy[];
+    readonly aliases: readonly DomainAliasPolicy[];
+}

package/dist/tooling/linter/policy/index.js

@@ -0,0 +1,3 @@
+export { compileDomainPolicy } from './compile.js';
+export { compileProjectDomainPolicy, configureDomainPolicySource, DOMAIN_LINT_CONFIG, } from './configuration.js';
+export { domainPolicyDigest, domainPolicySource } from './generated.js';

package/dist/tooling/linter/qualification/index.d.ts

@@ -0,0 +1,10 @@
+export { queryQualificationFixtures } from './query-fixtures.js';
+export { runQueryQualificationFixture } from './runner.js';
+import type { QueryDefinitionObservation } from '../analysis/query/index.js';
+import type { RuleEvaluationStatus } from '../evaluation/index.js';
+export interface QueryQualificationFixture {
+    readonly id: string;
+    readonly ruleId: 'QRY-CANON' | 'QRY-SINGLE';
+    readonly observations: readonly QueryDefinitionObservation[];
+    readonly expectedStatus: RuleEvaluationStatus;
+}

package/dist/tooling/linter/qualification/index.js

@@ -0,0 +1,2 @@
+export { queryQualificationFixtures } from './query-fixtures.js';
+export { runQueryQualificationFixture } from './runner.js';

package/dist/tooling/linter/qualification/query-fixtures.d.ts

@@ -0,0 +1,2 @@
+import type { QueryQualificationFixture } from './index.js';
+export declare const queryQualificationFixtures: readonly QueryQualificationFixture[];

package/dist/tooling/linter/qualification/query-fixtures.js

@@ -0,0 +1,68 @@
+import { ambiguous, known, unknown, unsupported, } from '../analysis/query/index.js';
+const VALID = Object.freeze({
+    subjectId: 'query.valid',
+    constructorIdentity: known(Object.freeze({
+        kind: 'sdk-query',
+        canonicalId: 'astrale.sdk.defineQuery',
+        aliases: Object.freeze([]),
+    })),
+    definitionKind: known('single'),
+    canonicalRequestCount: known(1),
+    buildCallbackCount: known(1),
+    projectCallbackCount: known(1),
+});
+export const queryQualificationFixtures = Object.freeze([
+    fixture('query-canonical-known', 'QRY-CANON', VALID, 'pass'),
+    fixture('query-canonical-fail', 'QRY-CANON', { ...VALID, subjectId: 'query.noncanonical', canonicalRequestCount: known(0) }, 'fail'),
+    fixture('query-canonical-unknown', 'QRY-CANON', {
+        ...VALID,
+        subjectId: 'query.unknown',
+        canonicalRequestCount: unknown('helper return is outside the admitted value bound'),
+    }, 'indeterminate'),
+    fixture('query-canonical-ambiguous', 'QRY-CANON', {
+        ...VALID,
+        subjectId: 'query.ambiguous',
+        canonicalRequestCount: ambiguous('two canonical candidates remain'),
+    }, 'indeterminate'),
+    fixture('query-canonical-unsupported', 'QRY-CANON', {
+        ...VALID,
+        subjectId: 'query.unsupported',
+        canonicalRequestCount: unsupported('dynamic decorator rewrites the callback'),
+    }, 'indeterminate'),
+    fixture('query-alias-barrel', 'QRY-CANON', {
+        ...VALID,
+        subjectId: 'query.barrel',
+        constructorIdentity: known(Object.freeze({
+            kind: 'sdk-query',
+            canonicalId: 'astrale.sdk.defineQuery',
+            aliases: Object.freeze(['#queries/facade', 'defineQuery']),
+        })),
+    }, 'pass'),
+    fixture('query-spelling-collision', 'QRY-CANON', {
+        ...VALID,
+        subjectId: 'query.collision',
+        constructorIdentity: known(Object.freeze({ kind: 'other', displayName: 'local defineQuery' })),
+        definitionKind: known('other'),
+        canonicalRequestCount: known(0),
+    }, 'pass'),
+    fixture('query-helper-forwarding', 'QRY-CANON', {
+        ...VALID,
+        subjectId: 'query.helper',
+        canonicalRequestCount: unknown('helper forwarding exceeds the current adapter bound'),
+    }, 'indeterminate'),
+    fixture('query-single-callbacks', 'QRY-SINGLE', VALID, 'pass'),
+    fixture('query-single-fail', 'QRY-SINGLE', { ...VALID, subjectId: 'query.no-build', buildCallbackCount: known(0) }, 'fail'),
+    fixture('query-single-ambiguous-callback', 'QRY-SINGLE', {
+        ...VALID,
+        subjectId: 'query.forwarded-build',
+        buildCallbackCount: ambiguous('callback is forwarded through an unresolved binding'),
+    }, 'indeterminate'),
+]);
+function fixture(id, ruleId, observation, expectedStatus) {
+    return Object.freeze({
+        id,
+        ruleId,
+        observations: Object.freeze([Object.freeze(observation)]),
+        expectedStatus,
+    });
+}

package/dist/tooling/linter/qualification/runner.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDecision } from '../evaluation/index.js';
+import type { QueryQualificationFixture } from './index.js';
+export declare function runQueryQualificationFixture(fixture: QueryQualificationFixture): RuleDecision;

package/dist/tooling/linter/qualification/runner.js

@@ -0,0 +1,6 @@
+import { decideCanonicalQuery, decideSingleQuery } from '../analysis/query/index.js';
+export function runQueryQualificationFixture(fixture) {
+    return fixture.ruleId === 'QRY-CANON'
+        ? decideCanonicalQuery(fixture.observations)
+        : decideSingleQuery(fixture.observations);
+}

package/dist/tooling/linter/report/format.d.ts

@@ -0,0 +1,3 @@
+import type { LintResult } from '../index.js';
+import type { LintReportFormat } from './index.js';
+export declare function formatLintResult(result: LintResult, format?: LintReportFormat): string;

package/dist/tooling/linter/report/format.js

@@ -0,0 +1,32 @@
+export function formatLintResult(result, format = 'stylish') {
+    if (format === 'json')
+        return `${JSON.stringify(result, null, 2)}\n`;
+    const lines = [];
+    for (const diagnostic of result.diagnostics) {
+        const place = diagnostic.location
+            ? `${diagnostic.location.path}:${diagnostic.location.line}:${diagnostic.location.column}`
+            : result.root;
+        lines.push(`${printable(place)}  ${diagnostic.severity} ${printable(diagnostic.id)}  ${printable(diagnostic.message)}`);
+        if (diagnostic.evidence)
+            lines.push(`  ${printable(diagnostic.evidence)}`);
+    }
+    const errors = result.diagnostics.filter(({ severity }) => severity === 'error').length;
+    const warnings = result.diagnostics.filter(({ severity }) => severity === 'warning').length;
+    const indeterminate = result.diagnostics.filter(({ kind }) => kind === 'ambiguity').length;
+    const errorsInEvaluation = result.outcomes.filter(({ status }) => status === 'error').length;
+    if (lines.length)
+        lines.push('');
+    const coverage = result.coverage;
+    lines.push(errors
+        ? `✗ ${errors} ${errors === 1 ? 'error' : 'errors'}, ${warnings} ${warnings === 1 ? 'warning' : 'warnings'}, ${indeterminate} indeterminate in ${result.durationMs}ms`
+        : `✓ ${result.files} files linted in ${result.durationMs}ms (${warnings} warnings, ${indeterminate} indeterminate)`);
+    lines.push(`  coverage: ${coverage.available}/${coverage.total} available; ${coverage.unavailable} unavailable`);
+    lines.push(`  evaluation: ${result.outcomes.length} ${result.outcomes.length === 1 ? 'rule' : 'rules'} evaluated; ${errorsInEvaluation} errors; ${result.suppressed.length} suppressed; policy ${result.policyDigest}`);
+    return `${lines.join('\n')}\n`;
+}
+function printable(value) {
+    return Array.from(value, (character) => {
+        const code = character.charCodeAt(0);
+        return code <= 31 || code === 127 ? `\\u${code.toString(16).padStart(4, '0')}` : character;
+    }).join('');
+}

package/dist/tooling/linter/report/index.d.ts

@@ -0,0 +1,2 @@
+export { formatLintResult } from './format.js';
+export type LintReportFormat = 'json' | 'stylish';

package/dist/tooling/linter/report/index.js

@@ -0,0 +1 @@
+export { formatLintResult } from './format.js';

package/dist/tooling/linter/requirements/index.d.ts

@@ -0,0 +1,2 @@
+export { domainRuleRequirements, requirementsFor } from './registry.js';
+export type { RuleFactRequirement, RulePartition, RuleRequirements } from './requirement.js';

package/dist/tooling/linter/requirements/index.js

@@ -0,0 +1 @@
+export { domainRuleRequirements, requirementsFor } from './registry.js';

package/dist/tooling/linter/requirements/registry.d.ts

@@ -0,0 +1,3 @@
+import type { RuleRequirements } from './requirement.js';
+export declare const domainRuleRequirements: readonly RuleRequirements[];
+export declare function requirementsFor(ruleId: string): RuleRequirements | undefined;

package/dist/tooling/linter/requirements/registry.js

@@ -0,0 +1,181 @@
+const STRUCTURE = profile('repository', ['repository-structure']);
+const STRUCTURE_DEPENDENCY = profile('repository', [
+    'repository-structure',
+    'module-dependencies',
+    'canonical-symbols',
+]);
+const ARCHITECTURE = profile('repository', [
+    'repository-structure',
+    'module-dependencies',
+    'canonical-symbols',
+]);
+const SEMANTIC_ARCHITECTURE = profile('repository', [
+    'repository-structure',
+    'module-dependencies',
+    'canonical-symbols',
+    'call-occurrences',
+    'body-flow',
+    'bounded-values',
+]);
+const DEPENDENCY = profile('module', ['module-dependencies', 'canonical-symbols']);
+const DECLARATION = profile('symbol', ['canonical-symbols', 'bounded-values']);
+const DECLARATION_FLOW = profile('symbol', [
+    'canonical-symbols',
+    'call-occurrences',
+    'body-flow',
+    'bounded-values',
+]);
+const DATAFLOW = profile('function', [
+    'canonical-symbols',
+    'call-occurrences',
+    'body-flow',
+    'bounded-values',
+]);
+const BEHAVIOR = profile('function', [
+    'canonical-symbols',
+    'call-occurrences',
+    'body-flow',
+    'bounded-values',
+]);
+const BEHAVIOR_DEPENDENCY = profile('function', [
+    'module-dependencies',
+    'canonical-symbols',
+    'call-occurrences',
+    'body-flow',
+    'bounded-values',
+]);
+const BEHAVIOR_EVIDENCE = profile('function', [
+    'canonical-symbols',
+    'call-occurrences',
+    'body-flow',
+    'bounded-values',
+    'execution-evidence',
+]);
+const EVIDENCE = profile('repository', ['repository-structure', 'canonical-symbols']);
+export const domainRuleRequirements = Object.freeze([
+    row('OWN-SEMANTIC', ARCHITECTURE),
+    row('MOD-SUBMODULE', STRUCTURE),
+    row('MOD-REQUIRED', STRUCTURE),
+    row('MOD-GOVERNED', STRUCTURE),
+    row('ROOT-FACADE', STRUCTURE),
+    row('ROOT-COMPOSE', STRUCTURE_DEPENDENCY),
+    row('DEP-ALLOWLIST', DEPENDENCY),
+    row('IMP-FACADE', DEPENDENCY),
+    row('IMP-SDK-BOUNDARY', DEPENDENCY),
+    row('IMP-LAYER-ALIAS', DEPENDENCY),
+    row('IMP-ALIAS-CFG', DEPENDENCY),
+    row('IMP-STATIC', DEPENDENCY),
+    row('TYP-OWNER', SEMANTIC_ARCHITECTURE),
+    row('ERR-EXPECTED', DATAFLOW),
+    row('TST-NO-PROD-IMP', DEPENDENCY),
+    row('ABS-EARNED', SEMANTIC_ARCHITECTURE),
+    row('ABS-NO-REPO', SEMANTIC_ARCHITECTURE),
+    row('ABS-CANON-GRAPH', DECLARATION_FLOW),
+    row('TRUST-ADMIT-ONCE', DATAFLOW),
+    row('QLT-EXHAUSTIVE', BEHAVIOR),
+    row('QLT-CANON-VALUES', DATAFLOW),
+    row('QLT-DEF-IDS', DECLARATION),
+    row('QLT-TYPED-COORD', DECLARATION),
+    row('NODE-INHERITED', DECLARATION),
+    row('DOM-PUBLIC-DEPS', DEPENDENCY),
+    row('DOM-CALL-INT', BEHAVIOR_DEPENDENCY),
+    row('DOM-ATOMICITY', BEHAVIOR),
+    row('SCH-SUBMODULE', DECLARATION),
+    row('SCH-DECL-ONLY', DECLARATION_FLOW),
+    row('SCH-EXACT-TYPES', DECLARATION),
+    row('SCH-POLICY-AUTH', DECLARATION_FLOW),
+    row('SCH-STATE-SOURCE', DECLARATION),
+    row('STA-ONE-RELATION', DECLARATION),
+    row('STA-PURE', DECLARATION_FLOW),
+    row('RUL-SYNC', BEHAVIOR),
+    row('RUL-PURE', BEHAVIOR),
+    row('RUL-EXPL-FACTS', BEHAVIOR),
+    row('RUL-CLOSED-DEC', BEHAVIOR),
+    row('QRY-CANON', DATAFLOW, [
+        'query-canonical-known',
+        'query-canonical-fail',
+        'query-canonical-unknown',
+        'query-canonical-ambiguous',
+        'query-canonical-unsupported',
+        'query-alias-barrel',
+        'query-spelling-collision',
+        'query-helper-forwarding',
+    ]),
+    row('QRY-CONTRACT', DATAFLOW),
+    row('QRY-SINGLE', DATAFLOW, [
+        'query-single-callbacks',
+        'query-single-fail',
+        'query-single-ambiguous-callback',
+    ]),
+    row('QRY-COMPOSE-TYPED', DATAFLOW),
+    row('QRY-COMPOSE-STABLE', DATAFLOW),
+    row('QRY-PROJECT-PURE', DATAFLOW),
+    row('QRY-SNAPSHOT', DATAFLOW),
+    row('MUT-CANON', DATAFLOW),
+    row('MUT-CONTRACT', DATAFLOW),
+    row('MUT-PRECONDS', DATAFLOW),
+    row('MUT-FRAGMENTS', DATAFLOW),
+    row('MUT-PURE', DATAFLOW),
+    row('MUT-MULTI-WFL', DATAFLOW),
+    row('WFL-MULTISTEP', BEHAVIOR),
+    row('WFL-STEP-EFFECTS', BEHAVIOR),
+    row('WFL-STEP-IDS', BEHAVIOR),
+    row('WFL-NO-NEST', BEHAVIOR),
+    row('WFL-INT-TYPES', DECLARATION),
+    row('WFL-ONE-OP-STEP', BEHAVIOR),
+    row('WFL-STATE-CODEC', BEHAVIOR),
+    row('WFL-RECOVERY', BEHAVIOR),
+    row('WFL-XDOM-INT', BEHAVIOR_DEPENDENCY),
+    row('MIG-EXACT-REVS', DATAFLOW),
+    row('MIG-APP-DATA', DATAFLOW),
+    row('MIG-DEDICATED-CTX', DATAFLOW),
+    row('MIG-RESTART-SAFE', DATAFLOW),
+    row('MIG-TARGET-PROOF', BEHAVIOR_EVIDENCE),
+    row('MIG-DESTRUCTIVE', DATAFLOW),
+    row('INT-BOUNDARY', SEMANTIC_ARCHITECTURE),
+    row('INT-NEUTRAL', DECLARATION),
+    row('INT-PURE', DEPENDENCY),
+    row('INT-ABILITY-NAME', STRUCTURE),
+    row('ACT-ONE-IMPL', BEHAVIOR),
+    row('ACT-ONE-OP', BEHAVIOR),
+    row('ACT-OP-KINDS', BEHAVIOR),
+    row('ACT-BOUNDARIES', BEHAVIOR_DEPENDENCY),
+    row('PRV-INT-IMPL', SEMANTIC_ARCHITECTURE),
+    row('PRV-BOUNDARY-NAME', STRUCTURE),
+    row('PRV-ADMIT-RESULT', DATAFLOW),
+    row('PRV-NO-DOMAIN', DEPENDENCY),
+    row('PRV-XDOM-TYPED', BEHAVIOR_DEPENDENCY),
+    row('PRV-XDOM-PUBLIC', BEHAVIOR_DEPENDENCY),
+    row('VIW-PROJECTION', DECLARATION_FLOW),
+    row('VIW-SCHEMA-DECL', DECLARATION),
+    row('VIW-DEPS', DEPENDENCY),
+    row('VIW-ACTIONS', BEHAVIOR_DEPENDENCY),
+    row('UI-PRES-DEPS', DEPENDENCY),
+    row('UI-NO-DOMAIN', DEPENDENCY),
+    row('UI-PURE', BEHAVIOR),
+    row('UI-CALLBACKS', DATAFLOW),
+    row('UTL-DOM-AGNOSTIC', SEMANTIC_ARCHITECTURE),
+    row('UTL-REUSED', SEMANTIC_ARCHITECTURE),
+    row('UTL-PUBLIC-DEPS', DEPENDENCY),
+    row('UTL-LIGHTWEIGHT', SEMANTIC_ARCHITECTURE),
+    row('SCR-OPERATOR', BEHAVIOR_EVIDENCE),
+    row('SCR-PUBLIC-DEPS', BEHAVIOR_DEPENDENCY),
+    row('SCR-TEST-DRIVERS', BEHAVIOR_EVIDENCE),
+    row('TST-SYS-OWNER', EVIDENCE),
+    row('TST-COLOCATED', EVIDENCE),
+]);
+const byId = new Map(domainRuleRequirements.map((requirements) => [requirements.ruleId, requirements]));
+export function requirementsFor(ruleId) {
+    return byId.get(ruleId);
+}
+function profile(partition, facts) {
+    return Object.freeze({ partition, facts: Object.freeze([...facts]) });
+}
+function row(ruleId, requirement, fixtureIds = []) {
+    return Object.freeze({
+        ruleId,
+        partition: requirement.partition,
+        facts: requirement.facts,
+        fixtureIds: Object.freeze([...fixtureIds]),
+    });
+}

package/dist/tooling/linter/requirements/requirement.d.ts

@@ -0,0 +1,8 @@
+export type RuleFactRequirement = 'repository-structure' | 'module-dependencies' | 'canonical-symbols' | 'call-occurrences' | 'body-flow' | 'bounded-values' | 'execution-evidence';
+export type RulePartition = 'repository' | 'module' | 'file' | 'symbol' | 'function';
+export interface RuleRequirements {
+    readonly ruleId: string;
+    readonly partition: RulePartition;
+    readonly facts: readonly RuleFactRequirement[];
+    readonly fixtureIds: readonly string[];
+}

package/dist/tooling/linter/requirements/requirement.js

@@ -0,0 +1 @@
+export {};

package/dist/tooling/linter/suppression/apply.d.ts

@@ -0,0 +1,3 @@
+import type { LintDiagnostic } from '../diagnostics/index.js';
+import type { SuppressionDirective, SuppressionResult } from './index.js';
+export declare function applySuppressions(directives: readonly SuppressionDirective[], diagnostics: readonly LintDiagnostic[]): SuppressionResult;

package/dist/tooling/linter/suppression/apply.js

@@ -0,0 +1,47 @@
+export function applySuppressions(directives, diagnostics) {
+    const remaining = [...diagnostics];
+    const suppressed = [];
+    const admission = [];
+    for (const directive of directives) {
+        if (directive.error) {
+            admission.push(admissionDiagnostic('linter/suppression-invalid', directive.error, directive));
+            continue;
+        }
+        const matches = remaining.filter((diagnostic) => diagnostic.source === 'domain-rule' &&
+            diagnostic.kind === 'violation' &&
+            diagnostic.id === directive.id &&
+            diagnostic.location?.path === directive.path &&
+            diagnostic.location.line === directive.line + 1);
+        if (matches.length === 0) {
+            admission.push(admissionDiagnostic('linter/suppression-unused', `Suppression for ${directive.id} does not match a conclusive violation on the next line.`, directive));
+            continue;
+        }
+        for (const diagnostic of matches) {
+            const index = remaining.indexOf(diagnostic);
+            if (index !== -1)
+                remaining.splice(index, 1);
+            suppressed.push(Object.freeze({
+                ruleId: directive.id,
+                reason: directive.reason,
+                directive: directive.location,
+                diagnostic,
+            }));
+        }
+    }
+    return Object.freeze({
+        diagnostics: Object.freeze([...remaining, ...admission]),
+        suppressed: Object.freeze(suppressed),
+    });
+}
+function admissionDiagnostic(id, message, directive) {
+    return Object.freeze({
+        id,
+        source: 'linter',
+        scope: 'suppressions',
+        analysis: 'structure',
+        kind: 'violation',
+        severity: 'error',
+        message,
+        location: directive.location,
+    });
+}

package/dist/tooling/linter/suppression/directive.d.ts

@@ -0,0 +1,10 @@
+import type { DiagnosticLocation } from '../diagnostics/index.js';
+/** Portable observation of one authored suppression directive. */
+export interface SuppressionDirective {
+    readonly id?: string;
+    readonly reason?: string;
+    readonly path: string;
+    readonly line: number;
+    readonly location: DiagnosticLocation;
+    readonly error?: string;
+}

package/dist/tooling/linter/suppression/directive.js

@@ -0,0 +1 @@
+export {};

package/dist/tooling/linter/suppression/index.d.ts

@@ -0,0 +1,13 @@
+export { applySuppressions } from './apply.js';
+import type { DiagnosticLocation, LintDiagnostic } from '../diagnostics/index.js';
+export type { SuppressionDirective } from './directive.js';
+export interface SuppressedDiagnostic {
+    readonly ruleId: string;
+    readonly reason: string;
+    readonly directive: DiagnosticLocation;
+    readonly diagnostic: LintDiagnostic;
+}
+export interface SuppressionResult {
+    readonly diagnostics: readonly LintDiagnostic[];
+    readonly suppressed: readonly SuppressedDiagnostic[];
+}

package/dist/tooling/linter/suppression/index.js

@@ -0,0 +1 @@
+export { applySuppressions } from './apply.js';

package/dist/tooling/packaging/admission.d.ts

@@ -0,0 +1,9 @@
+interface DomainPackageManifest {
+    readonly dependencies?: Readonly<Record<string, string>>;
+    readonly devDependencies?: Readonly<Record<string, string>>;
+    readonly optionalDependencies?: Readonly<Record<string, string>>;
+    readonly peerDependencies?: Readonly<Record<string, string>>;
+}
+/** Admit the one-SDK product-Domain boundary before compilation or normalization. */
+export declare function admitDomainPackage(project: string, manifest: DomainPackageManifest): void;
+export {};

package/dist/tooling/packaging/admission.js

@@ -0,0 +1,93 @@
+import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+import ts from 'typescript';
+/** Admit the one-SDK product-Domain boundary before compilation or normalization. */
+export function admitDomainPackage(project, manifest) {
+    for (const dependencies of [
+        manifest.dependencies,
+        manifest.devDependencies,
+        manifest.optionalDependencies,
+        manifest.peerDependencies,
+    ]) {
+        const dependency = Object.keys(dependencies ?? {}).find(isKernelSpecifier);
+        if (dependency !== undefined) {
+            throw new TypeError(`Product Domain declares a Kernel package directly: ${dependency}.`);
+        }
+    }
+    for (const document of sourceDocuments(project)) {
+        const file = document.fileName;
+        let direct;
+        visit(document);
+        if (direct !== undefined) {
+            throw new TypeError(`Product Domain imports a Kernel package directly: ${direct} in ${file}.`);
+        }
+        function visit(node) {
+            if (direct !== undefined)
+                return;
+            const specifier = moduleSpecifier(node);
+            if (specifier !== undefined && isKernelSpecifier(specifier))
+                direct = specifier;
+            else
+                ts.forEachChild(node, visit);
+        }
+    }
+}
+function sourceDocuments(root) {
+    const project = resolve(root);
+    const configuration = join(project, 'tsconfig.json');
+    const loaded = ts.readConfigFile(configuration, ts.sys.readFile);
+    if (loaded.error !== undefined)
+        failConfiguration(project, [loaded.error]);
+    const parsed = ts.parseJsonConfigFileContent(loaded.config, ts.sys, project, undefined, configuration);
+    const errors = parsed.errors.filter(({ category }) => category === ts.DiagnosticCategory.Error);
+    if (errors.length > 0)
+        failConfiguration(project, errors);
+    const program = ts.createProgram(parsed.fileNames, parsed.options);
+    return program
+        .getSourceFiles()
+        .filter(({ fileName }) => {
+        const path = relative(project, fileName);
+        return (path !== '..' &&
+            !path.startsWith(`..${sep}`) &&
+            !isAbsolute(path) &&
+            path !== 'node_modules' &&
+            !path.startsWith(`node_modules${sep}`));
+    })
+        .sort((left, right) => left.fileName.localeCompare(right.fileName));
+}
+function moduleSpecifier(node) {
+    if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
+        node.moduleSpecifier !== undefined &&
+        ts.isStringLiteral(node.moduleSpecifier)) {
+        return node.moduleSpecifier.text;
+    }
+    if (ts.isImportTypeNode(node) &&
+        ts.isLiteralTypeNode(node.argument) &&
+        ts.isStringLiteral(node.argument.literal)) {
+        return node.argument.literal.text;
+    }
+    if (ts.isCallExpression(node) &&
+        node.arguments.length === 1 &&
+        ts.isStringLiteral(node.arguments[0]) &&
+        (node.expression.kind === ts.SyntaxKind.ImportKeyword ||
+            (ts.isIdentifier(node.expression) && node.expression.text === 'require'))) {
+        return node.arguments[0].text;
+    }
+    if (ts.isImportEqualsDeclaration(node) &&
+        ts.isExternalModuleReference(node.moduleReference) &&
+        node.moduleReference.expression !== undefined &&
+        ts.isStringLiteral(node.moduleReference.expression)) {
+        return node.moduleReference.expression.text;
+    }
+    return undefined;
+}
+function isKernelSpecifier(specifier) {
+    return /^@astrale-os\/kernel(?:-|\/|$)/u.test(specifier);
+}
+function failConfiguration(project, diagnostics) {
+    const detail = ts.formatDiagnostics(diagnostics, {
+        getCanonicalFileName: (file) => file,
+        getCurrentDirectory: () => project,
+        getNewLine: () => '\n',
+    });
+    throw new TypeError(`Product Domain source configuration is invalid.\n${detail}`);
+}

package/dist/tooling/packaging/compile.d.ts

@@ -0,0 +1,8 @@
+export interface DomainPackageCompilation {
+    readonly root: string;
+}
+export interface DomainPackageCompilationInput {
+    readonly declarations: readonly string[];
+}
+/** Compile one Domain's public runtime package from its dedicated package config. */
+export declare function compileDomainPackage(projectDir: string, input: DomainPackageCompilationInput): DomainPackageCompilation;